package service

import (
	"fmt"
	"time"

	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/dao"

	"github.com/astaxie/beego/logs"

	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/factory"
	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/syncOrder/command"
	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/lib"
)

//从其他系统接收订单数据
const (
	BEST_SHOP_UNIONID string = "gh_18eb644002fb" //海鲜干货小程序原始id
)

type SyncOrderService struct {
}

func NewOrderInfoService(option map[string]interface{}) *SyncOrderService {
	newService := new(SyncOrderService)
	return newService
}

//SyncOrderFromBestshop 接收来源于xiangmi小程序的订单数据
func (s SyncOrderService) SyncOrderFromBestshop(cmd command.CreateOrderFromBestshop) error {
	var (
		transactionContext, _ = factory.CreateTransactionContext(nil)
		err                   error
	)
	if err = transactionContext.StartTransaction(); err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	//检查账号是否存在
	var (
		orderBestshopDao *dao.OrderBestshopDao
	)
	if orderBestshopDao, err = factory.CreateOrderBestshopDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
	}
	ok, err := orderBestshopDao.OrderExist(cmd.OrderCode)
	if err != nil {
		return lib.ThrowError(lib.TRANSACTION_ERROR, "orderBestshopDao.OrderExist err:"+err.Error())
	}
	if ok {
		logs.Info("订单已存在，order_code=%s", cmd.OrderCode)
		return nil
	}
	err = transactionContext.CommitTransaction()
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	err = s.CreateOrderFromBestshop(cmd)
	return err
}

func (s SyncOrderService) CreateOrderFromBestshop(cmd command.CreateOrderFromBestshop) error {
	var (
		transactionContext, _ = factory.CreateTransactionContext(nil)
		err                   error
	)
	if err = transactionContext.StartTransaction(); err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	var (
		orderBestshopRepository     domain.OrderBestshopRepository
		orderGoodBestshopRepository domain.OrderGoodBestshopRepository
	)
	if orderBestshopRepository, err = factory.CreateOrderBestshopRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	if orderGoodBestshopRepository, err = factory.CreateOrderGoodBestshopRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	order := domain.OrderBestShop{
		OrderCode:     cmd.OrderCode,
		OrderTime:     cmd.OrderTime,
		OrderState:    cmd.OrderState,
		OrderCount:    cmd.OrderCount,
		OrderAmount:   cmd.OrderAmount,
		CreateTime:    time.Now(),
		PartnerId:     cmd.PartnerId,
		BuyerName:     cmd.BuyerName,
		BuyerPhone:    cmd.BuyerPhone,
		BuyerAddress:  cmd.BuyerAddress,
		BuyerRemark:   cmd.BuyerRemark,
		BuyerId:       cmd.BuyerId,
		DeliveryState: cmd.DeliveryState,
		DeliveryTime:  cmd.DeliveryTime,
		IsCopy:        false,
		CompanyId:     cmd.CompanyId,
	}
	err = orderBestshopRepository.Add(&order)
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, "添加order_bestshop失败："+err.Error())
	}
	goods := []domain.OrderGoodBestShop{}
	for i := range cmd.Goods {
		good := domain.OrderGoodBestShop{
			OrderId: order.Id,
			Sn:      cmd.Goods[i].Sn,
			Bn:      cmd.Goods[i].Bn,
			Name:    cmd.Goods[i].Name,
			Price:   cmd.Goods[i].Price,
			Nums:    cmd.Goods[i].Nums,
			Amount:  cmd.Goods[i].Amount,
		}
		err = orderGoodBestshopRepository.Add(&good)
		if err != nil {
			return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, "添加order_good失败："+err.Error())
		}
		goods = append(goods, good)
	}
	order.Goods = goods
	err = transactionContext.CommitTransaction()
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	if cmd.PartnerId <= 0 {
		logs.Info("[SyncOrderFromBestshop] PartnerId<=0 ，不复制订单数据")
		return nil
	}
	err = s.copyOrderBestshopToOrderBase(&order)
	return err
}

//copyOrderBestshopToOrderBase 复制数据
func (s SyncOrderService) copyOrderBestshopToOrderBase(orderBestshop *domain.OrderBestShop) error {
	var (
		transactionContext, _ = factory.CreateTransactionContext(nil)
		err                   error
	)
	if err = transactionContext.StartTransaction(); err != nil {
		return lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	var (
		orderBaseRepository     domain.OrderBaseRepository
		orderGoodRepository     domain.OrderGoodRepository
		orderBestshopRepository domain.OrderBestshopRepository
		partnerRepository       domain.PartnerInfoRepository
		companyRepository       domain.CompanyRepository
	)
	if orderBaseRepository, err = factory.CreateOrderBaseRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	if orderGoodRepository, err = factory.CreateOrderGoodRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	if partnerRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	if companyRepository, err = factory.CreateCompanyRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	if orderBestshopRepository, err = factory.CreateOrderBestshopRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	var (
		partnerData  *domain.PartnerInfo
		companyData  domain.Company
		canCopyOrder bool
	)
	partnerData, err = partnerRepository.FindOne(domain.PartnerFindOneQuery{UserId: orderBestshop.PartnerId})
	if err != nil {
		e := fmt.Sprintf("未找到指定的合伙人(id=%d)数据,%s", orderBestshop.PartnerId, err)
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
	}
	companyData, err = companyRepository.FindOne(domain.CompanyFindOneOptions{
		Id: partnerData.CompanyId,
	})
	if err != nil {
		e := fmt.Sprintf("未找到指定的合伙人的公司(partner_id=%d,company_id=%d)数据,%s", orderBestshop.PartnerId, partnerData.CompanyId, err)
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
	}
	for _, v := range companyData.Applets {
		if v.Id == BEST_SHOP_UNIONID {
			canCopyOrder = true
		}
	}
	if !canCopyOrder {
		logs.Warning("公司未设置xiangmi小程序原始id; order_bestshop.id=%d", orderBestshop.Id)
		return nil
	}
	var (
		orderbase  domain.OrderBase
		ordergoods []domain.OrderGood
	)
	//TODO 添加orderBase
	orderBestshop.CopyToOrderBase(&orderbase)
	orderbase.CompanyId = companyData.Id
	for i := range orderBestshop.Goods {
		good := domain.NewOrderGood()
		orderBestshop.Goods[i].CopyToOrderGood(&good)
		good.OrderId = orderbase.Id
		good.Compute()
		good.CurrentBonusStatus.WartPayPartnerBonus(&good)
		ordergoods = append(ordergoods, good)
	}
	orderbase.Goods = ordergoods
	orderbase.PartnerId = orderBestshop.PartnerId
	orderbase.Compute()
	err = orderBaseRepository.Save(&orderbase)
	if err != nil {
		e := fmt.Sprintf("添加order_base数据失败%s", err)
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
	}
	for i := range ordergoods {
		ordergoods[i].OrderId = orderbase.Id
	}
	// 添加goods
	err = orderGoodRepository.Save(ordergoods)
	if err != nil {
		e := fmt.Sprintf("添加order_good数据失败%s", err)
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
	}
	// 更新isCopy
	orderBestshop.IsCopy = true
	err = orderBestshopRepository.Edit(orderBestshop)
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	err = transactionContext.CommitTransaction()
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	return nil
}

// func (s SyncOrderService) UpdateOrderFromBestshop(cmd command.CreateOrderFromBestshop) error {
// 	var (
// 		transactionContext, _ = factory.CreateTransactionContext(nil)
// 		err                   error
// 	)
// 	if err = transactionContext.StartTransaction(); err != nil {
// 		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
// 	}
// 	defer func() {
// 		transactionContext.RollbackTransaction()
// 	}()
// 	var (
// 		orderBestshopRepository     domain.OrderBestshopRepository
// 		orderGoodBestshopRepository domain.OrderGoodBestshopRepository
// 	)
// 	if orderBestshopRepository, err = factory.CreateOrderBestshopRepository(map[string]interface{}{
// 		"transactionContext": transactionContext,
// 	}); err != nil {
// 		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
// 	}
// 	if orderGoodBestshopRepository, err = factory.CreateOrderGoodBestshopRepository(map[string]interface{}{
// 		"transactionContext": transactionContext,
// 	}); err != nil {
// 		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
// 	}
// 	var (
// 		orderData  *domain.OrderBestShop
// 		orderGoods []domain.OrderGoodBestShop
// 	)
// 	orderData, err = orderBestshopRepository.FindOne(domain.OrderBestshopFindOneQuery{
// 		OrderCode: cmd.OrderCode,
// 	})
// 	if err != nil {
// 		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, "获取orderBestshop（order_code=%s）数据失败,err=%s", cmd.OrderCode, err.Error())
// 	}

// 	orderData.OrderCode = cmd.OrderCode
// 	orderData.OrderTime = cmd.OrderTime
// 	orderData.OrderState = cmd.OrderState
// 	orderData.OrderCount = cmd.OrderCount
// 	orderData.OrderAmount = cmd.OrderAmount
// 	orderData.PartnerId = cmd.PartnerId
// 	orderData.BuyerName = cmd.BuyerName
// 	orderData.BuyerPhone = cmd.BuyerPhone
// 	orderData.BuyerAddress = cmd.BuyerAddress
// 	orderData.BuyerRemark = cmd.BuyerRemark
// 	orderData.BuyerId = cmd.BuyerId
// 	orderData.DeliveryState = cmd.DeliveryState
// 	orderData.DeliveryTime = cmd.DeliveryTime
// 	orderData.CompanyId = cmd.CompanyId
// 	err = orderBestshopRepository.Edit(orderData)
// 	if err != nil {
// 		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, "添加order_bestshop失败："+err.Error())
// 	}
// 	orderGoods, err = orderGoodBestshopRepository.Find(domain.OrderGoodBestshopFindQuery{
// 		OrderId: orderData.Id,
// 	})
// 	if err != nil {
// 		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, "获取orderGoodBestshop（order_id=%s）数据失败,err=%s", orderData.Id, err.Error())
// 	}

// 	for i := range orderGoods {
// 		var updated bool
// 		for ii := range cmd.Goods {
// 			if cmd.Goods[ii].Sn != orderGoods[i].Sn {
// 				continue
// 			}
// 			good := orderGoods[i]
// 			good.Sn=   cmd.Goods[i].Sn,
// 			good.Bn=      cmd.Goods[i].Bn,
// 			good.Name=   cmd.Goods[i].Name,
// 			good.Price   cmd.Goods[i].Price,
// 			good.Nums:    cmd.Goods[i].Nums,
// 			good.Amount:  cmd.Goods[i].Amount,
// 		}
// 		err = orderGoodBestshopRepository.Edit(&orderGoods[i])
// 		if err != nil {
// 			logs.Error("更新order_good_bestshop失败：" + err.Error())

// 		}
// 	}
// 	err = transactionContext.CommitTransaction()
// 	if err != nil {
// 		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
// 	}
// 	return nil
// }