package logic

import (
	"context"
	"strconv"

	"lone-services/pkg/modelbase"
	"lone-services/pkg/rpcclient"
	"lone-services/pkg/utils"
	"lone-services/pkg/validate"
	sale "lone-services/rpc/sale/pb"
	wecom "lone-services/rpc/wecom/pb"
	"lone-services/services/wecom/internal/dao"
	"lone-services/services/wecom/internal/model"
	"lone-services/services/wecom/internal/svc"
	"lone-services/services/wecom/validator"

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

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

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

func (l *ItemsUsersLogic) ItemsUsers(in *wecom.ItemsUserReq) (*wecom.Response, error) {
	var req validator.ItemsUserValidator
	if msg := validate.ValidateFromProto(in, &req); msg != utils.StringEmpty {
		return outResponse(utils.ErrorParams, msg), nil
	}

	page := int(req.Page)
	size := int(req.PageSize)
	if page < utils.NumberOne {
		page = modelbase.DefaultPage
	}
	if size < utils.NumberOne {
		size = modelbase.DefaultSize
	}

	w := modelbase.Params{
		Eq:    map[string]string{},
		Like:  map[string]string{},
		Order: "id desc",
		Page:  page,
		Size:  size,
	}
	if req.Type > utils.NumberZero {
		w.Eq["type"] = strconv.FormatUint(uint64(req.Type), utils.NumberTen)
	}
	// w.Eq["status"] = strconv.FormatUint(uint64(dao.StatusEnabled), utils.NumberTen)
	if req.Name != utils.StringEmpty {
		w.Like["name LIKE ?"] = "%" + req.Name + "%"
	}

	var rows []dao.WecomUser
	result, err := model.UserModel{}.Init().Page(w, &rows)
	if err != nil {
		l.Errorf("wecom items users: %v", err)
		return failResponse(utils.Fail), nil
	}

	saleNames, err := l.fetchSaleNames(rows)
	if err != nil {
		l.Errorf("wecom items fetch sale names: %v", err)
		return failResponse(utils.Fail), nil
	}

	items := make([]dao.UserListItem, 0, len(rows))
	for _, row := range rows {
		mobile := utils.StringEmpty
		if dec, dErr := utils.DecryptPhone(row.Mobile); dErr == nil {
			mobile = utils.DecryptPhoneReplace(dec)
		}
		// 管理员人员未获取到
		bizName := utils.StringEmpty
		if row.Type == dao.UserTypeSale {
			bizName = saleNames[row.UserId]
		}
		items = append(items, dao.UserListItem{
			Id:           row.Id,
			UserId:       row.UserId,
			Type:         row.Type,
			TypeText:     typeText(row.Type),
			Name:         row.Name,
			Mobile:       mobile,
			OriginMobile: row.Mobile,
			Avatar:       row.Avatar,
			Status:       row.Status,
			BizName:      bizName,
			WecomUserId:  row.WecomUserId,
			CreatedAt:    row.CreatedAt.Format(),
		})
	}

	return okResponse(map[string]any{
		"count": result.Count,
		"items": items,
	}), nil
}

func (l *ItemsUsersLogic) fetchSaleNames(rows []dao.WecomUser) (map[int64]string, error) {
	result := make(map[int64]string)
	seen := make(map[int64]struct{})
	ids := make([]int64, 0)
	for _, row := range rows {
		if row.Type != dao.UserTypeSale || row.UserId < utils.NumberOne {
			continue
		}
		if _, ok := seen[row.UserId]; ok {
			continue
		}
		seen[row.UserId] = struct{}{}
		ids = append(ids, row.UserId)
	}
	if len(ids) < utils.NumberOne {
		return result, nil
	}

	cli, err := rpcclient.Get(l.svcCtx.SaleSvcName)
	if err != nil {
		return nil, err
	}
	res, err := sale.NewSaleClient(cli.Conn()).NamesByIds(l.ctx, &sale.NamesByIdsReq{Ids: ids})
	if err != nil {
		return nil, err
	}
	for _, item := range res.GetItems() {
		result[item.GetId()] = item.GetName()
	}
	return result, nil
}