import { Injectable } from '@nestjs/common';
import { CoreRoleService } from '../core/CoreRoleService';
import { SysRole } from '../../../rbac/entities/SysRole';

/**
 * 角色服务 - Admin层
 * 对应PHP: app\service\admin\sys\RoleService
 */
@Injectable()
export class RoleService {
  constructor(private readonly coreRoleService: CoreRoleService) {}

  /**
   * 管理端获取角色列表
   * @param siteId 站点ID
   * @param data 查询参数
   * @returns 分页结果
   */
  async getPage(siteId: number, data: any = {}) {
    const { role_name, page = 1, limit = 10 } = data;
    return await this.coreRoleService.getPage(siteId, role_name, page, limit);
  }

  /**
   * 获取角色信息
   * @param roleId 角色ID
   * @returns 角色信息
   */
  async getInfo(roleId: number): Promise<SysRole | null> {
    return await this.coreRoleService.getInfo(roleId);
  }

  /**
   * 获取站点下的所有角色
   * @param siteId 站点ID
   * @param userRoleIds 当前用户的角色ID数组（用于权限过滤）
   * @param isAdmin 是否是超级管理员
   * @returns 角色列表
   */
  async getAll(
    siteId: number,
    userRoleIds: number[] = [],
    isAdmin: boolean = false,
  ): Promise<any[]> {
    const siteRoleAll = await this.coreRoleService.getAll(siteId);

    // 为每个角色添加disabled字段
    const result = siteRoleAll.map((role) => ({
      ...role,
      disabled: false,
    }));

    // 如果不是超级管理员，需要检查权限
    if (!isAdmin && userRoleIds.length > 0) {
      // TODO: 实现菜单权限检查逻辑
      // 暂时跳过权限检查，后续完善权限模块时补充
      // const menuKeys = await this.getMenuIdsByRoleIds(siteId, userRoleIds);
      // 检查每个角色的权限是否超出当前用户权限
    }

    // 移除rules字段，不返回给前端
    return result.map((role) => {
      const { rules, ...roleWithoutRules } = role;
      return roleWithoutRules;
    });
  }

  /**
   * 新增角色
   * @param siteId 站点ID
   * @param appType 应用类型
   * @param data 角色数据
   * @returns 是否成功
   */
  async add(
    siteId: number,
    appType: string,
    data: Partial<SysRole>,
  ): Promise<boolean> {
    const roleData = {
      ...data,
      site_id: siteId,
      // app_type: appType, // 根据数据表结构，暂时不添加app_type字段
    };

    await this.coreRoleService.add(roleData);
    return true;
  }

  /**
   * 更新角色
   * @param roleId 角色ID
   * @param siteId 站点ID
   * @param data 更新数据
   * @returns 是否成功
   */
  async edit(
    roleId: number,
    siteId: number,
    data: Partial<SysRole>,
  ): Promise<boolean> {
    return await this.coreRoleService.edit(roleId, siteId, data);
  }

  /**
   * 修改角色状态
   * @param roleId 角色ID
   * @param siteId 站点ID
   * @param status 状态
   * @returns 是否成功
   */
  async modifyStatus(
    roleId: number,
    siteId: number,
    status: number,
  ): Promise<boolean> {
    return await this.coreRoleService.modifyStatus(roleId, siteId, status);
  }

  /**
   * 查找角色
   * @param siteId 站点ID
   * @param roleId 角色ID
   * @returns 角色实体
   */
  async find(siteId: number, roleId: number): Promise<SysRole> {
    const role = await this.coreRoleService.find(siteId, roleId);
    if (!role) {
      throw new Error('角色不存在');
    }
    return role;
  }

  /**
   * 删除角色
   * @param roleId 角色ID
   * @param siteId 站点ID
   * @returns 是否成功
   */
  async del(roleId: number, siteId: number): Promise<boolean> {
    // 先检查角色是否存在
    await this.find(siteId, roleId);

    // 检查是否有用户使用该角色
    // TODO: 需要检查SysUserRole表
    // 暂时跳过用户角色关联检查，后续完善用户模块时补充

    return await this.coreRoleService.del(roleId, siteId);
  }

  /**
   * 获取角色ID和名称的键值对
   * @param siteId 站点ID
   * @returns 角色键值对
   */
  async getColumn(siteId: number): Promise<Record<number, string>> {
    return await this.coreRoleService.getColumn(siteId);
  }

  /**
   * 通过角色ID数组获取菜单权限
   * @param siteId 站点ID
   * @param roleIds 角色ID数组
   * @param allowMenuKeys 允许的菜单键列表
   * @returns 菜单键数组
   */
  async getMenuIdsByRoleIds(
    siteId: number,
    roleIds: number[],
    allowMenuKeys: string[] = [],
  ): Promise<string[]> {
    return await this.coreRoleService.getMenuIdsByRoleIds(
      siteId,
      roleIds,
      allowMenuKeys,
    );
  }

  /**
   * 根据角色ID数组获取角色列表
   * @param roleIds 角色ID数组
   * @returns 角色列表
   */
  async getRolesByIds(roleIds: number[]): Promise<SysRole[]> {
    return await this.coreRoleService.getRolesByIds(roleIds);
  }

  /**
   * 检查用户是否为超级管理员
   * @param userId 用户ID
   * @param siteId 站点ID
   * @returns 是否为超级管理员
   */
  async isSuperAdmin(userId: number, siteId: number): Promise<boolean> {
    // TODO: 实现超级管理员检查逻辑
    // 需要与AuthService配合实现
    // 暂时返回false，后续完善权限模块时补充
    return false;
  }

  /**
   * 获取用户的角色权限信息
   * @param userId 用户ID
   * @param siteId 站点ID
   * @returns 角色权限信息
   */
  async getUserRoleInfo(userId: number, siteId: number): Promise<any> {
    // TODO: 实现用户角色信息获取逻辑
    // 需要与用户模块配合实现
    // 暂时返回空对象，后续完善用户模块时补充
    return {
      role_ids: [],
      is_admin: false,
    };
  }
}