import { defineStore } from 'pinia'
import { getStorage, setStorage, removeStorage } from '@/utils/storage'
import { useUserStore } from './user'

// 固定标签页列表
export const fixedTabs = ['/dashboard']

// 检查是否是固定标签页
export const isFixedTab = (path: string) => fixedTabs.includes(path)

export interface BreadcrumbItem {
  title: string
  path: string
}

export interface TabItem {
  title: string
  path: string
  query?: any
  breadcrumbs?: BreadcrumbItem[]
}

export const useTabsStore = defineStore('tabs', () => {
  const userStore = useUserStore()
  
  // 从本地存储恢复页签数据
  const savedTabs = getStorage('tabs')
  const savedActiveTab = getStorage('activeTab')
  
  // 验证恢复的数据是否有效
  const tabs = ref<TabItem[]>(Array.isArray(savedTabs) && savedTabs.length > 0 ? savedTabs : [])
  const activeTab = ref<string>(
    typeof savedActiveTab === 'string' &&
    tabs.value.some(t => t.path === savedActiveTab)
      ? savedActiveTab
      : '/dashboard'
  )
  
  // 如果没有有效的标签页，初始化添加首页
  if (tabs.value.length === 0) {
    tabs.value.push({
      title: '首页',
      path: '/dashboard'
    })
    activeTab.value = '/dashboard'
  }

  /**
   * 从菜单中查找当前路由的面包屑路径
   * 逻辑：
   * - 第一个永远是一级菜单的名字
   * - 点击一级菜单会跳转到第一个二级菜单
   */
  const findBreadcrumbPath = (path: string): BreadcrumbItem[] => {
    const list: BreadcrumbItem[] = []

    // 如果是首页，直接返回首页
    if (path === '/dashboard') {
      list.push({
        title: '首页',
        path: '/dashboard'
      })
      return list
    }

    // 从菜单中查找当前路由的层级信息
    const findMenuPath = (menus: any[], targetPath: string, parentMenu: any = null): any => {
      for (const menu of menus) {
        const menuPath = menu.path || menu.api || `/menu-${menu.id}`

        if (menuPath === targetPath) {
          return { current: menu, parent: parentMenu }
        }

        // 兼容 children 和 son 两种子菜单字段名
        const subMenus = menu.children || menu.son
        if (subMenus && subMenus.length > 0) {
          const result = findMenuPath(subMenus, targetPath, menu)
          if (result) {
            return result
          }
        }
      }
      return null
    }

    const menuResult = findMenuPath(userStore.sideMenu, path)

    if (menuResult) {
      const { current, parent } = menuResult
      
      // 如果存在父级菜单（一级菜单）
      if (parent) {
        // 获取第一个二级菜单的路径
        const firstChildMenus = parent.children || parent.son
        const firstChildPath = firstChildMenus && firstChildMenus.length > 0
          ? (firstChildMenus[0].path || firstChildMenus[0].api || `/menu-${firstChildMenus[0].id}`)
          : parent.path || parent.api || `/menu-${parent.id}`
        
        // 第一个面包屑是一级菜单的名字，但点击跳转第一个二级菜单
        list.push({
          title: parent.label,
          path: firstChildPath
        })
      }
      
      // 添加当前菜单（二级菜单）
      list.push({
        title: current.label,
        path: current.path || current.api || `/menu-${current.id}`
      })
    }

    // 如果没有找到菜单信息，默认添加首页
    if (list.length === 0) {
      list.push({
        title: '首页',
        path: '/dashboard'
      })
    }

    return list
  }

  // 添加页签
  const addTab = (tab: TabItem) => {
    // 检查是否已存在
    const existIndex = tabs.value.findIndex(item => item.path === tab.path)
    // 计算面包屑路径
    const breadcrumbs = findBreadcrumbPath(tab.path)
    
    if (existIndex === -1) {
      // 新标签页，添加到列表
      tabs.value.push({ ...tab, breadcrumbs })
    } else {
      // 已存在的标签页，更新面包屑（确保数据是最新的）
      const existingTab = tabs.value[existIndex]
      if (existingTab) {
        existingTab.breadcrumbs = breadcrumbs
      }
    }
    activeTab.value = tab.path
    saveTabs()
  }

  // 移除页签
  const removeTab = (path: string) => {
    const index = tabs.value.findIndex(item => item.path === path)
    if (index !== -1) {
      tabs.value.splice(index, 1)
      // 如果移除的是当前激活的页签，则激活前一个或后一个
      if (activeTab.value === path && tabs.value.length > 0) {
        const newIndex = Math.max(0, index - 1)
        const newTab = tabs.value[newIndex]
        if (newTab) {
          activeTab.value = newTab.path
        }
      }
      saveTabs()
    }
  }

  // 关闭其他页签（保留固定标签页和当前标签）
  const closeOtherTabs = (path: string) => {
    const currentTab = tabs.value.find(item => item.path === path)
    if (currentTab) {
      // 获取所有固定标签页
      const fixedTabItems = tabs.value.filter(item => isFixedTab(item.path))
      // 合并固定标签页和当前标签（去重）
      const newTabs = [...fixedTabItems]
      if (!isFixedTab(path)) {
        newTabs.push(currentTab)
      }
      tabs.value = newTabs
      activeTab.value = path
      saveTabs()
    }
  }

  // 关闭所有页签（只保留固定标签页）
  const closeAllTabs = () => {
    // 保留所有固定标签页
    const fixedTabItems = tabs.value.filter(item => isFixedTab(item.path))
    // 如果没有固定标签页，添加首页
    if (fixedTabItems.length === 0) {
      fixedTabItems.push({
        title: '首页',
        path: '/dashboard'
      })
    }
    tabs.value = fixedTabItems
    activeTab.value = '/dashboard'
    saveTabs()
  }

  // 关闭左侧页签（保留所有固定标签页）
  const closeLeftTabs = (path: string) => {
    const index = tabs.value.findIndex(item => item.path === path)
    if (index > 0) {
      // 收集要保留的标签：所有固定标签页 + 从右键点击位置开始的标签
      const tabsToKeep: TabItem[] = []

      for (let i = 0; i < tabs.value.length; i++) {
        const tab = tabs.value[i]
        if (!tab) continue
        if (isFixedTab(tab.path) || i >= index) {
          // 固定标签页或位于/右侧的标签保留
          tabsToKeep.push(tab)
        }
      }

      tabs.value = tabsToKeep
      saveTabs()
    }
  }

  // 关闭右侧页签（保留所有固定标签页）
  const closeRightTabs = (path: string) => {
    const index = tabs.value.findIndex(item => item.path === path)
    if (index !== -1) {
      // 收集要保留的标签：所有固定标签页 + 从右键点击位置开始的标签
      const tabsToKeep: TabItem[] = []

      for (let i = 0; i < tabs.value.length; i++) {
        const tab = tabs.value[i]
        if (!tab) continue
        if (isFixedTab(tab.path) || i <= index) {
          // 固定标签页或位于左侧的标签保留
          tabsToKeep.push(tab)
        }
      }

      tabs.value = tabsToKeep
      saveTabs()
    }
  }

  // 设置当前激活的页签
  const setActiveTab = (path: string) => {
    activeTab.value = path
    saveTabs()
  }

  // 刷新指定 tab 的 key（用于触发组件刷新）
  const refreshKey = ref<string>('')
  
  // 刷新指定路径的 tab
  const refreshTab = (path: string) => {
    refreshKey.value = path + '-' + Date.now()
  }

  // 保存到本地存储
  const saveTabs = () => {
    setStorage('tabs', tabs.value)
    setStorage('activeTab', activeTab.value)
  }

  // 清空页签（重新登录时调用，保留固定页签）
  const clearTabs = () => {
    // 只保留固定页签
    const fixedTabItems = tabs.value.filter(item => isFixedTab(item.path))
    // 如果没有固定页签，至少添加首页
    if (fixedTabItems.length === 0) {
      tabs.value = [{
        title: '首页',
        path: '/dashboard'
      }]
      activeTab.value = '/dashboard'
    } else {
      tabs.value = fixedTabItems
      const firstFixedTab = fixedTabItems[0]
      activeTab.value = firstFixedTab ? firstFixedTab.path : '/dashboard'
    }
    saveTabs()
  }

  // 初始化默认首页标签
  const initDefaultTab = () => {
    // 检查是否已有有效的标签页
    if (tabs.value.length === 0) {
      tabs.value.push({
        title: '首页',
        path: '/dashboard'
      })
      activeTab.value = '/dashboard'
      saveTabs()
    }
  }

  // 验证并恢复标签页状态（用于应用启动时检查）
  const validateAndRecoverTabs = () => {
    const savedTabs = getStorage('tabs')
    const savedActiveTab = getStorage('activeTab')
    
    // 如果存储中没有数据或者数据无效
    if (!savedTabs || !Array.isArray(savedTabs) || savedTabs.length === 0) {
      initDefaultTab()
      return
    }
    
    // 验证当前激活的标签页是否在列表中
    if (savedActiveTab && !savedTabs.some((t: TabItem) => t.path === savedActiveTab)) {
      // 激活的标签页不在列表中，切换到第一个有效的标签页
      if (savedTabs.length > 0) {
        activeTab.value = savedTabs[0].path
        saveTabs()
      } else {
        initDefaultTab()
      }
    }
  }

  // 设置标签页列表（用于拖拽排序）
  const setTabs = (newTabs: TabItem[]) => {
    tabs.value = newTabs
    saveTabs()
  }

  // 获取当前激活标签页的面包屑
  const currentBreadcrumbs = computed<BreadcrumbItem[]>(() => {
    const currentTab = tabs.value.find(item => item.path === activeTab.value)
    if (currentTab && currentTab.breadcrumbs) {
      return currentTab.breadcrumbs
    }
    // 默认返回首页
    return [{ title: '首页', path: '/dashboard' }]
  })

  return {
    tabs,
    activeTab,
    currentBreadcrumbs,
    addTab,
    removeTab,
    closeOtherTabs,
    closeAllTabs,
    closeLeftTabs,
    closeRightTabs,
    setActiveTab,
    clearTabs,
    setTabs,
    refreshKey,
    refreshTab,
    initDefaultTab,
    validateAndRecoverTabs
  }
})
