package system

import (
	"errors"
	"net/http"

	"management/internal/erpserver/model/system"
	"management/internal/erpserver/model/system/request"
	"management/internal/erpserver/service/v1"
	"management/internal/pkg/convertor"
	"management/internal/pkg/gin/gu"
	"management/internal/pkg/sqldb"

	"github.com/gin-gonic/gin"
)

type RoleApp struct {
	roleService v1.RoleService
	menuService v1.MenuService
}

func NewRoleApp(roleService v1.RoleService, menuService v1.MenuService) *RoleApp {
	return &RoleApp{
		roleService: roleService,
		menuService: menuService,
	}
}

func (a *RoleApp) Create(c *gin.Context) {
	var req request.CreateAndUpdateRole
	if err := c.ShouldBindJSON(&req); err != nil {
		gu.ValidatorErrors(c, err)
		return
	}

	if err := a.roleService.Create(c, &req); err != nil {
		if errors.Is(err, sqldb.ErrDBDuplicatedEntry) {
			gu.FailedWithCode(c, http.StatusConflict, "角色已存在")
			return
		}

		gu.Failed(c, err.Error())
		return
	}

	gu.Ok(c, "添加成功")
}

func (a *RoleApp) Update(c *gin.Context) {
	var id request.GetRoleID
	if err := c.ShouldBindUri(&id); err != nil {
		gu.ValidatorErrors(c, err)
		return
	}

	var req request.CreateAndUpdateRole
	if err := c.ShouldBindJSON(&req); err != nil {
		gu.ValidatorErrors(c, err)
		return
	}

	req.ID = id.ID
	if err := a.roleService.Update(c, &req); err != nil {
		gu.Failed(c, err.Error())
		return
	}

	gu.Ok(c, "更新成功")
}

func (a *RoleApp) Get(c *gin.Context) {
	var id request.GetRoleID
	if err := c.ShouldBindUri(&id); err != nil {
		gu.ValidatorErrors(c, err)
		return
	}

	config, err := a.roleService.Get(c, id.ID)
	if err != nil {
		if errors.Is(err, sqldb.ErrDBNotFound) {
			gu.FailedWithCode(c, http.StatusNotFound, "配置不存在")
			return
		}

		gu.Failed(c, err.Error())
		return
	}

	gu.Ok(c, config)
}

func (a *RoleApp) List(c *gin.Context) {
	var req request.ListRole
	if err := c.ShouldBindQuery(&req); err != nil {
		gu.ValidatorErrors(c, err)
		return
	}

	res, count, err := a.roleService.List(c, req)
	if err != nil {
		gu.Failed(c, err.Error())
		return
	}

	gu.Ok(c, gu.NewPageData(count, req.PageID, req.PageSize, res))
}

func (a *RoleApp) Refresh(c *gin.Context) {
	err := a.roleService.RefreshCache(c)
	if err != nil {
		gu.Failed(c, err.Error())
		return
	}

	gu.Ok(c, "缓存刷新成功")
}

func (a *RoleApp) RebuildParentPath(c *gin.Context) {
	err := a.roleService.RebuildParentPath(c)
	if err != nil {
		gu.Failed(c, err.Error())
		return
	}

	gu.Ok(c, "重建成功")
}

func (a *RoleApp) RefreshRoleMenus(c *gin.Context) {
	// 获取需要刷新的角色ID
	roleID := convertor.Int[int32](c.PostForm("roleID"), 0)
	roleModel, err := a.roleService.Get(c, roleID)
	if err != nil {
		gu.Failed(c, err.Error())
		return
	}
	if roleModel == nil {
		gu.Failed(c, "角色不存在")
		return
	}

	// 刷新角色菜单 (角色所拥有的菜单集合)
	_, err = a.menuService.SetListByRoleID(c, roleModel.ID)
	if err != nil {
		gu.Failed(c, err.Error())
		return
	}

	// 刷新角色菜单 (角色所拥有的菜单集合)
	_, err = a.menuService.SetListByRoleIDToMap(c, roleModel.ID)
	if err != nil {
		gu.Failed(c, err.Error())
		return
	}

	// 刷新角色菜单树 (pear admin layui 使用的格式)
	_, err = a.menuService.SetOwerMenus(c, roleModel.ID)
	if err != nil {
		gu.Failed(c, err.Error())
		return
	}

	gu.Ok(c, "刷新成功")
}

func (a *RoleApp) setMenu(c *gin.Context) {
	var req request.SetMenu
	if err := c.ShouldBindJSON(&req); err != nil {
		gu.ValidatorErrors(c, err)
		return
	}

	role, err := a.roleService.Get(c, req.RoleID)
	if err != nil {
		gu.Failed(c, err.Error())
		return
	}

	var rms []*system.RoleMenu
	for _, v := range req.MenuIDs {
		menu, err := a.menuService.Get(c, v)
		if err != nil {
			gu.Failed(c, err.Error())
			return
		}

		rms = append(rms, &system.RoleMenu{
			RoleID: role.ID,
			MenuID: menu.ID,
		})
	}

	if len(rms) == 0 {
		gu.Failed(c, "请选择正确的菜单")
		return
	}

	err = a.menuService.SetRoleMenu(c, role.ID, rms)
	if err != nil {
		gu.Failed(c, err.Error())
		return
	}

	gu.Ok(c, "设置成功")
}