package system

import (
	"context"
	"encoding/json"
	"strconv"
	"strings"
	"time"

	"management/internal/db/model/dto"
	db "management/internal/db/sqlc"
	"management/internal/global/keys"
	"management/internal/pkg/redis"
)

func CreateSysRole(ctx context.Context, arg *db.CreateSysRoleParams) (*db.SysRole, error) {
	return db.Engine.CreateSysRole(ctx, arg)
}

func UpdateSysRole(ctx context.Context, arg *db.UpdateSysRoleParams) (*db.SysRole, error) {
	return db.Engine.UpdateSysRole(ctx, arg)
}

func GetSysRole(ctx context.Context, id int32) (*db.SysRole, error) {
	return db.Engine.GetSysRole(ctx, id)
}

func ListSysRoleCondition(ctx context.Context, q dto.SearchDto) ([]*db.SysRole, int64, error) {
	countArg := &db.CountSysRoleConditionParams{
		IsStatus:   q.SearchStatus != 9999,
		Status:     int32(q.SearchStatus),
		IsParentID: q.SearchParentID != 0,
		ParentID:   int32(q.SearchParentID),
	}

	dataArg := &db.ListSysRoleConditionParams{
		IsStatus:   q.SearchStatus != 9999,
		Status:     int32(q.SearchStatus),
		IsParentID: q.SearchParentID != 0,
		ParentID:   int32(q.SearchParentID),
		Skip:       (int32(q.Page) - 1) * int32(q.Rows),
		Size:       int32(q.Rows),
	}

	if len(q.SearchKey) > 0 {
		switch strings.ToLower(q.SearchName) {
		case "id":
			id, err := strconv.Atoi(q.SearchKey)
			if err == nil {
				countArg.IsID = true
				countArg.ID = int32(id)

				dataArg.IsID = true
				dataArg.ID = int32(id)
			}
		case "name":
			countArg.DisplayName = q.SearchKey
			dataArg.DisplayName = q.SearchKey
		}
	}
	count, err := db.Engine.CountSysRoleCondition(ctx, countArg)
	if err != nil {
		return nil, 0, err
	}

	roles, err := db.Engine.ListSysRoleCondition(ctx, dataArg)
	if err != nil {
		return nil, 0, err
	}

	return roles, count, nil
}

func XmSelectSysRole(ctx context.Context) ([]*dto.XmSelectDto, error) {
	all, err := db.Engine.AllSysRole(ctx)
	if err != nil {
		return nil, err
	}

	var res []*dto.XmSelectDto
	for _, item := range all {
		res = append(res, &dto.XmSelectDto{Name: item.DisplayName, Value: int(item.ID)})
	}

	return res, nil
}

func SetMenu(ctx context.Context, roleID int32, menus []*db.SysMenu) error {
	return db.Engine.ExecTx(ctx, func(q *db.Queries) error {
		err := db.Engine.DeleteRoleMneuByRoleID(ctx, roleID)
		if err != nil {
			return err
		}

		for _, m := range menus {
			err := db.Engine.CreateRoleMenu(ctx, &db.CreateRoleMenuParams{
				RoleID: roleID,
				MenuID: m.ID,
			})
			if err != nil {
				return err
			}
		}

		return nil
	})
}

func DTreeSysRole(ctx context.Context, id int32) ([]*dto.DTreeDto, error) {
	all, err := db.Engine.AllSysRole(ctx)
	if err != nil {
		return nil, err
	}

	return toDtreeSysRole(id, all), nil
}

func RefreshSysRole(ctx context.Context) error {
	all, err := db.Engine.AllSysRole(ctx)
	if err != nil {
		return err
	}

	b, err := json.Marshal(all)
	if err != nil {
		return err
	}

	key := keys.GetManageKey(ctx, keys.AllRoles)
	err = redis.Set(ctx, key, b, time.Hour*6)
	return err
}

func RebuildSysRoleParentPath(ctx context.Context) error {
	return db.Engine.SysRoleRebuildPath(ctx)
}

func toDtreeSysRole(parentId int32, data []*db.SysRole) []*dto.DTreeDto {
	var res []*dto.DTreeDto
	for _, v := range data {
		if v.ParentID == parentId {
			item := dto.DTreeDto{}
			item.ID = strconv.FormatInt(int64(v.ID), 10)
			item.Title = v.DisplayName
			item.Last = !hasSysRoleChildren(v.ID, data)
			item.ParentId = strconv.FormatInt(int64(v.ParentID), 10)
			item.Children = toDtreeSysRole(v.ID, data)
			res = append(res, &item)
		}
	}

	return res
}

func hasSysRoleChildren(parentId int32, data []*db.SysRole) bool {
	if len(data) > 0 {
		for _, v := range data {
			if v.ParentID == parentId {
				return true
			}
		}
	}

	return false
}