package logic

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"fusenapi/model/gmodel"
	"fusenapi/server/shopping-cart/internal/svc"
	"fusenapi/server/shopping-cart/internal/types"
	"fusenapi/utils/auth"
	"fusenapi/utils/basic"
	"fusenapi/utils/format"
	"gorm.io/gorm"

	"github.com/zeromicro/go-zero/core/logx"
)

type CalculateCartPriceLogic struct {
	logx.Logger
	ctx    context.Context
	svcCtx *svc.ServiceContext
}

func NewCalculateCartPriceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CalculateCartPriceLogic {
	return &CalculateCartPriceLogic{
		Logger: logx.WithContext(ctx),
		ctx:    ctx,
		svcCtx: svcCtx,
	}
}

// 处理进入前逻辑w,r
// func (l *CalculateCartPriceLogic) BeforeLogic(w http.ResponseWriter, r *http.Request) {
// }

func (l *CalculateCartPriceLogic) CalculateCartPrice(req *types.CalculateCartPriceReq, userinfo *auth.UserInfo) (resp *basic.Response) {
	if !userinfo.IsUser() {
		return resp.SetStatusWithMessage(basic.CodeUnAuth, "please sign in")
	}
	if len(req.CalculateList) == 0 {
		return resp.SetStatusWithMessage(basic.CodeOK, "success", types.CalculateCartPriceRsp{CalculateResultList: []types.CalculateResultItem{}})
	}
	cartIds := make([]int64, 0, len(req.CalculateList))
	mapCalculateQuantity := make(map[int64]types.CalculateItem)
	for _, v := range req.CalculateList {
		cartIds = append(cartIds, v.CartId)
		if v.PurchaseQuantity <= 0 {
			return resp.SetStatusWithMessage(basic.CodeRequestParamsErr, "purchase quantity must grater than 0")
		}
		mapCalculateQuantity[v.CartId] = v
	}
	//获取购物车列表
	carts, _, err := l.svcCtx.AllModels.FsShoppingCart.GetAllCartsByParam(l.ctx, gmodel.GetAllCartsByParamReq{
		Ids:    cartIds,
		Fields: "id,size_id,product_id,fitting_id,model_id",
		UserId: userinfo.UserId,
		Page:   1,
		Limit:  len(cartIds),
	})
	if err != nil {
		logx.Error(err)
		return resp.SetStatusWithMessage(basic.CodeDbSqlErr, "failed to get cart list")
	}
	if len(carts) < len(req.CalculateList) {
		return resp.SetStatusWithMessage(basic.CodeRequestParamsErr, "please refresh page for the shopping cart has changed!!")
	}
	sizeIds := make([]int64, 0, len(carts))
	productIds := make([]int64, 0, len(carts))
	modelIds := make([]int64, 0, len(carts)) //模型+配件
	for _, v := range carts {
		sizeIds = append(sizeIds, *v.SizeId)
		productIds = append(productIds, *v.ProductId)
		modelIds = append(modelIds, *v.ModelId)
		if *v.FittingId > 0 {
			modelIds = append(modelIds, *v.FittingId)
		}
	}
	//获取配件列表(只有id跟价格)
	modelList, err := l.svcCtx.AllModels.FsProductModel3d.GetAllByIds(l.ctx, modelIds, "id,step_price,price")
	if err != nil {
		logx.Error(err)
		return resp.SetStatusWithMessage(basic.CodeDbSqlErr, "failed to get model list")
	}
	mapModel := make(map[int64]gmodel.FsProductModel3d)
	for _, v := range modelList {
		mapModel[v.Id] = v
	}
	//开始计算价格
	calculateResultList := make([]types.CalculateResultItem, 0, len(req.CalculateList))
	subTotalPrice := int64(0)
	//开启事物
	err = l.svcCtx.MysqlConn.Transaction(func(tx *gorm.DB) error {
		shoppingCartModel := gmodel.NewFsShoppingCartModel(tx)
		for _, cart := range carts {
			modelInfo, ok := mapModel[*cart.ModelId]
			if !ok {
				return err
			}
			var stepPrice gmodel.StepPriceJsonStruct
			if modelInfo.StepPrice != nil && len(*modelInfo.StepPrice) != 0 {
				if err = json.Unmarshal(*modelInfo.StepPrice, &stepPrice); err != nil {
					logx.Error(err)
					return err
				}
			}
			//请求的数量
			reqPurchaseQuantity := mapCalculateQuantity[cart.Id].PurchaseQuantity
			isSelected := int64(0)
			if mapCalculateQuantity[cart.Id].IsSelected {
				isSelected = 1
			}
			//如果有配件，单价也要加入配件价格
			fittingPrice := int64(0)
			if *cart.FittingId > 0 {
				if fittingInfo, ok := mapModel[*cart.FittingId]; ok {
					fittingPrice = *fittingInfo.Price
				} else {
					logx.Error(fmt.Sprintf("cart contain some one witch lose fitting:%d", *cart.FittingId))
				}
			}
			//计算价格
			totalPrice, itemPrice, err := l.svcCtx.Repositories.NewShoppingCart.CaculateStepPrice(reqPurchaseQuantity, stepPrice, fittingPrice)
			if err != nil {
				return err
			}
			calculateResultList = append(calculateResultList, types.CalculateResultItem{
				CartId:     cart.Id,
				ItemPrice:  format.NumToStringWithThousandthPercentile(format.CentitoDollar(itemPrice, 3)),
				TotalPrice: format.NumToStringWithThousandthPercentile(format.CentitoDollarWithNoHalfAdjust(totalPrice, 2)),
			})
			updData := &gmodel.FsShoppingCart{
				PurchaseQuantity: &reqPurchaseQuantity,
				IsSelected:       &isSelected,
			}
			//如果是选中则累加总价
			if isSelected == 1 {
				subTotalPrice += totalPrice
			}
			//更新购物车购买数量
			if err = shoppingCartModel.Update(l.ctx, cart.Id, userinfo.UserId, updData); err != nil {
				logx.Error(err)
				return errors.New(fmt.Sprintf("failed to update cart`s purchase quantity:%d", cart.Id))
			}
		}
		return nil
	})
	if err != nil {
		logx.Error(err)
		return resp.SetStatusWithMessage(basic.CodeDbSqlErr, err.Error())
	}
	return resp.SetStatusWithMessage(basic.CodeOK, "success", types.CalculateCartPriceRsp{
		SubTotalPrice:       format.NumToStringWithThousandthPercentile(format.CentitoDollarWithNoHalfAdjust(subTotalPrice, 2)),
		CalculateResultList: calculateResultList,
	})
}

// 处理逻辑后 w,r 如:重定向, resp 必须重新处理
// func (l *CalculateCartPriceLogic) AfterLogic(w http.ResponseWriter, r *http.Request, resp *basic.Response) {
// // httpx.OkJsonCtx(r.Context(), w, resp)
// }