import { defineStore } from 'pinia'
import { ref } from 'vue'
import type { Menu, RouteRecord } from '@/types'
import { getMenuListApi, getUserMenuTree } from '@/api/menu'
import { useUserStore } from './user'
import router from '@/router'

export const usePermissionStore = defineStore('permission', () => {
  // 菜单列表
  const menuList = ref<Menu[]>([])
  
  // 路由列表
  const routes = ref<RouteRecord[]>([])
  
  // 权限列表
  const permissions = ref<string[]>([])
  
  // 获取菜单列表
  const getMenuList = async (): Promise<Menu[]> => {
    try {
      const response: Menu[] = await getMenuListApi()
      menuList.value = response
      return response
    } catch (error) {
      console.error('获取菜单列表失败:', error)
      return []
    }
  }
  
  // 生成路由
  const generateRoutes = (menus: Menu[]): RouteRecord[] => {
    const routes: RouteRecord[] = []
    
    menus.forEach(menu => {
      if (menu.menuType === '0') {
        // 目录
        const route: RouteRecord = {
          path: menu.path,
          name: menu.menuName,
          meta: {
            title: menu.menuName,
            icon: menu.icon,
            requiresAuth: true,
            permissions: menu.perms ? [menu.perms] : []
          },
          children: menu.children ? generateRoutes(menu.children) : []
        }
        routes.push(route)
      } else if (menu.menuType === '1') {
        // 菜单
        const route: RouteRecord = {
          path: menu.path,
          name: menu.menuName,
          component: () => import(/* @vite-ignore */ `@/views${menu.component}`),
          meta: {
            title: menu.menuName,
            icon: menu.icon,
            requiresAuth: true,
            permissions: menu.perms ? [menu.perms] : []
          }
        }
        routes.push(route)
      }
    })
    
    return routes
  }
  
  // 构建路由
  const buildRoutes = async (): Promise<RouteRecord[]> => {
    try {
      const menus = await getMenuList()
      const generatedRoutes = generateRoutes(menus)
      
      // 添加动态路由
      generatedRoutes.forEach(route => {
        router.addRoute(route as any)
      })
      
      routes.value = generatedRoutes
      return generatedRoutes
    } catch (error) {
      console.error('构建路由失败:', error)
      return []
    }
  }
  
  // 检查菜单权限
  const checkMenuPermission = (menu: Menu): boolean => {
    const userStore = useUserStore()
    
    if (!menu.perms) return true
    
    return userStore.hasPermission(menu.perms)
  }
  
  // 过滤有权限的菜单
  const filterMenuByPermission = (menus: Menu[]): Menu[] => {
    return menus.filter(menu => {
      if (!checkMenuPermission(menu)) return false
      
      if (menu.children && menu.children.length > 0) {
        menu.children = filterMenuByPermission(menu.children)
        return menu.children.length > 0
      }
      
      return true
    })
  }
  
  // 获取有权限的菜单列表
  const getPermissionMenuList = async (): Promise<Menu[]> => {
    try {
      const menus = await getMenuList()
      const filteredMenus = filterMenuByPermission(menus)
      menuList.value = filteredMenus
      return filteredMenus
    } catch (error) {
      console.error('获取权限菜单列表失败:', error)
      return []
    }
  }

  // 根据用户ID获取用户菜单权限
  const getUserPermissionMenus = async (userId: number): Promise<Menu[]> => {
    try {
      const response = await getUserMenuTree(userId)
      if (response.code === 200) {
        menuList.value = response.data || []
        return response.data || []
      } else {
        console.error('获取用户菜单权限失败:', response.message)
        return []
      }
    } catch (error) {
      console.error('获取用户菜单权限失败:', error)
      return []
    }
  }
  
  // 重置状态
  const resetState = (): void => {
    menuList.value = []
    routes.value = []
    permissions.value = []
  }
  
  return {
    // 状态
    menuList,
    routes,
    permissions,
    
    // 方法
    getMenuList,
    generateRoutes,
    buildRoutes,
    checkMenuPermission,
    filterMenuByPermission,
    getPermissionMenuList,
    getUserPermissionMenus,
    resetState
  }
})