package service

import (
	"errors"
	"hospital-admin-api/api/dao"
	"hospital-admin-api/api/model"
	"hospital-admin-api/api/responses/roleResponse"
)

type RoleService struct{}

// GetRoleMenuList 获取角色菜单
func (r *RoleService) GetRoleMenuList(roleId int64) ([]*roleResponse.RoleMenuList, error) {
	AdminRoleMenuDao := dao.AdminRoleMenuDao{}
	adminRoleMenu, _ := AdminRoleMenuDao.GetAdminRoleMenuListByRoleId(roleId)
	if adminRoleMenu == nil {
		return []*roleResponse.RoleMenuList{}, nil
	}

	// 获取全部菜单
	AdminMenuDao := dao.AdminMenuDao{}
	adminMenu, _ := AdminMenuDao.GetAdminMenuListSortOrderNum()
	if adminMenu == nil {
		return []*roleResponse.RoleMenuList{}, nil
	}

	var menuIDs []int64
	var menuTree []*roleResponse.RoleMenuList

	if len(adminRoleMenu) > 0 {
		for _, roleMenu := range adminRoleMenu {
			menuIDs = append(menuIDs, roleMenu.MenuID)
		}

		// 构建菜单树
		menuTree = buildMenuTree(menuIDs, adminMenu)
	}

	return menuTree, nil
}

// 获取角色菜单-构建菜单树
func buildMenuTree(menuIds []int64, menuData []*model.AdminMenu) []*roleResponse.RoleMenuList {
	menuMap := make(map[int64]*roleResponse.RoleMenuList)
	rootNodes := make([]*roleResponse.RoleMenuList, 0)

	// 构建菜单映射
	for _, menu := range menuData {
		for _, v := range menuIds {
			if v == menu.MenuId {
				node := &roleResponse.RoleMenuList{
					MenuId:     menu.MenuId,
					MenuName:   menu.MenuName,
					MenuTitle:  menu.MenuTitle,
					ParentId:   menu.ParentId,
					MenuStatus: menu.MenuStatus,
					MenuType:   menu.MenuType,
					Permission: menu.Permission,
					OrderNum:   menu.OrderNum,
					Icon:       menu.Icon,
					Path:       menu.Path,
					Component:  menu.Component,
					Children:   nil,
				}

				menuMap[menu.MenuId] = node
			}
		}
	}

	// 构建菜单树
	for _, menu := range menuData {
		if menu.ParentId == 0 {
			rootNodes = append(rootNodes, menuMap[menu.MenuId])
		} else if parent, ok := menuMap[menu.ParentId]; ok {
			parent.Children = append(parent.Children, menuMap[menu.MenuId])
		}
	}

	return rootNodes
}

// PutRoleStatus 角色禁用/启用
func (r *RoleService) PutRoleStatus(roleId int64, roleStatus int) (bool, error) {
	// 获取请求角色数据
	AdminRoleDao := dao.AdminRoleDao{}
	adminRole, err := AdminRoleDao.GetAdminRoleFirstById(roleId)
	if err != nil || adminRole.RoleId == 0 {
		return false, errors.New("非法操作")
	}

	// 检测是否为超级管理员
	if adminRole.IsAdmin == 1 {
		return false, errors.New("请勿修改超级管理员数据")
	}

	// 修改角色状态
	err = AdminRoleDao.EditAdminRoleStatusById(roleId, roleStatus)
	if err != nil {
		return false, errors.New(err.Error())
	}
	return true, nil
}

// GetRole 角色详情
func (r *RoleService) GetRole(roleId int64) (*roleResponse.GetRole, error) {
	// 获取请求角色数据
	AdminRoleDao := dao.AdminRoleDao{}
	adminRole, err := AdminRoleDao.GetAdminRoleFirstById(roleId)
	if err != nil || adminRole.RoleId == 0 {
		return nil, errors.New("非法操作")
	}

	// 获取角色权限菜单id
	AdminRoleMenuDao := dao.AdminRoleMenuDao{}
	menuIds, err := AdminRoleMenuDao.GetAdminRoleMenuIdByRoleId(roleId)
	if err != nil {
		return nil, errors.New("角色权限菜单获取失败")
	}

	GetRoleResponse := &roleResponse.GetRole{
		MenuIds:    menuIds,
		RoleId:     adminRole.RoleId,
		RoleName:   adminRole.RoleName,
		RoleStatus: adminRole.RoleStatus,
		IsAdmin:    adminRole.IsAdmin,
	}

	return GetRoleResponse, nil
}