package svc

import (
	"context"
	"fmt"
	"lone-services/pkg/modelbase"
	"lone-services/pkg/utils"
	express "lone-services/rpc/express/pb"
	product "lone-services/rpc/product/pb"
	sale "lone-services/rpc/sale/pb"
	"lone-services/services/order/internal/dao"
	"math/rand"
	"strconv"
	"time"

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

func GetOrderSn(orderType string, adminId int64) string {
	now := time.Now().Format("20060102150405")
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	rnd := r.Intn(90000000) + 10000000

	sn := fmt.Sprintf("O%s%s%d%d", now, orderType, adminId, rnd)
	return sn
}

func GetCartData(name string, info map[int64]int64) (*product.ItemsByIdsData, utils.Status) {
	keys := make([]int64, utils.NumberZero, len(info))
	for k := range info {
		keys = append(keys, k)
	}

	cli, err := GetRpcClient(name)
	if err != nil {
		logx.Errorf("get rpc client err: %v", err)
		return nil, utils.Fail
	}
	productClient := product.NewProductClient(cli.Conn())
	products, err := productClient.ItemsByIds(context.Background(), &product.ItemsByIdsReq{Ids: keys})
	if err != nil {
		logx.Errorf("get products err: %v", err)
		return nil, utils.Fail
	}

	return products, utils.Ok
}

func GetCartInfo(info string) (map[int64]int64, utils.Status) {
	var list [][]int64
	err := jsoniter.Unmarshal([]byte(info), &list)
	if err != nil {
		return nil, utils.ErrorJsonDataError
	}
	m := make(map[int64]int64, len(list))
	for _, item := range list {
		if len(item) >= 2 {
			m[item[0]] = item[1]
		}
	}
	return m, utils.Ok
}

func GetOneData(name string, id int64) (*product.Item, utils.Status) {
	cli, err := GetRpcClient(name)
	if err != nil {
		logx.Errorf("get rpc client err: %v", err)
		return nil, utils.Fail
	}
	productClient := product.NewProductClient(cli.Conn())
	productInfo, err := productClient.InfoById(context.Background(), &product.InfoByIdReq{Id: id})
	if err != nil {
		logx.Errorf("get products err: %v", err)
		return nil, utils.Fail
	}

	return productInfo, utils.Ok
}

func SetGroupWhere(w *modelbase.Params, adminInfo utils.UserInfo, checkProvince bool) {
	if w.Eq == nil {
		w.Eq = make(map[string]string)
	}
	if adminInfo.GroupId < utils.NumberOne {
		return
	}

	//如果是公司销售
	if adminInfo.Type == dao.TypeSale {
		w.Eq["group_id"] = strconv.FormatInt(adminInfo.GroupId, utils.NumberTen)
	} else if adminInfo.SaleProvince > utils.NumberZero {
		if checkProvince {
			w.Eq["sale_province"] = strconv.FormatInt(adminInfo.SaleProvince, utils.NumberTen)
		} else {
			w.Eq["group_id"] = strconv.FormatInt(adminInfo.GroupId, utils.NumberTen)
		}
	}
}

func GetDeliveryInfo(name string, id int64, Type uint8) (*express.DeliveryInfoResponse, utils.Status) {
	cli, err := GetRpcClient(name)
	if err != nil {
		logx.Errorf("get rpc client err: %v", err)
		return nil, utils.Fail
	}
	client := express.NewExpressClient(cli.Conn())
	if Type == utils.NumberOne {
		info, err := client.GetDeliveryByOrderId(context.Background(), &express.IdRequest{Id: id})
		if err != nil {
			logx.Errorf("get products err: %v", err)
			return nil, utils.Fail
		}
		return info, utils.Ok
	}

	if Type == dao.OrderTypeOrder {
		info, err := client.GetDeliveryByOrderId(context.Background(), &express.IdRequest{Id: id})
		if err != nil {
			logx.Errorf("get products err: %v", err)
			return nil, utils.Fail
		}

		return info, utils.Ok
	}
	info, err := client.GetDeliveryBySupplyId(context.Background(), &express.IdRequest{Id: id})
	if err != nil {
		logx.Errorf("get products err: %v", err)
		return nil, utils.Fail
	}

	return info, utils.Ok
}

func GetSaleInfo(name string, id int64) (*sale.InfoData, utils.Status) {
	cli, err := GetRpcClient(name)
	if err != nil {
		logx.Errorf("get rpc client err: %v", err)
		return nil, utils.Fail
	}
	client := sale.NewSaleClient(cli.Conn())
	info, err := client.InfoInternal(context.Background(), &sale.InfoReq{Id: id})
	if err != nil {
		logx.Errorf("get products err: %v", err)
		return nil, utils.Fail
	}

	return info, utils.Ok
}