import { defineStore } from 'pinia'
import { ref, computed } from 'vue'

/**
 * 自定义范式管理 Store
 * 用于管理用户通过需求文档生成的自定义范式
 * 现已迁移到数据库存储（IndexedDB/SQLite）
 */
export const useParadigmStore = defineStore('paradigm', () => {
  // 自定义范式列表（从数据库加载）
  const customParadigms = ref([])

  // 数据库是否已初始化
  const isDbInitialized = ref(false)

  // 当前正在编辑的范式
  const editingParadigm = ref(null)

  // 是否正在解析需求文档
  const isParsing = ref(false)

  // 解析进度信息
  const parsingProgress = ref('')

  /**
   * 从数据库加载自定义范式
   * 如果 localStorage 中有旧数据，自动迁移到数据库
   */
  async function loadCustomParadigms() {
    try {
      // 动态导入数据库模块（避免循环依赖）
      const { getAllParadigms, addParadigm, updateParadigm } = await import('../db/index.js')

      // 从数据库加载所有范式
      const allParadigms = getAllParadigms()

      // 过滤出自定义范式
      customParadigms.value = allParadigms.filter(p => p.isCustom)

      // 检查 localStorage 中是否有旧数据需要迁移
      const localStorageData = localStorage.getItem('customParadigms')
      if (localStorageData && !isDbInitialized.value) {
        try {
          const oldParadigms = JSON.parse(localStorageData)

          if (oldParadigms.length > 0) {
            console.log(`🔄 检测到 localStorage 中有 ${oldParadigms.length} 个范式，开始迁移...`)

            // 迁移每个范式到数据库
            for (const oldParadigm of oldParadigms) {
              // 检查数据库中是否已存在
              const existing = customParadigms.value.find(p => p.id === oldParadigm.id)

              if (existing) {
                // 更新现有范式
                updateParadigm(oldParadigm.id, oldParadigm)
              } else {
                // 添加新范式
                addParadigm({
                  ...oldParadigm,
                  isCustom: true,
                  autoMatchRefs: oldParadigm.autoMatchRefs !== false
                })
              }
            }

            // 重新加载从数据库
            const updatedParadigms = getAllParadigms()
            customParadigms.value = updatedParadigms.filter(p => p.isCustom)

            // 清除 localStorage 中的旧数据
            localStorage.removeItem('customParadigms')

            console.log('✅ 范式迁移完成，localStorage 已清理')
          }
        } catch (migrateError) {
          console.error('❌ 迁移 localStorage 数据失败:', migrateError)
        }
      }

      isDbInitialized.value = true
    } catch (error) {
      console.error('加载自定义范式失败:', error)
      customParadigms.value = []
    }
  }

  /**
   * 保存单个自定义范式到数据库（替换旧的批量保存）
   */
  async function saveCustomParadigm(paradigm) {
    try {
      const { addParadigm, updateParadigm } = await import('../db/index.js')

      // 检查是否已存在
      const existing = customParadigms.value.find(p => p.id === paradigm.id)

      if (existing) {
        // 更新现有范式
        updateParadigm(paradigm.id, paradigm)
      } else {
        // 添加新范式
        addParadigm({
          ...paradigm,
          isCustom: true,
          autoMatchRefs: paradigm.autoMatchRefs !== false
        })
      }
    } catch (error) {
      console.error('保存自定义范式失败:', error)
    }
  }

  /**
   * 添加自定义范式
   * @param {Object} paradigm - 范式对象
   */
  async function addCustomParadigm(paradigm) {
    // 检查是否已存在相同ID
    const index = customParadigms.value.findIndex(p => p.id === paradigm.id)
    if (index >= 0) {
      // 更新现有范式
      customParadigms.value[index] = paradigm
    } else {
      // 添加新范式
      customParadigms.value.push(paradigm)
    }
    await saveCustomParadigm(paradigm)
  }

  /**
   * 删除自定义范式
   * @param {string} paradigmId - 范式ID
   */
  async function deleteCustomParadigm(paradigmId) {
    try {
      const { deleteParadigm } = await import('../db/index.js')
      deleteParadigm(paradigmId)
      customParadigms.value = customParadigms.value.filter(p => p.id !== paradigmId)
    } catch (error) {
      console.error('删除自定义范式失败:', error)
    }
  }

  /**
   * 根据ID获取自定义范式
   * @param {string} paradigmId - 范式ID
   * @returns {Object|null}
   */
  function getCustomParadigmById(paradigmId) {
    return customParadigms.value.find(p => p.id === paradigmId) || null
  }

  /**
   * 更新范式的某个字段
   * @param {string} paradigmId - 范式ID
   * @param {string} field - 字段名
   * @param {any} value - 新值
   */
  async function updateParadigmField(paradigmId, field, value) {
    const paradigm = getCustomParadigmById(paradigmId)
    if (paradigm) {
      paradigm[field] = value
      await saveCustomParadigm(paradigm)
    }
  }

  /**
   * 获取所有范式（包括内置和自定义）
   * @param {Object} builtInParadigms - 内置范式对象
   * @returns {Array}
   */
  function getAllParadigms(builtInParadigms = {}) {
    const builtIn = Object.values(builtInParadigms).map(p => ({
      ...p,
      type: 'builtin'
    }))

    return [
      ...builtIn,
      ...customParadigms.value
    ]
  }

  /**
   * 计算属性：自定义范式数量
   */
  const customParadigmCount = computed(() => customParadigms.value.length)

  /**
   * 计算属性：最近使用的范式（按创建时间排序）
   */
  const recentCustomParadigms = computed(() => {
    return [...customParadigms.value]
      .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt))
      .slice(0, 5)
  })

  /**
   * 导出范式为JSON
   * @param {string} paradigmId - 范式ID
   * @returns {string|null} JSON字符串
   */
  function exportParadigm(paradigmId) {
    const paradigm = getCustomParadigmById(paradigmId)
    if (!paradigm) return null

    try {
      return JSON.stringify(paradigm, null, 2)
    } catch (error) {
      console.error('导出范式失败:', error)
      return null
    }
  }

  /**
   * 从JSON导入范式
   * @param {string} jsonString - JSON字符串
   * @returns {boolean} 是否成功
   */
  function importParadigm(jsonString) {
    try {
      const paradigm = JSON.parse(jsonString)

      // 基本验证
      if (!paradigm.id || !paradigm.name || !paradigm.specializedPrompt) {
        throw new Error('范式格式不正确')
      }

      // 生成新ID避免冲突
      paradigm.id = `custom-imported-${Date.now()}`
      paradigm.createdAt = new Date().toISOString()

      addCustomParadigm(paradigm)
      return true
    } catch (error) {
      console.error('导入范式失败:', error)
      return false
    }
  }

  /**
   * 清空所有自定义范式（慎用）
   */
  async function clearAllCustomParadigms() {
    try {
      const { execute } = await import('../db/index.js')
      execute('DELETE FROM paradigms WHERE is_custom = 1')
      customParadigms.value = []
    } catch (error) {
      console.error('清空自定义范式失败:', error)
    }
  }

  /**
   * 智能推断 guideline 的 scope
   * @param {string|Object} guideline - 检查指令
   * @returns {string} scope ('sentence' | 'paragraph' | 'document')
   */
  function inferScope(guideline) {
    const text = typeof guideline === 'string' ? guideline : (guideline.description || guideline.title || '')

    // 全文级关键词
    if (/篇幅|章节|完整性|结构.*完整|会前准备|典型案例|巡视|巡察/.test(text)) {
      return 'document'
    }

    // 段落级关键词
    if (/递进|逻辑|段落|承接|前后.*呼应|层次|论述|因果/.test(text)) {
      return 'paragraph'
    }

    // 默认句子级
    return 'sentence'
  }

  /**
   * 为现有范式补充 scope 字段（返回新对象，不修改原对象）
   * @param {Object} paradigm - 范式对象
   * @returns {Object} 更新后的范式（新对象）
   */
  function ensureGuidelinesHasScope(paradigm) {
    if (!paradigm.expertGuidelines || !Array.isArray(paradigm.expertGuidelines)) {
      return paradigm
    }

    // 创建深拷贝，避免修改原对象
    const updatedParadigm = {
      ...paradigm,
      expertGuidelines: paradigm.expertGuidelines.map(g => {
        if (typeof g === 'string') {
          // 字符串格式：转换为对象格式并推断 scope
          // 提取前面的关键词作为标题（最多15个字符）
          const title = g.length > 15 ? g.substring(0, 15) : g
          return {
            title: title,
            description: g,
            scope: inferScope(g)
          }
        } else if (!g.scope) {
          // 对象格式但缺少 scope：推断并补充
          return {
            ...g,
            scope: inferScope(g)
          }
        }
        return g
      })
    }

    return updatedParadigm
  }

  // 初始化时加载（异步）
  loadCustomParadigms()

  return {
    // 状态
    customParadigms,
    editingParadigm,
    isParsing,
    parsingProgress,
    isDbInitialized,

    // 计算属性
    customParadigmCount,
    recentCustomParadigms,

    // 方法
    loadCustomParadigms,
    saveCustomParadigm,  // 单个保存（新）
    addCustomParadigm,
    deleteCustomParadigm,
    getCustomParadigmById,
    updateParadigmField,
    getAllParadigms,
    exportParadigm,
    importParadigm,
    clearAllCustomParadigms,

    // Scope 工具函数
    inferScope,
    ensureGuidelinesHasScope
  }
})
