package service

import (
	"fmt"
	"time"

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

//OrderService 管理员相关服务
type OrderInfoService struct {
}

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

// PageListOrderBase 获取订单列表
func (service OrderInfoService) PageListOrderBase(listOrderQuery query.ListOrderBaseQuery) ([]domain.OrderBase, int, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, 0, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
	}
	var (
		orderRepository domain.OrderBaseRepository
		orders          []domain.OrderBase
		cnt             int
	)
	if value, err := factory.CreateOrderBaseRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, 0, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		orderRepository = value
	}
	query := domain.OrderBaseFindQuery{
		PartnerId:    listOrderQuery.PartnerId,
		OrderCode:    listOrderQuery.OrderCode,
		Offset:       listOrderQuery.Offset,
		Limit:        listOrderQuery.Limit,
		OrderType:    listOrderQuery.OrderType,
		DeliveryCode: listOrderQuery.DeliveryCode,
	}
	orders, cnt, err = orderRepository.Find(query)
	if err != nil {
		return nil, 0, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	var PartnerInfoRepository domain.PartnerInfoRepository
	if PartnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, 0, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	for i := range orders {
		var partnerData *domain.PartnerInfo
		partnerData, err = PartnerInfoRepository.FindOne(domain.PartnerFindOneQuery{
			UserId: orders[i].PartnerId,
		})
		if err != nil {
			return nil, 0, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
		}
		orders[i].PartnerInfo = partnerData.Partner
	}
	return orders, cnt, nil
}

//GetOrderDetail 获取订单详情
func (service OrderInfoService) GetOrderDetail(getOrderQuery query.GetOrderQuery) (*domain.OrderBase, error) {
	//实际业务
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
	}
	var (
		orderBaseRepository   domain.OrderBaseRepository
		PartnerInfoRepository domain.PartnerInfoRepository
		orderGoodRepository   domain.OrderGoodRepository
		order                 *domain.OrderBase
	)
	if err = transactionContext.StartTransaction(); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	if value, err := factory.CreateOrderBaseRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		orderBaseRepository = value
	}
	if PartnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	if orderGoodRepository, err = factory.CreateOrderGoodRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	order, err = orderBaseRepository.FindOne(domain.OrderBaseFindOneQuery{
		OrderId: getOrderQuery.OrderId,
	})
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("获取订单数据失败：%s", err))
	}
	var (
		partnerData *domain.PartnerInfo
		goods       []domain.OrderGood
	)

	partnerData, err = PartnerInfoRepository.FindOne(domain.PartnerFindOneQuery{UserId: order.PartnerId})
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("检索合伙人数据失败：%s", err))
	}
	order.PartnerInfo = partnerData.Partner
	goods, _, err = orderGoodRepository.Find(domain.OrderGoodFindQuery{
		OrderId: order.Id,
	})
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("获取订单中的商品列表失败：%s", err))
	}
	order.Goods = goods
	err = transactionContext.CommitTransaction()
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	return order, nil
}

func (service OrderInfoService) CreateNewOrder(cmd command.CreateOrderCommand) (*domain.OrderBase, error) {
	var (
		transactionContext, _ = factory.CreateTransactionContext(nil)
		err                   error
	)

	if err = transactionContext.StartTransaction(); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	// orderDao, _ := factory.CreateOrderDao(map[string]interface{}{"transactionContext": transactionContext})
	// ok, err := orderDao.OrderCodeIsExist(command.OrderCode, 0)
	// if err != nil {
	// 	return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	// }
	// if ok {
	// 	return lib.ThrowError(lib.BUSINESS_ERROR, "订单编号已存在")
	// }
	var PartnerInfoRepository domain.PartnerInfoRepository
	if PartnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	var partnerData *domain.PartnerInfo
	partnerData, err = PartnerInfoRepository.FindOne(domain.PartnerFindOneQuery{UserId: cmd.PartnerId})
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("检索合伙人数据失败"))
	}
	var (
		orderBaseRepository domain.OrderBaseRepository
		orderGoodRepository domain.OrderGoodRepository
	)
	if orderBaseRepository, err = factory.CreateOrderBaseRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	if orderGoodRepository, err = factory.CreateOrderGoodRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	newOrder := &domain.OrderBase{
		OrderType: cmd.OrderType, OrderCode: cmd.OrderCode,
		DeliveryCode: cmd.DeliveryCode,
		Buyer: &domain.Buyer{
			BuyerName: cmd.BuyerName,
		},
		RegionInfo: &domain.RegionInfo{
			RegionName: cmd.OrderRegion,
		},
		PartnerId:            cmd.PartnerId,
		PartnerInfo:          partnerData.Partner,
		SalesmanBonusPercent: cmd.SalesmanBonusPercent,
	}
	var orderGoods []domain.OrderGood
	for _, good := range cmd.Goods {
		m := domain.NewOrderGood()
		m.OrderId = 0
		m.GoodName = good.GoodName
		m.PlanGoodNumber = good.PlanGoodNumber
		m.Price = good.Price
		m.PartnerBonusPercent = good.PartnerBonusPercent
		m.Remark = good.Remark
		err = m.Compute()
		if err != nil {
			return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中商品的数值失败：%s", err))
		}
		err = m.CurrentBonusStatus.WartPayPartnerBonus(&m)
		if err != nil {
			return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中商品的分红数值失败：%s", err))
		}
		orderGoods = append(orderGoods, m)
	}
	newOrder.Goods = orderGoods
	err = newOrder.Compute()
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中合计的数值失败：%s", err))
	}
	err = orderBaseRepository.Save(newOrder)
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("保存订单数据失败：%s", err))
	}
	for i := range newOrder.Goods {
		newOrder.Goods[i].OrderId = newOrder.Id
	}
	err = orderGoodRepository.Save(orderGoods)
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("保存订单中的商品数据失败：%s", err))
	}
	newOrder.Goods = orderGoods
	err = transactionContext.CommitTransaction()
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	return newOrder, nil
}

//DeleteOrder 删除订单
func (service OrderInfoService) DeleteOrder(orderId int64) 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 (
		orderBaseRepository domain.OrderBaseRepository
		orderGoodRepository domain.OrderGoodRepository
	)
	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())
	}
	err = orderBaseRepository.Remove(orderId)
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("删除订单数据失败：%s", err))
	}
	err = orderGoodRepository.Remove(orderId)
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("删除订单中商品数据失败：%s", err))
	}
	err = transactionContext.CommitTransaction()
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	return nil
}

//UpdateOrderData 编辑订单
func (service OrderInfoService) UpdateOrderData(cmd command.UpdateOrderCommand) (*domain.OrderBase, error) {
	var (
		transactionContext, _ = factory.CreateTransactionContext(nil)
		err                   error
	)

	if err = transactionContext.StartTransaction(); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	// orderDao, _ := factory.CreateOrderDao(map[string]interface{}{"transactionContext": transactionContext})
	// ok, err := orderDao.OrderCodeIsExist(command.OrderCode, 0)
	// if err != nil {
	// 	return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	// }
	// if ok {
	// 	return lib.ThrowError(lib.BUSINESS_ERROR, "订单编号已存在")
	// }
	var PartnerInfoRepository domain.PartnerInfoRepository
	if PartnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	var partnerData *domain.PartnerInfo
	partnerData, err = PartnerInfoRepository.FindOne(domain.PartnerFindOneQuery{UserId: cmd.PartnerId})
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("检索合伙人数据失败"))
	}
	var (
		orderBaseRepository domain.OrderBaseRepository
		orderGoodRepository domain.OrderGoodRepository
		oldOrderData        *domain.OrderBase
		oldOrderGoods       []domain.OrderGood
		newOrderGoods       []domain.OrderGood
		delGoods            []int64
	)
	if orderBaseRepository, err = factory.CreateOrderBaseRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	if orderGoodRepository, err = factory.CreateOrderGoodRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	//获取旧的订单
	oldOrderData, err = orderBaseRepository.FindOne(domain.OrderBaseFindOneQuery{
		OrderId: cmd.Id,
	})
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("未找到指定的订单:%s", err))
	}
	//判定要求的更新的订单类型
	if oldOrderData.OrderType != cmd.OrderType {
		return nil, lib.ThrowError(lib.BUSINESS_ERROR, fmt.Sprintf("操作失败，待更新的订单的类型已变更"))
	}
	//获取旧的订单中的商品
	oldOrderGoods, _, err = orderGoodRepository.Find(domain.OrderGoodFindQuery{
		OrderId: cmd.Id,
	})
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("未找到指定的订单中的商品列表失败:%s", err))
	}
	for _, good := range cmd.Goods {
		m := domain.NewOrderGood()
		m.OrderId = oldOrderData.Id
		m.GoodName = good.GoodName
		m.PlanGoodNumber = good.PlanGoodNumber
		m.Price = good.Price
		m.PartnerBonusPercent = good.PartnerBonusPercent
		m.Remark = good.Remark
		err = m.Compute()
		if err != nil {
			return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中商品的数值失败：%s", err))
		}
		err = m.CurrentBonusStatus.WartPayPartnerBonus(&m)
		if err != nil {
			return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中商品的分红数值失败：%s", err))
		}
		newOrderGoods = append(newOrderGoods, m)
	}
	oldOrderData.OrderCode = cmd.OrderCode
	oldOrderData.DeliveryCode = cmd.DeliveryCode
	oldOrderData.Buyer.BuyerName = cmd.BuyerName
	oldOrderData.RegionInfo.RegionName = cmd.OrderRegion
	oldOrderData.PartnerId = cmd.PartnerId
	oldOrderData.PartnerInfo = partnerData.Partner
	oldOrderData.SalesmanBonusPercent = cmd.SalesmanBonusPercent
	oldOrderData.Goods = newOrderGoods
	err = oldOrderData.Compute()
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中合计的数值失败：%s", err))
	}

	err = orderBaseRepository.Save(oldOrderData)
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("保存订单数据失败：%s", err))
	}
	err = orderGoodRepository.Save(newOrderGoods)
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("保存订单中的商品数据失败：%s", err))
	}
	oldOrderData.Goods = newOrderGoods
	//删不需要的订单总不需要的商品
	delGoods = service.deleteOldOrderGoods(newOrderGoods, oldOrderGoods)
	err = orderGoodRepository.Remove(oldOrderData.Id, delGoods...)
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("删除订单中的商品数据失败：%s", err))
	}
	err = transactionContext.CommitTransaction()
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	return oldOrderData, nil
}

//deleteOldOrderGoods 新旧商品列表对比
func (service OrderInfoService) deleteOldOrderGoods(newGoods []domain.OrderGood, oldGoods []domain.OrderGood) (goodIds []int64) {
	for _, old := range oldGoods {
		var hasIn bool
		for _, new := range newGoods {
			if old.Id == new.Id {
				hasIn = true
				break
			}
		}
		if !hasIn {
			goodIds = append(goodIds, old.Id)
		}
	}
	return
}

//Delivery 发货
func (service OrderInfoService) Delivery(cmd command.OrderDeliveryCommand) 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 (
		orderBaseRepository domain.OrderBaseRepository
		orderGoodRepository domain.OrderGoodRepository
		oldOrderData        *domain.OrderBase
		oldOrderGoods       []domain.OrderGood
	)
	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())
	}
	//获取旧的订单
	oldOrderData, err = orderBaseRepository.FindOne(domain.OrderBaseFindOneQuery{
		OrderId: cmd.OrderId,
	})
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("未找到指定的订单:%s", err))
	}
	//获取旧的订单中的商品
	oldOrderGoods, _, err = orderGoodRepository.Find(domain.OrderGoodFindQuery{
		OrderId: cmd.OrderId,
	})
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("未找到指定的订单中的商品列表失败:%s", err))
	}
	for _, newGood := range cmd.Goods {
		for i := range oldOrderGoods {
			if newGood.Id != oldOrderGoods[i].Id {
				continue
			}
			oldOrderGoods[i].GoodName = newGood.GoodName
			oldOrderGoods[i].PlanGoodNumber = newGood.PlanGoodNumber
			oldOrderGoods[i].Price = newGood.Price
			oldOrderGoods[i].PartnerBonusPercent = newGood.PartnerBonusPercent
			oldOrderGoods[i].Remark = newGood.Remark
			err = oldOrderGoods[i].Compute()
			if err != nil {
				return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中商品的数值失败：%s", err))
			}
			err = oldOrderGoods[i].CurrentBonusStatus.WartPayPartnerBonus(&oldOrderGoods[i])
			if err != nil {
				return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中商品的分红数值失败：%s", err))
			}
		}
	}
	oldOrderData.DeliveryCode = cmd.DeliveryCode
	oldOrderData.DeliveryTime = time.Now()
	//变更订单类型
	oldOrderData.OrderType = domain.OrderReal
	err = oldOrderData.Compute()
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中合计的数值失败：%s", err))
	}
	err = orderBaseRepository.Save(oldOrderData)
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("保存订单数据失败：%s", err))
	}
	err = orderGoodRepository.Save(oldOrderGoods)
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("保存订单中的商品数据失败：%s", err))
	}
	err = transactionContext.CommitTransaction()
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	return nil
}

//DisableOrEnable 开启关闭订单
func (service OrderInfoService) DisableOrEnable(cmd command.DisableOrderCommand) 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 (
		orderBaseRepository domain.OrderBaseRepository
		oldOrderData        *domain.OrderBase
	)
	if orderBaseRepository, err = factory.CreateOrderBaseRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	//获取旧的订单
	oldOrderData, err = orderBaseRepository.FindOne(domain.OrderBaseFindOneQuery{
		OrderId: cmd.OrderId,
	})
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("未找到指定的订单:%s", err))
	}
	if oldOrderData.OrderType != cmd.OrderType {
		return lib.ThrowError(lib.BUSINESS_ERROR, fmt.Sprintf("操作失败，指定的订单的类型发生变更"))
	}
	oldOrderData.IsDisable = cmd.IsDisable
	err = orderBaseRepository.Save(oldOrderData)
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("保存订单数据失败：%s", err))
	}
	err = transactionContext.CommitTransaction()
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	return nil
}