package logic

import (
	"admin/internal/dao"
	"admin/internal/model"
	"context"
	"strconv"
	"strings"

	"admin/admin"
	"admin/internal/svc"

	"github.com/zeromicro/go-zero/core/logx"
	"pkg.local/modelbase"
	"pkg.local/utils"
)

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

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

func (l *AdminItemsLogic) AdminItems(in *admin.AdminItemsRequest) (*admin.Response, error) {
	modelObj := model.AdminModel{}.Init()
	w := modelbase.Params{
		Page:  int(in.Page),
		Size:  int(in.Size),
		Order: "id desc",
	}

	w.Like = make(map[string]string)
	eq := make(map[string]string)
	if len(in.Name) > utils.NumberZero {
		w.Like["name LIKE ? "] = "%%" + in.Name + "%%"
	}
	if len(in.Phone) > utils.NumberZero {
		phone := utils.GetSearchPhone(in.Phone)
		if len(phone) > utils.NumberZero {
			w.Like["phone LIKE ? "] = "%%" + phone + "%%"
		}
	}
	if len(in.Email) > utils.NumberZero {
		w.Like["email LIKE ? "] = "%%" + in.Email + "%%"
	}
	if in.Status > utils.NumberZero {
		eq["status"] = strconv.Itoa(int(in.Status))
	}

	if len(eq) > utils.NumberZero {
		w.Eq = eq
	}

	var data []dao.AdminInfo
	var list []dao.AdminItemsRet
	items, _ := modelObj.Page(w, &data)
	roleInfos := l.getRoleInfos(data)
	for _, item := range data {
		var roles []dao.RoleNameItems
		for _, role := range strings.Split(item.Roles, utils.DecollatorComma) {
			if _, ok := roleInfos[role]; ok {
				roles = append(roles, roleInfos[role])
			}
		}

		mobile, dErr := utils.DecryptPhone(item.Phone)
		if dErr == nil {
			item.Phone = mobile
		}

		list = append(list, dao.AdminItemsRet{
			AdminInfo: item,
			RoleInfo:  roles,
		})
	}
	items.Items = list

	return l.ok(items), nil
}

func (l *AdminItemsLogic) getRoleInfos(data []dao.AdminInfo) map[string]dao.RoleNameItems {
	var ids []string
	for _, item := range data {
		ids = append(ids, strings.Split(item.Roles, utils.DecollatorComma)...)
	}

	w := modelbase.Params{In: map[string][]string{"id in ?": ids}}
	var items []dao.RoleNameItems
	retData := make(map[string]dao.RoleNameItems)

	err := model.RoleModel{}.Init().Items(w, &items)
	if err != nil {
		return retData
	}

	w = modelbase.Params{}
	var serversItems []dao.ServicesNameItems
	pErr := model.ServicesModel{}.Init().Items(w, &serversItems)
	serverIds := make(map[int]string)
	if pErr == nil {
		for _, item := range serversItems {
			serverIds[item.Id] = item.Name
		}
	}
	for i := utils.NumberZero; i < len(items); i++ {
		serverName := utils.StringEmpty
		if _, ok := serverIds[items[i].ServiceId]; ok {
			serverName = serverIds[items[i].ServiceId] + utils.DecollatorColon
		}
		retData[strconv.Itoa(items[i].Id)] = dao.RoleNameItems{
			Id:   items[i].Id,
			Name: serverName + items[i].Name,
		}
	}

	return retData
}