package logic

import (
	"context"
	"lone-services/pkg/modelbase"
	"lone-services/pkg/utils"
	"lone-services/services/order/internal/dao"
	"lone-services/services/order/internal/model"
	"lone-services/services/order/validator"
	"strconv"
	"strings"

	"lone-services/rpc/order/pb"
	"lone-services/services/order/internal/svc"

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

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

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

func (l *ApiSupplyLogic) ApiSupply(in *order.ApiSupplyRequest) (*order.Response, error) {
	var v validator.SupplyValidator
	if fail := l.checkParams(in, &v); fail != nil {
		return fail, nil
	}
	adminInfo := utils.GetUserFromCtx(l.ctx)
	if adminInfo.ID < utils.NumberOne {
		return l.fail(utils.ErrorNoLoginInfo)
	}

	w := modelbase.Params{Eq: map[string]string{
		"order_sn": in.OrderSn,
	}}

	var supplyInfo dao.SupplyCreate
	modelObj := model.SupplyModel{}.Init()
	err := modelObj.GetOne(w, &supplyInfo)
	if err != nil {
		return l.fail(utils.ErrorSupplyOrderError)
	}
	var orderInfo dao.OrderCreate
	ww := modelbase.Params{Eq: map[string]string{
		"order_sn":       in.OrderSn,
		"deliver_status": strconv.Itoa(dao.SendStatusOver),
	}}
	err = model.OrderModel{}.Init().GetOne(ww, &orderInfo)
	if err != nil {
		return l.fail(utils.ErrorNotFund)
	}
	if orderInfo.Id < utils.NumberOne {
		return l.fail(utils.ErrorNotFund)
	}

	check := l.checkProducts(in.Info, in.OrderSn)
	if check != utils.Ok {
		return l.fail(check)
	}

	supplyInfo.OrderSn = in.OrderSn
	supplyInfo.Products = in.Info
	supplyInfo.GroupId = int64(orderInfo.GroupId)
	supplyInfo.Reason = in.Reason
	supplyInfo.SaleId = int64(orderInfo.SaleId)
	supplyInfo.Images = strings.Join(in.Images, utils.DecollatorComma)
	modelObj.Begin()
	err = modelObj.Create(&supplyInfo)
	if err != nil {
		modelObj.Rollback()
		return l.fail(utils.Fail)
	}

	update := dao.UpdateOrderSupply{
		Id:       orderInfo.Id,
		IsSupply: dao.SupplyYes,
	}
	_, err = model.OrderModel{}.Init().Edit(ww, &update)
	if err != nil {
		modelObj.Rollback()
		return l.fail(utils.Fail)
	}

	modelObj.Commit()

	return l.ok(utils.NumberOne)
}

func (l *ApiSupplyLogic) checkProducts(info, orderSn string) utils.Status {
	w := modelbase.Params{Eq: map[string]string{
		"order_sn": orderSn,
	}}

	var items []dao.OrderProductInfo
	err := model.OrderProductModel{}.Init().Items(w, &items)
	if err != nil {
		return utils.Fail
	}
	orderProducts := make(map[int]int)
	for _, item := range items {
		orderProducts[int(item.ProductId)] = item.Number
	}

	var products [][]int
	ok := utils.JsonStringToStruct(info, &products)
	if !ok {
		return utils.Fail
	}
	for _, value := range products {
		if _, o := orderProducts[value[0]]; !o {
			return utils.ErrorSupplyOrderProduct
		}
		if orderProducts[value[0]] < value[1] {
			return utils.ErrorSupplyOrderProduct
		}
	}

	return utils.Ok
}