package logic

import (
	"context"
	"lone-services/pkg/modelbase"
	"lone-services/pkg/utils"
	sale "lone-services/rpc/sale/pb"
	"lone-services/services/store/internal/dao"
	"lone-services/services/store/internal/model"
	"lone-services/services/store/validator"
	"strconv"

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

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

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

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

func (l *ApplyVerifyLogic) ApplyVerify(in *store.ItemsRequest) (*store.Response, error) {
	var v validator.StoreVerifyItemsValidator
	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 info []dao.StoreInfo
	w := modelbase.Params{
		Eq:    map[string]string{},
		Like:  map[string]string{},
		Page:  int(v.Page),
		Size:  int(v.Size),
		Order: "id desc",
	}

	if v.Status > utils.NumberZero {
		w.Eq["status"] = strconv.Itoa(int(v.Status))
	} else {
		w.In = map[string][]string{"status": {strconv.Itoa(utils.StatusFail), strconv.Itoa(utils.StatusWaitPass)}}
	}

	if v.SaleId > utils.NumberZero {
		w.Eq["sale_id"] = strconv.FormatInt(v.SaleId, utils.NumberTen)
	}

	if len(v.Name) > utils.NumberZero {
		w.Like["name LIKE ? "] = "%%" + v.Name + "%%"
	}

	l.SetWhere(&w, adminInfo)

	items, err := model.StoreModel{}.Init().Page(w, &info)
	if err != nil {
		l.Logger.Error(err)
		return l.fail(utils.Fail)
	}
	var saleIds []int64
	for key, v := range info {
		mobile, aErr := utils.DecryptPhone(v.UserMobile)
		if aErr == nil {
			info[key].UserMobile = mobile
		}

		credentials, aErr := utils.Crypto{}.AESDecryptECB(v.BusinessLicense)
		if aErr == nil {
			info[key].BusinessLicense = credentials
		}
		idCard, aErr := utils.Crypto{}.AESDecryptECB(v.IdCard)
		if aErr == nil {
			info[key].IdCard = idCard
		}
		saleIds = append(saleIds, v.SaleId)
	}
	newSaleIds := lo.Uniq(saleIds)
	if len(newSaleIds) > utils.NumberZero {
		salesMap := make(map[int64]string)
		if len(newSaleIds) > utils.NumberZero {
			sales, err := l.getSaleInfo(saleIds)
			if err == utils.Ok {
				for _, val := range sales.Items {
					salesMap[val.Id] = val.Name
				}
			}
		}

		for key, item := range info {
			if s, ok := salesMap[item.SaleId]; ok {
				info[key].SaleName = s
			}
		}
	}

	items.Items = info

	return l.ok(items)
}

func (l *ApplyVerifyLogic) getSaleInfo(ids []int64) (*sale.NamesByIdsData, utils.Status) {
	cli, err := svc.GetRpcClient(l.svcCtx.SaleName)
	if err != nil {
		logx.Errorf("get order err: %v", err)
		return &sale.NamesByIdsData{}, utils.ErrorInternalServer
	}

	client := sale.NewSaleClient(cli.Conn())
	w := sale.NamesByIdsReq{Ids: ids}
	info, err := client.NamesByIds(context.Background(), &w)
	if err != nil {
		logx.Errorf("get order err: %v", err)
		return &sale.NamesByIdsData{}, utils.ErrorInternalServer
	}
	return info, utils.Ok
}