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

// API 基础 URL
const API_BASE = 'http://localhost:3001/api'

/**
 * 自定义范式管理 Store
 * 使用服务器端 SQLite 数据库存储
 */
export const useParadigmStore = defineStore('paradigm', () => {
  // 自定义范式列表（从 API 加载）
  const customParadigms = ref([])

  // API 是否可用
  const isApiReady = ref(false)

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

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

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

  /**
   * 从服务器 API 加载自定义范式
   */
  async function loadCustomParadigms() {
    try {
      const response = await fetch(`${API_BASE}/paradigms`)
      const result = await response.json()

      if (result.success) {
        customParadigms.value = result.data
        isApiReady.value = true
        console.log(`✅ 从服务器加载了 ${result.data.length} 个自定义范式`)
      } else {
        console.error('加载自定义范式失败:', result.error)
        customParadigms.value = []
      }
    } catch (error) {
      console.error('API 请求失败（服务器可能未启动）:', error.message)
      customParadigms.value = []
      isApiReady.value = false
    }
  }

  /**
   * 保存单个自定义范式到服务器
   * 新范式使用 POST，已存在的使用 PUT
   */
  async function saveCustomParadigm(paradigm) {
    try {
      // 先尝试 PUT 更新
      const putResponse = await fetch(`${API_BASE}/paradigms/${paradigm.id}`, {
        method: 'PUT',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(paradigm)
      })

      if (putResponse.status === 404) {
        // 范式不存在，使用 POST 创建
        const postResponse = await fetch(`${API_BASE}/paradigms`, {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify(paradigm)
        })
        const result = await postResponse.json()
        if (!result.success) throw new Error(result.error)
        console.log('✅ 创建新范式:', paradigm.name)
      } else {
        const result = await putResponse.json()
        if (!result.success) throw new Error(result.error)
        console.log('✅ 更新范式:', paradigm.name)
      }
    } catch (error) {
      console.error('保存自定义范式失败:', error)
      throw 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 response = await fetch(`${API_BASE}/paradigms/${paradigmId}`, {
        method: 'DELETE'
      })
      const result = await response.json()

      if (result.success) {
        customParadigms.value = customParadigms.value.filter(p => p.id !== paradigmId)
      } else {
        throw new Error(result.error)
      }
    } catch (error) {
      console.error('删除自定义范式失败:', error)
      throw 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} 是否成功
   */
  async 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()

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

  /**
   * 清空所有自定义范式（慎用）
   */
  async function clearAllCustomParadigms() {
    try {
      // 逐个删除
      for (const paradigm of customParadigms.value) {
        await deleteCustomParadigm(paradigm.id)
      }
      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
          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,
    isApiReady,

    // 计算属性
    customParadigmCount,
    recentCustomParadigms,

    // 方法
    loadCustomParadigms,
    saveCustomParadigm,
    addCustomParadigm,
    deleteCustomParadigm,
    getCustomParadigmById,
    updateParadigmField,
    getAllParadigms,
    exportParadigm,
    importParadigm,
    clearAllCustomParadigms,

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