package logic

import (
	"context"
	"lone-services/pkg/modelbase"
	"lone-services/pkg/utils"
	chore "lone-services/rpc/chore/pb"
	express "lone-services/rpc/express/pb"
	"lone-services/rpc/order/pb"
	product "lone-services/rpc/product/pb"
	"lone-services/services/order/internal/dao"
	"lone-services/services/order/internal/model"
	"lone-services/services/order/internal/svc"
	"lone-services/services/order/validator"
	"strconv"
	"strings"

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

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

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

func (l *OrderAuditingLogic) OrderAuditing(in *order.OrderAuditingRequest) (*order.Response, error) {
	var v validator.AdminOrderAuditingValidator
	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)
	}
	var action = utils.ActionAdd{}
	var info dao.OrderImitateInfo
	w := modelbase.Params{Eq: map[string]string{"id": strconv.Itoa(int(in.Id))}}
	modelObj := model.OrderModel{}.Init()
	err := modelObj.GetOne(w, &info)
	if err != nil {
		l.Logger.Error(err)
		return l.fail(utils.Fail)
	}
	if info.Id < utils.NumberOne {
		return l.fail(utils.ErrorNotFund)
	}

	if info.VerifyStatus != dao.OrderVerifyStatusWait {
		return l.fail(utils.ErrorVerifyReview)
	}

	action.OldContent = info
	info.VerifyStatus = uint8(in.Status)
	info.Reason = in.Reason
	info.AdminName = adminInfo.Name
	info.AdminId = adminInfo.ID

	modelObj.Begin()
	row, editErr := modelObj.Edit(w, info)
	if editErr != nil {
		modelObj.Rollback()
		l.Logger.Error(editErr)
		return l.fail(utils.Fail)
	}

	if in.Status == utils.StatusOk {
		deliverGoods, status := l.getDeliveryInfo(info)
		if status != utils.Ok {
			modelObj.Rollback()
			return l.fail(status)
		}
		status = l.setDeliverGoods(deliverGoods)
		if status != utils.Ok {
			modelObj.Rollback()
			return l.fail(status)
		}
	} else {
		status := l.recover(info.OrderSn)
		if status != utils.Ok {
			modelObj.Rollback()
			return l.fail(status)
		}
	}

	modelObj.Commit()
	if row > utils.NumberZero {
		action.NewContent = info
		action.Reason = in.Reason
		action.Type = utils.LogActionTypeStatus
		action.ModuleName = utils.LogActionModuleOrder
		l.Logger.Error("set action log", action)
		utils.SetActionLog(adminInfo, action)
	}
	return l.ok(utils.NumberOne)
}

func (l *OrderAuditingLogic) getDeliveryInfo(info dao.OrderImitateInfo) (express.DeliveryOrderCreateRequest, utils.Status) {
	deliverGoods := express.DeliveryOrderCreateRequest{
		ObjId:     strconv.FormatInt(info.Id, utils.NumberTen),
		Mobile:    info.Mobile,
		Address:   info.Address,
		Addressee: info.Addressee,
		ObjSn:     info.OrderSn,
		Type:      dao.DeliverTypeOrder,
		Status:    dao.SendStatusWait,
	}
	if info.DeliverType == dao.OrderDeliverTypeSend {
		deliverGoods.Status = dao.SendStatusOver
	}

	w := modelbase.Params{Eq: map[string]string{"order_sn": info.OrderSn}}
	var orderProducts []dao.OrderProductInfo
	err := model.OrderProductModel{}.Init().Items(w, &orderProducts)
	if err != nil || len(orderProducts) < utils.NumberOne {
		logx.Errorf("get products err: %v", err)
		return deliverGoods, utils.ErrorNotFund
	}
	var productIds []int64
	idsNumber := make(map[int64]int)
	for _, item := range orderProducts {
		productIds = append(productIds, item.ProductId)
		idsNumber[item.ProductId] = item.Number
	}

	cli, err := svc.GetRpcClient(l.svcCtx.ProductSvcName)
	if err != nil {
		logx.Errorf("get products err: %v", err)
		return deliverGoods, utils.ErrorInternalServer
	}

	productClient := product.NewProductClient(cli.Conn())
	productItems, err := productClient.ItemsByIds(l.ctx, &product.ItemsByIdsReq{Ids: productIds})
	if err != nil {
		logx.Errorf("get products err: %v", err)
		return deliverGoods, utils.ErrorInternalServer
	}

	for _, item := range productItems.Items {
		number := utils.NumberZero
		if _, ok := idsNumber[item.Id]; ok {
			number = idsNumber[item.Id]
		}
		deliverGoods.ProductInfo = append(deliverGoods.ProductInfo, &express.DeliverOrderProductInfo{
			ProductId:   item.Id,
			Number:      int32(number),
			Type:        int32(item.Type),
			ProductName: item.Name,
			Price:       item.Price,
		})
	}

	clic, err := svc.GetRpcClient(l.svcCtx.ChoreSvcName)
	if err != nil {
		logx.Errorf("get region err: %v", err)
		return deliverGoods, utils.ErrorInternalServer
	}

	var regionIds []int64
	for _, item := range strings.Split(info.DistrictIds, utils.DecollatorComma) {
		id, _ := strconv.Atoi(item)
		regionIds = append(regionIds, int64(id))
	}

	clicClient := chore.NewChoreClient(clic.Conn())
	regionItems, err := clicClient.RegionsByIds(l.ctx, &chore.RegionsByIdsReq{Ids: regionIds})
	if err != nil {
		logx.Errorf("get region err: %v", err)
		return deliverGoods, utils.ErrorInternalServer
	}

	switch len(regionItems.Items) {
	case utils.NumberOne:
		deliverGoods.Province = regionItems.Items[utils.NumberZero].Name
	case utils.NumberTwo:
		deliverGoods.Province = regionItems.Items[utils.NumberZero].Name
		deliverGoods.City = regionItems.Items[utils.NumberOne].Name
	case utils.NumberThree:
		deliverGoods.Province = regionItems.Items[utils.NumberZero].Name
		deliverGoods.City = regionItems.Items[utils.NumberOne].Name
		deliverGoods.County = regionItems.Items[utils.NumberTwo].Name
	}

	return deliverGoods, utils.Ok
}

func (l *OrderAuditingLogic) setDeliverGoods(data express.DeliveryOrderCreateRequest) utils.Status {
	cli, err := svc.GetRpcClient(l.svcCtx.ExpressSvcName)
	if err != nil {
		return utils.ErrorInternalServer
	}

	client := express.NewExpressClient(cli.Conn())
	_, err = client.DeliveryOrderCreate(l.ctx, &data)
	if err != nil {
		logx.Errorf("set products err: %v", err)
		return utils.ErrorInternalServer
	}
	return utils.Ok
}

func (l *OrderAuditingLogic) recover(orderSn string) utils.Status {
	w := modelbase.Params{Eq: map[string]string{"order_sn": orderSn}}
	var orderProducts []dao.OrderProductInfo
	err := model.OrderProductModel{}.Init().Items(w, &orderProducts)
	if err != nil || len(orderProducts) < utils.NumberOne {
		logx.Errorf("get products err: %v", err)
		return utils.ErrorNotFund
	}
	var data product.NumberItemsReq
	data.Type = utils.NumberTwo
	for _, item := range orderProducts {
		data.Items = append(data.Items, &product.NumberItem{Id: item.ProductId, Number: uint32(item.Number)})
	}

	cli, err := svc.GetRpcClient(l.svcCtx.ProductSvcName)
	if err != nil {
		return utils.ErrorInternalServer
	}

	productClient := product.NewProductClient(cli.Conn())
	_, err = productClient.NumberItems(l.ctx, &data)
	if err != nil {
		logx.Errorf("set products err: %v", err)
		return utils.ErrorInternalServer
	}
	return utils.Ok
}