// 权限管理工具
import { ref, triggerRef } from 'vue'
import { authAPI, roleAPI } from '../api/auth.js'

// 响应式的权限缓存
const reactiveUserPermissionsCache = ref([])
const reactiveUserRoleCache = ref(null)
const reactiveAccessibleModulesCache = ref([])

// 强制触发响应式更新的函数
const triggerPermissionsUpdate = () => {
  // 使用 triggerRef 强制触发响应式更新
  triggerRef(reactiveUserPermissionsCache)
  triggerRef(reactiveAccessibleModulesCache)
  triggerRef(reactiveUserRoleCache)
  console.log('强制触发响应式权限更新')
}

// 权限代码到模块的映射
// 支持多种权限格式：旧格式、新格式、后端实际返回格式
const permissionCodeToModule = {
  // ========== 制度文件查看和学习模块 ==========
  'read': 'read',
  'read:view': 'read',
  'read:read': 'read',
  'read:upload': 'read',
  'read:favorite': 'read',
  'read:approve': 'read',
  'read:questionBank': 'read',
  
  // ========== 制度文件管理模块 ==========
  'manage': 'manage',
  'manage:file': 'read',
  'manage:sync': 'manage',
  'manage:question': 'manage',
  
  // ========== 知识问答模块 ==========
  'qa': 'qa',
  'qa:chat': 'qa',
  'qa:faq': 'qa',
  
  // ========== 考察和训练模块 ==========
  'exam': 'exam',
  'exam:ai': 'exam',
  'exam:bank': 'exam',
  'exam:paper': 'exam',
  'exam:train': 'exam',
  'exam:exam': 'exam',              // 试卷考核
  'exam:exam:selftest': 'exam',     // 自测组卷
  'exam:exam:taking': 'exam',      // 答题中
  'exam:exam:results': 'exam',     // 成绩单
  
  // ========== 纲要学习模块 ==========
  'mind': 'mind',
  'mind:generate': 'mind',
  'mind:learn': 'mind',
  
  // ========== 综合看板模块 ==========
  'dashboard': 'dashboard',
  'dashboard:alert': 'dashboard',
  'dashboard:decision': 'dashboard',
  
  // ========== 权限管理模块（后端实际格式）==========
  'permission': 'permission',
  'permission:role': 'permission',
  'permission:user': 'permission',
  'permission:manage': 'permission',      // 后端格式
  'permission:query': 'permission',        // 后端格式
  
  // ========== 用户管理相关（→ 权限管理模块）==========
  'user': 'permission',
  'user:manage': 'permission',             // 后端格式
  'user:query': 'permission',               // 后端格式
  'user:create': 'permission',              // 后端格式
  'user:update': 'permission',              // 后端格式
  'user:delete': 'permission',              // 后端格式
  
  // ========== 角色管理相关（→ 权限管理模块）==========
  'role': 'permission',
  'role:manage': 'permission',              // 后端格式
  'role:query': 'permission',                // 后端格式
  'role:create': 'permission',               // 后端格式
  'role:update': 'permission',               // 后端格式
  'role:delete': 'permission',               // 后端格式
  
  // ========== 组织管理相关（包含公司和部门管理 → 权限管理模块）==========
  'organization': 'permission',
  'organization:manage': 'permission',       // 组织管理权限（整合版）
  'organization:query': 'permission',
  'organization:create': 'permission',
  'organization:update': 'permission',
  'organization:delete': 'permission',
  
  // 保留旧格式以兼容（公司和部门权限也映射到组织管理）
  'dept': 'permission',
  'dept:manage': 'permission',              // 后端格式
  'dept:query': 'permission',                // 后端格式
  'dept:create': 'permission',               // 后端格式
  'dept:update': 'permission',               // 后端格式
  'dept:delete': 'permission',               // 后端格式

  'company': 'permission',
  'company:manage': 'permission',            // 后端格式
  'company:query': 'permission',             // 后端格式
  'company:create': 'permission',            // 后端格式
  'company:update': 'permission',            // 后端格式
  'company:delete': 'permission',            // 后端格式
  
  // ========== 日志管理相关（→ 综合看板模块）==========
  'log': 'dashboard',
  'log:manage': 'dashboard',                // 后端格式
  'log:query': 'dashboard',                  // 后端格式
  
  // ========== 系统配置相关（→ 综合看板模块）==========
  'config': 'dashboard',
  'config:manage': 'dashboard',             // 后端格式
  'config:query': 'dashboard',               // 后端格式
  'config:update': 'dashboard',              // 后端格式
  
  // ========== 超级管理员（访问所有模块）==========
  'super_admin': 'all',
  'SUPER_ADMIN': 'all',
  'admin': 'all'
}

// 前缀匹配规则（用于智能匹配）
const permissionPrefixToModule = {
  'read': 'read',
  'manage': 'manage',
  'qa': 'qa',
  'exam': 'exam',
  'mind': 'mind',
  'dashboard': 'dashboard',
  'permission': 'permission',
  'user': 'permission',
  'role': 'permission',
  'dept': 'permission',
  'company': 'permission',
  'organization': 'permission',               // 组织管理（整合版）
  'log': 'dashboard',
  'config': 'dashboard'
}

// 模块名称映射
export const moduleNames = {
  'read': '制度文件查看和学习',
  'manage': '制度文件管理',
  'qa': '知识问答',
  'exam': '考察和训练',
  'mind': '纲要学习',
  'dashboard': '综合看板',
  'permission': '权限管理'
}

// 兼容旧代码 - 非响应式缓存（用于内部使用）
let userPermissionsCache = null
let userRoleCache = null
let userRoleIdCache = null
let accessibleModulesCache = null

// 重试配置
const RETRY_CONFIG = {
  maxRetries: 2,
  retryDelay: 500
}

// 带重试的请求函数
const requestWithRetry = async (fn, retries = RETRY_CONFIG.maxRetries) => {
  try {
    return await fn()
  } catch (error) {
    // 如果是限流错误，不重试
    if (error.isRateLimitError || 
        (error.response?.data?.message && 
         error.response.data.message.includes('请求过于频繁'))) {
      console.warn('⚠️ 检测到限流错误，不进行重试')
      throw error
    }
    
    if (retries > 0) {
      console.log(`请求失败，剩余重试次数: ${retries}`)
      await new Promise(resolve => setTimeout(resolve, RETRY_CONFIG.retryDelay))
      return requestWithRetry(fn, retries - 1)
    }
    throw error
  }
}

// 获取当前用户的主要角色（带缓存优先策略）
export const getCurrentUserRole = async (options = { useCache: true }) => {
  // 优先使用内存缓存
  if (options.useCache && reactiveUserRoleCache.value) {
    console.log('使用响应式缓存的角色:', reactiveUserRoleCache.value)
    return reactiveUserRoleCache.value
  }
  if (options.useCache && userRoleCache) {
    console.log('使用内存缓存的角色:', userRoleCache)
    return userRoleCache
  }
  
  // 其次使用本地存储
  if (options.useCache) {
    const storedRole = getUserRoleFromStorage()
    if (storedRole) {
      console.log('使用本地存储的角色:', storedRole)
      userRoleCache = storedRole
      reactiveUserRoleCache.value = storedRole
      return storedRole
    }
  }
  
  // 最后从API获取
  try {
    const response = await requestWithRetry(() => authAPI.getMainRole())
    if (response.data.code === 200) {
      const roleData = response.data.data
      const roleName = roleData.roleName || roleData.roleCode || roleData
      userRoleCache = roleName
      reactiveUserRoleCache.value = roleName
      saveUserRole(roleName)
      console.log('从API获取角色:', roleName)
      // 强制触发响应式更新
      triggerPermissionsUpdate()
      return roleName
    }
    return null
  } catch (error) {
    console.error('获取用户角色失败:', error)
    // 如果API失败但有缓存，返回缓存
    const storedRole = getUserRoleFromStorage()
    if (storedRole) {
      console.log('API失败，使用本地存储的角色:', storedRole)
      userRoleCache = storedRole
      reactiveUserRoleCache.value = storedRole
      return storedRole
    }
    return null
  }
}

// 获取当前用户的角色名称列表
export const getCurrentUserRoleNames = async () => {
  try {
    const response = await authAPI.getUserRoles()
    if (response.data.code === 200) {
      return response.data.data || []
    }
    return []
  } catch (error) {
    console.error('获取用户角色列表失败:', error)
    return []
  }
}

// 获取所有角色列表（包含ID）
export const getAllRoles = async () => {
  try {
    const response = await roleAPI.getRoles()
    if (response.data.code === 200) {
      return response.data.data || []
    }
    return []
  } catch (error) {
    console.error('获取所有角色失败:', error)
    return []
  }
}

// 根据角色ID获取角色权限
export const getRolePermissions = async (roleId) => {
  try {
    console.log('获取角色权限, roleId:', roleId)
    const response = await roleAPI.getRolePermissions(roleId)
    if (response.data.code === 200) {
      const permissions = response.data.data || []
      console.log('获取到的权限:', permissions)
      return permissions
    }
    return []
  } catch (error) {
    console.error('获取角色权限失败:', error)
    return []
  }
}

// 将权限列表转换为可访问的模块列表
// 拥有任何一个子权限，就可以访问对应模块
export const convertPermissionsToModules = (permissions) => {
  console.log('=========================================')
  console.log('🔄 开始权限转换 - 详细追踪')
  console.log('=========================================')
  console.log('   输入权限数量:', permissions ? permissions.length : 0)
  console.log('   输入权限原始数据:', JSON.stringify(permissions, null, 2))

  if (!permissions || permissions.length === 0) {
    console.log('⚠️ 权限列表为空，返回空模块列表')
    console.log('=========================================')
    return []
  }

  const modules = new Set()
  const permissionCodes = new Set()
  let exactMatchCount = 0
  let prefixMatchCount = 0
  let unableToExtractCount = 0

  permissions.forEach((permission, index) => {
    console.log('---')
    console.log(`📋 处理第 ${index + 1} 个权限...`)
    
    // 支持权限对象或权限代码字符串
    let permissionCode = null

    if (typeof permission === 'string') {
      permissionCode = permission.trim()
      console.log(`✅ 权限格式: 字符串 - "${permissionCode}"`)
    } else if (typeof permission === 'object' && permission !== null) {
      // 尝试不同的字段名（兼容不同的API返回格式）
      const keys = Object.keys(permission)
      console.log(`🔍 权限格式: 对象 - 可用字段: ${keys.join(', ')}`)

      permissionCode = permission.permissionCode ||
                       permission.permission_code ||
                       permission.permission ||
                       permission.code ||
                       permission.permissionName ||
                       permission.permission_name ||
                       permission.name

      if (permissionCode) {
        console.log(`✅ 提取到权限代码: "${permissionCode}"`)
        console.log(`   权限详情: id=${permission.id}, name=${permission.permissionName}, code=${permissionCode}`)
      } else {
        console.warn(`⚠️ 无法从对象中提取权限代码`)
        console.warn(`   完整对象:`, JSON.stringify(permission))
        unableToExtractCount++
        return
      }
    } else {
      console.warn(`⚠️ 不支持的权限类型: ${typeof permission}`)
      unableToExtractCount++
      return
    }

    if (!permissionCode || permissionCode.trim() === '') {
      console.warn(`⚠️ 权限代码为空，跳过`)
      unableToExtractCount++
      return
    }

    // 保存权限代码到缓存，用于后续细粒度控制
    permissionCodes.add(permissionCode)

    // 查找权限代码对应的模块（精确匹配优先）
    const module = permissionCodeToModule[permissionCode]
    if (module) {
      modules.add(module)
      exactMatchCount++
      console.log(`✅ 精确匹配成功: "${permissionCode}" → 可访问模块 "${module}"`)
    } else {
      // 精确匹配失败，尝试前缀匹配（使用冒号前的部分）
      const prefix = permissionCode.split(':')[0]
      const prefixModule = permissionPrefixToModule[prefix]

      if (prefixModule) {
        modules.add(prefixModule)
        prefixMatchCount++
        console.log(`📌 前缀匹配成功: "${permissionCode}" (前缀:"${prefix}") → 可访问模块 "${prefixModule}"`)
      } else {
        console.warn(`⚠️ 未找到匹配的模块: "${permissionCode}"`)
      }
    }
  })

  console.log('---')
  console.log('📊 转换统计汇总:')
  console.log(`   - 总权限数: ${permissions.length}`)
  console.log(`   - 成功提取: ${permissions.length - unableToExtractCount}`)
  console.log(`   - 无法提取: ${unableToExtractCount}`)
  console.log(`   - 精确匹配: ${exactMatchCount}`)
  console.log(`   - 前缀匹配: ${prefixMatchCount}`)

  // 保存权限代码到缓存（同时更新响应式和非响应式）
  const permissionCodeArray = Array.from(permissionCodes)
  userPermissionsCache = permissionCodeArray

  // 使用 splice 替换整个数组，确保响应式更新
  reactiveUserPermissionsCache.value.splice(0, reactiveUserPermissionsCache.value.length, ...permissionCodeArray)

  let result = Array.from(modules)

  console.log('---')
  console.log('📋 最终权限转换结果:')
  console.log(`   - 拥有的权限代码 (${permissionCodeArray.length}个):`, permissionCodeArray)
  console.log(`   - 可访问的模块 (${result.length}个): ${result.length > 0 ? result.join(', ') : '无'}`)

  if (result.length === 0) {
    console.warn('⚠️ 该角色没有任何可访问的模块！')
    console.warn('   请确保在权限管理页面为该角色分配了相应的权限')
  }

  accessibleModulesCache = result

  // 使用 splice 替换整个数组，确保响应式更新
  reactiveAccessibleModulesCache.value.splice(0, reactiveAccessibleModulesCache.value.length, ...result)

  // 特殊处理：如果用户有 'all' 权限，开放所有模块
  if (modules.has('all') || result.includes('all')) {
    console.log('🔑 检测到超级管理员权限，开放所有模块')
    const allModules = ['read', 'manage', 'qa', 'exam', 'mind', 'dashboard', 'permission']
    accessibleModulesCache = allModules
    reactiveAccessibleModulesCache.value.splice(0, reactiveAccessibleModulesCache.value.length, ...allModules)
    result = allModules
  }

  console.log('=========================================')
  console.log('✅ 权限转换完成')
  console.log('=========================================')

  // 强制触发响应式更新
  triggerPermissionsUpdate()

  return result
}

// 验证缓存数据一致性（用于调试）
export const validateCacheConsistency = () => {
  console.log('🔍 验证缓存一致性...')
  
  const issues = []
  
  // 检查非响应式缓存和响应式缓存是否一致
  if (userPermissionsCache && reactiveUserPermissionsCache.value) {
    if (userPermissionsCache.length !== reactiveUserPermissionsCache.value.length) {
      issues.push({
        type: 'permissions_length_mismatch',
        cache: userPermissionsCache.length,
        reactive: reactiveUserPermissionsCache.value.length
      })
    }
  }
  
  if (accessibleModulesCache && reactiveAccessibleModulesCache.value) {
    if (accessibleModulesCache.length !== reactiveAccessibleModulesCache.value.length) {
      issues.push({
        type: 'modules_length_mismatch',
        cache: accessibleModulesCache.length,
        reactive: reactiveAccessibleModulesCache.value.length
      })
    }
  }
  
  // 检查localStorage是否与内存缓存一致
  const storedPermissions = getUserPermissionsFromStorage()
  const storedRole = getUserRoleFromStorage()
  
  if (storedPermissions && userPermissionsCache) {
    if (storedPermissions.length !== userPermissionsCache.length) {
      issues.push({
        type: 'localStorage_permissions_mismatch',
        localStorage: storedPermissions.length,
        memory: userPermissionsCache.length
      })
    }
  }
  
  if (issues.length === 0) {
    console.log('✅ 缓存数据一致')
    return { consistent: true, issues: [] }
  } else {
    console.warn('⚠️ 发现缓存不一致问题:', issues)
    return { consistent: false, issues }
  }
}

// 获取用户可以访问的模块列表（通过角色权限，带缓存优先策略）
export const getAccessibleModules = async (options = { useCache: true, forceRefresh: false }) => {
  // 如果是强制刷新，先清除所有缓存
  if (options.forceRefresh) {
    console.log('强制刷新：清除所有缓存')
    clearUserPermissions()
  }
  
  // 如果不是强制刷新，优先使用内存缓存
  if (!options.forceRefresh && options.useCache && reactiveAccessibleModulesCache.value && reactiveAccessibleModulesCache.value.length > 0) {
    console.log('使用响应式缓存的可访问模块:', reactiveAccessibleModulesCache.value)
    return reactiveAccessibleModulesCache.value
  }
  if (!options.forceRefresh && options.useCache && accessibleModulesCache && accessibleModulesCache.length > 0) {
    console.log('使用内存缓存的可访问模块:', accessibleModulesCache)
    return accessibleModulesCache
  }
  
  // 其次使用本地存储
  if (!options.forceRefresh && options.useCache) {
    const storedPermissions = getUserPermissionsFromStorage()
    if (storedPermissions && storedPermissions.length > 0) {
      console.log('使用本地存储的权限转换模块')
      // ✅ 先转换（这会正确提取 permissionCode 并更新所有缓存）
      const modules = convertPermissionsToModules(storedPermissions)
      accessibleModulesCache = modules
      reactiveAccessibleModulesCache.value = modules
      return modules
    }
  }
  
  try {
    // 获取用户主要角色（使用 /auth/user/main-role API）
    const mainRoleName = await getCurrentUserRole({ useCache: options.useCache })
    console.log('用户主要角色:', mainRoleName)
    
    if (!mainRoleName) {
      console.log('用户没有角色，不允许访问任何模块')
      const emptyModules = []
      accessibleModulesCache = emptyModules
      reactiveAccessibleModulesCache.value.splice(0, reactiveAccessibleModulesCache.value.length, ...emptyModules)
      // 强制触发响应式更新
      triggerPermissionsUpdate()
      return emptyModules
    }
    
    // 获取所有角色（包含ID）
    const allRoles = await requestWithRetry(() => getAllRoles())
    console.log('所有角色:', allRoles)
    
    // 找到用户主要角色对应的角色ID
    const mainRole = allRoles.find(role => 
      role.roleName === mainRoleName || role.roleCode === mainRoleName
    )
    
    if (!mainRole) {
      console.log('无法找到角色信息，使用缓存或空模块列表')
      // 尝试使用缓存
      const storedPermissions = getUserPermissionsFromStorage()
      if (storedPermissions && storedPermissions.length > 0) {
        userPermissionsCache = storedPermissions
        reactiveUserPermissionsCache.value.splice(0, reactiveUserPermissionsCache.value.length, ...storedPermissions)
        const modules = convertPermissionsToModules(storedPermissions)
        accessibleModulesCache = modules
        reactiveAccessibleModulesCache.value.splice(0, reactiveAccessibleModulesCache.value.length, ...modules)
        return modules
      }
      const emptyModules = []
      accessibleModulesCache = emptyModules
      reactiveAccessibleModulesCache.value.splice(0, reactiveAccessibleModulesCache.value.length, ...emptyModules)
      // 强制触发响应式更新
      triggerPermissionsUpdate()
      return emptyModules
    }
    
    const roleId = mainRole.id
    console.log('主要角色:', mainRoleName, '角色ID:', roleId)
    
    // 获取该角色的权限
    const permissions = await requestWithRetry(() => getRolePermissions(roleId))
    console.log('角色权限原始数据:', JSON.stringify(permissions, null, 2))
    
    // 转换为模块列表
    const modules = convertPermissionsToModules(permissions)
    console.log('转换后的可访问模块:', modules)
    
    // 保存到缓存（同时更新响应式和非响应式）
    accessibleModulesCache = modules
    reactiveAccessibleModulesCache.value.splice(0, reactiveAccessibleModulesCache.value.length, ...modules)
    saveUserPermissions(permissions)
    
    // ⚠️ 不添加任何默认权限！
    // 严格按照数据库配置展示权限
    if (modules.length === 0) {
      console.log('权限转换结果为空，该角色没有任何可访问的模块')
    }
    
    return modules
  } catch (error) {
    console.error('获取可访问模块失败:', error)
    // API失败时使用缓存
    const storedPermissions = getUserPermissionsFromStorage()
    if (storedPermissions && storedPermissions.length > 0) {
      console.log('API失败，使用本地存储的权限')
      userPermissionsCache = storedPermissions
      reactiveUserPermissionsCache.value.splice(0, reactiveUserPermissionsCache.value.length, ...storedPermissions)
      const modules = convertPermissionsToModules(storedPermissions)
      accessibleModulesCache = modules
      reactiveAccessibleModulesCache.value.splice(0, reactiveAccessibleModulesCache.value.length, ...modules)
      return modules
    }
    console.log('API失败且没有缓存，返回空模块列表')
    const emptyModules = []
    accessibleModulesCache = emptyModules
    reactiveAccessibleModulesCache.value.splice(0, reactiveAccessibleModulesCache.value.length, ...emptyModules)
    // 强制触发响应式更新
    triggerPermissionsUpdate()
    return emptyModules
  }
}

// 检查用户是否有权限访问某个模块
export const hasPermission = async (module) => {
  try {
    const accessibleModules = await getAccessibleModules()
    return accessibleModules.includes(module)
  } catch (error) {
    console.error('检查权限失败:', error)
    return false
  }
}

// 直接从 localStorage 读取权限（绕过响应式缓存，保证准确）
export const getDirectPermission = (code) => {
  try {
    const stored = JSON.parse(localStorage.getItem('userPermissions'))
    if (Array.isArray(stored)) {
      return stored.some(p => {
        if (typeof p === 'string') return p === code
        return p?.permissionCode === code || p?.permission_code === code
      })
    }
  } catch (e) {}
  return false
}

// 检查用户是否拥有特定子权限（细粒度控制）- 使用响应式缓存
export const hasChildPermission = (permissionCode) => {
  const cache = reactiveUserPermissionsCache.value
  if (cache && Array.isArray(cache)) {
    const result = cache.includes(permissionCode)
    if (permissionCode === 'exam:train') {
      console.log('🔎 [hasChildPermission] 检查 exam:train:')
      console.log('   - 缓存类型:', typeof cache, 'Array:', Array.isArray(cache))
      console.log('   - 缓存长度:', cache.length)
      console.log('   - 缓存内容:', JSON.stringify(cache))
      console.log('   - 检查结果:', result)
    }
    return result
  }
  // 备用：使用非响应式缓存
  if (userPermissionsCache && Array.isArray(userPermissionsCache)) {
    const result = userPermissionsCache.includes(permissionCode)
    if (permissionCode === 'exam:train') {
      console.log('🔎 [hasChildPermission] 使用备用缓存检查 exam:train:')
      console.log('   - 备用缓存内容:', JSON.stringify(userPermissionsCache))
      console.log('   - 检查结果:', result)
    }
    return result
  }
  if (permissionCode === 'exam:train') {
    console.warn('🔎 [hasChildPermission] 检查 exam:train 时缓存为空!')
  }
  return false
}

// 导出响应式权限缓存，供 computed 使用
export const usePermissions = () => {
  return {
    userPermissions: reactiveUserPermissionsCache,
    userRole: reactiveUserRoleCache,
    accessibleModules: reactiveAccessibleModulesCache
  }
}

// 同步检查权限（使用缓存）
export const hasPermissionSync = (module) => {
  if (!userPermissionsCache) {
    return false // 没有缓存时默认不允许访问任何模块
  }
  const modules = convertPermissionsToModules(userPermissionsCache)
  return modules.includes(module)
}

// 获取用户角色信息
export const getUserRoleInfo = () => {
  return {
    role: userRoleCache,
    permissions: userPermissionsCache,
    accessibleModules: userPermissionsCache ? convertPermissionsToModules(userPermissionsCache) : []
  }
}

// 存储用户权限到本地存储
export const saveUserPermissions = (permissions) => {
  localStorage.setItem('userPermissions', JSON.stringify(permissions))
}

// 从本地存储获取用户权限
export const getUserPermissionsFromStorage = () => {
  const stored = localStorage.getItem('userPermissions')
  if (stored) {
    try {
      return JSON.parse(stored)
    } catch (e) {
      return null
    }
  }
  return null
}

// 存储用户角色到本地存储
export const saveUserRole = (role) => {
  localStorage.setItem('userRole', role)
}

// 从本地存储获取用户角色
export const getUserRoleFromStorage = () => {
  return localStorage.getItem('userRole')
}

// 清除用户权限信息
export const clearUserPermissions = () => {
  localStorage.removeItem('userRole')
  localStorage.removeItem('userPermissions')
  // 清除非响应式缓存
  userPermissionsCache = null
  userRoleCache = null
  userRoleIdCache = null
  accessibleModulesCache = null
  // 清除响应式缓存
  reactiveUserPermissionsCache.value = []
  reactiveUserRoleCache.value = null
  reactiveAccessibleModulesCache.value = []
  // 强制触发响应式更新
  triggerPermissionsUpdate()
}

// 初始化用户权限（优先使用缓存）
export const initUserPermissions = async (options = { useCache: true }) => {
  // 如果不使用缓存，直接从API获取，并且清除所有缓存
  if (!options.useCache) {
    console.log('初始化权限 - 强制从API获取，清除所有缓存')
    clearUserPermissions()
    const modules = await getAccessibleModules({ useCache: false, forceRefresh: true })
    const role = await getCurrentUserRole({ useCache: false })
    
    if (role && modules) {
      return {
        role: role,
        modules: modules
      }
    }
    return null
  }
  
  // 先从本地存储获取
  const storedRole = getUserRoleFromStorage()
  const storedPermissions = getUserPermissionsFromStorage()
  
  if (storedRole && storedPermissions) {
    console.log('初始化权限 - 使用本地存储')
    userRoleCache = storedRole
    reactiveUserRoleCache.value = storedRole

    // 先转换为模块（这会同时更新 userPermissionsCache 和 reactiveUserPermissionsCache 为正确的权限代码字符串）
    accessibleModulesCache = convertPermissionsToModules(storedPermissions)

    // ✅ 修复：使用 convertPermissionsToModules 已经处理好的权限代码字符串数组
    // 而不是原始的对象数组
    console.log('✅ 权限缓存已正确初始化:')
    console.log('   - userPermissionsCache 类型:', typeof userPermissionsCache, '长度:', userPermissionsCache?.length)
    console.log('   - reactiveUserPermissionsCache 长度:', reactiveUserPermissionsCache.value?.length)
    console.log('   - exam:train 在缓存中:', userPermissionsCache?.includes('exam:train'))

    return {
      role: storedRole,
      permissions: storedPermissions,
      modules: accessibleModulesCache
    }
  }
  
  // 从API获取
  console.log('初始化权限 - 从API获取')
  const modules = await getAccessibleModules({ useCache: false })
  const role = await getCurrentUserRole({ useCache: false })
  
  if (role && modules) {
    return {
      role: role,
      modules: modules
    }
  }
  
  return null
}

// 刷新用户权限（强制从API刷新）
export const refreshUserPermissions = async () => {
  console.log('刷新用户权限 - 强制从API获取')
  userPermissionsCache = null
  accessibleModulesCache = null
  
  const modules = await getAccessibleModules({ useCache: true, forceRefresh: true })
  const role = await getCurrentUserRole({ useCache: false })
  
  if (role && modules) {
    return {
      role: role,
      modules: modules
    }
  }
  
  return null
}

// 登录后初始化用户权限（根据新API文档重构）
export const initUserPermissionsAfterLogin = async () => {
  console.log('===== 开始初始化用户权限（登录后优化版） =====')
  const startTime = Date.now()
  
  try {
    // 步骤1：获取用户主要角色名称
    console.log('📌 步骤1: 获取用户主要角色...')
    const mainRoleResponse = await authAPI.getMainRole()
    if (mainRoleResponse.data.code !== 200) {
      throw new Error(mainRoleResponse.data.message || '获取用户角色失败')
    }
    
    const mainRoleData = mainRoleResponse.data.data
    const mainRoleName = mainRoleData.roleName || mainRoleData.roleCode || mainRoleData
    console.log('✅ 用户主要角色:', mainRoleName)
    
    // 存储角色信息（同步更新所有缓存层）
    userRoleCache = mainRoleName
    reactiveUserRoleCache.value = mainRoleName
    saveUserRole(mainRoleName)
    
    // 步骤2：获取所有角色列表（包含ID）
    console.log('📌 步骤2: 获取所有角色列表...')
    const allRolesResponse = await roleAPI.getRoles()
    if (allRolesResponse.data.code !== 200) {
      throw new Error(allRolesResponse.data.message || '获取角色列表失败')
    }
    
    const allRoles = allRolesResponse.data.data || []
    console.log('✅ 获取到', allRoles.length, '个角色')
    
    // 步骤3：找到用户的主要角色，获取角色ID
    console.log('📌 步骤3: 查找用户角色ID...')
    const userRole = allRoles.find(role => 
      role.roleName === mainRoleName || role.roleCode === mainRoleName
    )
    
    if (!userRole) {
      console.warn('⚠️ 未找到匹配的角色信息，使用空权限')
      const emptyModules = []
      const emptyPermissions = []
      
      // 同步更新所有缓存
      accessibleModulesCache = emptyModules
      reactiveAccessibleModulesCache.value.splice(0, reactiveAccessibleModulesCache.value.length, ...emptyModules)
      userPermissionsCache = emptyPermissions
      reactiveUserPermissionsCache.value.splice(0, reactiveUserPermissionsCache.value.length, ...emptyPermissions)
      saveUserPermissions(emptyPermissions)
      userRoleIdCache = null
      
      triggerPermissionsUpdate()
      
      const duration = Date.now() - startTime
      console.log('⏱️ 权限初始化完成（无权限）- 耗时:', duration, 'ms')
      return { role: mainRoleName, modules: emptyModules }
    }
    
    const roleId = userRole.id
    userRoleIdCache = roleId
    console.log('✅ 找到用户角色:', userRole.roleName, 'ID:', roleId)
    
    // 步骤4：获取该角色的权限列表
    console.log('📌 步骤4: 获取角色权限...')
    const permissionsResponse = await roleAPI.getRolePermissions(roleId)
    if (permissionsResponse.data.code !== 200) {
      throw new Error(permissionsResponse.data.message || '获取角色权限失败')
    }
    
    const permissions = permissionsResponse.data.data || []
    console.log('✅ 获取到', permissions.length, '个权限')
    
    if (permissions.length > 0) {
      console.log('📋 权限列表:', permissions.map(p => p.permissionCode || p.permission_name || p))
    }
    
    // 步骤5：转换权限为模块并存储（同步更新所有缓存）
    console.log('📌 步骤5: 转换权限并存储...')
    const modules = convertPermissionsToModules(permissions)
    
    // 更新内存缓存
    accessibleModulesCache = modules
    reactiveAccessibleModulesCache.value.splice(0, reactiveAccessibleModulesCache.value.length, ...modules)
    saveUserPermissions(permissions)
    
    // ⚠️ 不添加任何默认权限！
    // 严格按照数据库配置展示权限
    if (modules.length === 0) {
      console.log('⚠️ 权限为空，该角色没有任何可访问的模块')
    }
    
    // 强制触发响应式更新
    triggerPermissionsUpdate()
    
    const duration = Date.now() - startTime
    console.log('⏱️ 权限初始化完成 - 耗时:', duration, 'ms')
    console.log('🎯 最终结果:')
    console.log('   ✅ 角色:', mainRoleName)
    console.log('   ✅ 角色ID:', roleId)
    console.log('   ✅ 权限数量:', permissions.length)
    console.log('   ✅ 可访问模块:', accessibleModulesCache)
    console.log('   ✅ 权限代码:', userPermissionsCache)
    
    return {
      role: mainRoleName,
      roleId: roleId,
      permissions: permissions,
      modules: accessibleModulesCache,
      permissionCodes: userPermissionsCache
    }
    
  } catch (error) {
    console.error('❌ 登录后权限初始化失败:', error)
    console.error('   错误详情:', error.message)
    console.error('   错误堆栈:', error.stack)
    
    // 失败时设置空权限（严格按照数据库配置）
    const emptyModules = []
    const emptyPermissions = []
    
    accessibleModulesCache = emptyModules
    reactiveAccessibleModulesCache.value.splice(0, reactiveAccessibleModulesCache.value.length, ...emptyModules)
    userPermissionsCache = emptyPermissions
    reactiveUserPermissionsCache.value.splice(0, reactiveUserPermissionsCache.value.length, ...emptyPermissions)
    saveUserPermissions(emptyPermissions)
    
    triggerPermissionsUpdate()
    
    throw error
  }
}

export default {
  moduleNames,
  getCurrentUserRole,
  getCurrentUserRoleNames,
  getAllRoles,
  getRolePermissions,
  convertPermissionsToModules,
  getAccessibleModules,
  hasPermission,
  hasChildPermission,
  getDirectPermission,
  hasPermissionSync,
  getUserRoleInfo,
  saveUserPermissions,
  getUserPermissionsFromStorage,
  saveUserRole,
  getUserRoleFromStorage,
  clearUserPermissions,
  initUserPermissions,
  refreshUserPermissions,
  initUserPermissionsAfterLogin,
  validateCacheConsistency
}
