package service

import (
	"errors"
	"github.com/gin-gonic/gin"
	"hospital-admin-api/api/dao"
	"hospital-admin-api/api/model"
	"hospital-admin-api/api/requests"
	"hospital-admin-api/api/responses/roleResponse"
	"hospital-admin-api/global"
	"strconv"
)

type RoleService struct{}

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

	// 获取全部正常菜单列表
	AdminMenuDao := dao.AdminMenuDao{}
	adminMenu, _ := AdminMenuDao.GetAdminMenuListNormalSortOrderNum()
	if adminMenu == nil {
		return []*roleResponse.GetRoleMenuList{}, nil
	}

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

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

		if len(menuIDs) > 0 {
			// 构建菜单树
			menuTree = buildMenuTree(menuIDs, adminMenu)
			if menuTree == nil {
				return nil, nil
			}
		}
	}

	return menuTree, nil
}

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

	// 构建菜单映射
	for _, menu := range menuData {
		for _, v := range menuIds {
			if v == menu.MenuId {
				node := &roleResponse.GetRoleMenuList{
					MenuId:     strconv.FormatInt(menu.MenuId, 10),
					MenuName:   menu.MenuName,
					MenuTitle:  menu.MenuTitle,
					ParentId:   strconv.FormatInt(menu.ParentId, 10),
					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 {
			if menuMap[menu.MenuId] == nil {
				continue
			}
			rootNodes = append(rootNodes, menuMap[menu.MenuId])
		} else if parent, ok := menuMap[menu.ParentId]; ok && parent != nil {
			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 == nil {
		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) (adminRole *model.AdminRole, menuIds []int64, err error) {
	// 获取请求角色数据
	AdminRoleDao := dao.AdminRoleDao{}
	adminRole, err = AdminRoleDao.GetAdminRoleFirstById(roleId)
	if err != nil || adminRole == nil {
		return nil, nil, errors.New("非法操作")
	}

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

	return adminRole, menuIds, nil
}

// AddRole 新增角色
func (r *RoleService) AddRole(c *gin.Context, AddRoleRequest requests.AddRole) (bool, error) {
	roleId := c.GetInt64("RoleId")
	if roleId == 0 {
		return false, errors.New("数据错误")
	}

	// 获取当前登陆用户角色数据
	AdminRoleDao := dao.AdminRoleDao{}
	adminRole, err := AdminRoleDao.GetAdminRoleFirstById(roleId)
	if err != nil || adminRole == nil {
		return false, errors.New("非法操作")
	}

	if AddRoleRequest.IsAdmin == 1 && adminRole.IsAdmin == 0 {
		return false, errors.New("您当前为普通用户，无法添加管理员角色")
	}

	AdminMenuDao := dao.AdminMenuDao{}

	// 判断菜单id
	for _, menuId := range AddRoleRequest.MenuIds {
		// 将字符串转换为int64类型
		menuId, err := strconv.ParseInt(menuId, 10, 64)
		if err != nil {
			return false, errors.New("菜单错误")
		}

		adminMenu, _ := AdminMenuDao.GetAdminMenuById(menuId)
		if adminMenu == nil {
			return false, errors.New("菜单错误")
		}
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// 新增角色
	AdminRoleModel := &model.AdminRole{
		RoleName: AddRoleRequest.RoleName,
		IsAdmin:  AddRoleRequest.IsAdmin,
	}

	adminRole, _ = AdminRoleDao.AddAdminRole(tx, AdminRoleModel)
	if adminRole == nil {
		tx.Rollback()
		return false, errors.New("新增失败")
	}

	// 新增角色菜单
	AdminRoleMenuDao := dao.AdminRoleMenuDao{}
	for _, menuId := range AddRoleRequest.MenuIds {
		// 将字符串转换为int64类型
		menuId, err := strconv.ParseInt(menuId, 10, 64)
		if err != nil {
			tx.Rollback()
			return false, errors.New("菜单错误")
		}

		AdminRoleMenuModel := &model.AdminRoleMenu{
			RoleID: adminRole.RoleId,
			MenuID: menuId,
		}

		adminRoleMenu, _ := AdminRoleMenuDao.AddAdminRoleMenu(tx, AdminRoleMenuModel)
		if adminRoleMenu == nil {
			tx.Rollback()
			return false, errors.New("新增失败")
		}
	}

	tx.Commit()

	return true, nil
}

// PutRole 修改角色
func (r *RoleService) PutRole(c *gin.Context, requestRoleId int64, PutRoleRequest requests.PutRole) (bool, error) {
	// 获取当前登陆用户数据
	roleId := c.GetInt64("RoleId")
	if roleId == 0 {
		return false, errors.New("数据错误")
	}

	AdminRoleDao := dao.AdminRoleDao{}
	adminRole, err := AdminRoleDao.GetAdminRoleFirstById(roleId)
	if err != nil || adminRole == nil {
		return false, errors.New("非法操作")
	}

	if PutRoleRequest.IsAdmin == 1 && adminRole.IsAdmin == 0 {
		return false, errors.New("您当前为普通用户，无法设置管理员")
	}

	AdminMenuDao := dao.AdminMenuDao{}

	// 判断菜单id
	for _, menuId := range PutRoleRequest.MenuIds {
		// 将字符串转换为int64类型
		menuId, err := strconv.ParseInt(menuId, 10, 64)
		if err != nil {
			return false, errors.New("菜单错误")
		}

		adminMenu, _ := AdminMenuDao.GetAdminMenuById(menuId)
		if adminMenu == nil {
			return false, errors.New("菜单错误")
		}
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// 修改角色
	data := make(map[string]interface{})
	data["role_name"] = PutRoleRequest.RoleName
	data["is_admin"] = PutRoleRequest.IsAdmin
	err = AdminRoleDao.EditAdminRoleById(tx, requestRoleId, data)
	if err != nil {
		tx.Rollback()
		return false, errors.New("修改失败")
	}

	AdminRoleMenuDao := dao.AdminRoleMenuDao{}
	// 删除角色菜单
	err = AdminRoleMenuDao.DeleteAdminRoleMenuByRoleId(tx, requestRoleId)
	if err != nil {
		tx.Rollback()
		return false, errors.New("修改失败")
	}

	// 新增角色菜单
	for _, menuId := range PutRoleRequest.MenuIds {
		// 将字符串转换为int64类型
		menuId, err := strconv.ParseInt(menuId, 10, 64)
		if err != nil {
			tx.Rollback()
			return false, errors.New("新增失败")
		}

		AdminRoleMenuModel := &model.AdminRoleMenu{
			RoleID: requestRoleId,
			MenuID: menuId,
		}

		adminRoleMenu, _ := AdminRoleMenuDao.AddAdminRoleMenu(tx, AdminRoleMenuModel)
		if adminRoleMenu == nil {
			tx.Rollback()
			return false, errors.New("新增失败")
		}
	}

	tx.Commit()

	return true, nil
}

// DeleteRole 删除角色-批量
func (r *RoleService) DeleteRole(c *gin.Context, DeleteRoleRequest requests.DeleteRole) (bool, error) {
	// 获取当前登陆用户角色数据
	roleId := c.GetInt64("RoleId")
	if roleId == 0 {
		return false, errors.New("数据错误")
	}

	AdminUserDao := dao.AdminUserDao{}
	AdminRoleMenuDao := dao.AdminRoleMenuDao{}

	AdminRoleDao := dao.AdminRoleDao{}
	adminRole, err := AdminRoleDao.GetAdminRoleFirstById(roleId)
	if err != nil || adminRole == nil {
		return false, errors.New("非法操作")
	}

	if adminRole.IsAdmin == 0 {
		return false, errors.New("暂无权限，请联系管理员删除")
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	for _, v := range DeleteRoleRequest.RoleIds {
		// 将字符串转换为int64类型
		v, err := strconv.ParseInt(v, 10, 64)
		if err != nil {
			return false, errors.New("菜单错误")
		}

		if v == adminRole.RoleId {
			tx.Rollback()
			return false, errors.New("非法操作，请勿删除自己所属角色")
		}

		// 检测角色id
		adminRole, err := AdminRoleDao.GetAdminRoleFirstById(v)
		if err != nil || adminRole == nil {
			tx.Rollback()
			return false, errors.New("无法删除不存在的角色")
		}

		// 获取绑定该角色的用户
		maps := make(map[string]interface{})
		maps["role_id"] = v
		AdminUser, err := AdminUserDao.GetAdminUserList(maps)
		if AdminUser != nil {
			for _, user := range AdminUser {
				// 修改对应用户角色id为0
				data := make(map[string]interface{})
				data["role_id"] = nil
				err = AdminUserDao.EditAdminUserById(tx, user.UserID, data)
				if err != nil {
					tx.Rollback()
					return false, errors.New("删除失败")
				}
			}
		}

		// 删除角色关联菜单
		err = AdminRoleMenuDao.DeleteAdminRoleMenuByRoleId(tx, v)
		if err != nil {
			tx.Rollback()
			return false, errors.New("删除失败")
		}

		// 删除角色
		err = AdminRoleDao.DeleteAdminRoleByRoleId(tx, v)
		if err != nil {
			tx.Rollback()
			return false, errors.New("删除失败")
		}
	}

	tx.Commit()

	return true, nil
}