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
	}

	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,
	}
	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())
	}
	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.Id})
	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()
		ordergoods = append(ordergoods, good)
	}
	orderbase.Goods = ordergoods
	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
}