package logic

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

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

	"github.com/zeromicro/go-zero/core/logx"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

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

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

func (l *UpdateOrderPayStatusLogic) UpdateOrderPayStatus(in *order.UpdateOrderPayStatusRequest) (*order.UpdateOrderPayStatusResponse, error) {
	var info dao.UpPayStatus
	w := modelbase.Params{
		Eq: map[string]string{"order_sn": in.OrderSn},
	}
	modelObj := model.OrderModel{}.Init()
	err := modelObj.GetOne(w, &info)
	if err != nil {
		return nil, status.Error(codes.Internal, utils.Fail.Msg)
	}
	if info.Id < utils.NumberOne {
		return nil, status.Error(codes.Internal, utils.ErrorNotFund.Msg)
	}

	info.PayPrice = utils.RoundMoney(in.PayPrice)
	info.PayType = in.PayType
	info.RemitNo = in.RemitNo
	if in.Status == dao.OrderPayStatusOk {
		info.Status = dao.OrderPayStatusOk
	} else if in.Status == dao.OrderPayStatusFail {
		info.Status = dao.OrderPayStatusFail
	} else {
		return nil, status.Error(codes.Internal, utils.ErrorParams.Msg)
	}

	deliverGoods, s := l.getDeliveryInfo(info)
	if s != utils.Ok {
		return nil, status.Error(codes.Internal, s.Msg)
	}
	_, err = modelObj.Edit(w, info)
	if err != nil {
		return nil, status.Error(codes.Internal, utils.Fail.Msg)
	}

	s = l.setDeliverGoods(deliverGoods)

	if s != utils.Ok {
		return nil, status.Error(codes.Internal, s.Msg)
	}

	return &order.UpdateOrderPayStatusResponse{Id: info.Id}, nil
}

func (l *UpdateOrderPayStatusLogic) 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 *UpdateOrderPayStatusLogic) getDeliveryInfo(info dao.UpPayStatus) (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
}