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

/**
 * 通用数据项接口
 * 可根据实际需求扩展字段
 */
export interface DataItem {
  id: string
  [key: string]: any
}

/**
 * 查询条件接口
 */
export interface QueryCondition {
  field?: string
  value?: any
  operator?: 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte' | 'includes'
}

/**
 * 通用对象存储 Store
 * 提供增删改查功能，state 中保存的是对象结构
 */
export const useDataStore = defineStore('zx', () => {
  // ==================== State ====================
  /**
   * 数据存储对象
   * 结构：{ [id: string]: DataItem }
   */
  const items = ref<Record<string, DataItem>>({})

  // ==================== Getters ====================
  /**
   * 获取所有数据项（数组形式）
   */
  const allItems = computed<DataItem[]>(() => {
    return Object.values(items.value)
  })

  /**
   * 获取数据项数量
   */
  const count = computed<number>(() => {
    return Object.keys(items.value).length
  })

  /**
   * 获取所有 ID 列表
   */
  const allIds = computed<string[]>(() => {
    return Object.keys(items.value)
  })

  // ==================== Actions ====================

  /**
   * 创建/新增数据项
   * @param item 要添加的数据项（必须包含 id 字段）
   * @returns 是否成功
   * 
   * @example
   * ```ts
   * const store = useDataStore()
   * await store.create({ id: '1', name: '测试', value: 100 })
   * ```
   */
  const create = async (item: DataItem): Promise<boolean> => {
    if (!item || !item.id) {
      console.warn('[DataStore] 创建失败：缺少 id 字段')
      return false
    }

    const id = String(item.id)
    
    // 检查是否已存在
    if (items.value[id]) {
      console.warn(`[DataStore] 创建失败：ID "${id}" 已存在`)
      return false
    }

    // 深拷贝后存储
    items.value[id] = JSON.parse(JSON.stringify(item))
    console.log(`[DataStore] 创建成功：${id}`)
    return true
  }

  /**
   * 批量创建数据项
   * @param itemList 数据项数组
   * @returns 成功创建的数量
   * 
   * @example
   * ```ts
   * await store.createBatch([
   *   { id: '1', name: '项目1' },
   *   { id: '2', name: '项目2' }
   * ])
   * ```
   */
  const createBatch = async (itemList: DataItem[]): Promise<number> => {
    let successCount = 0
    
    for (const item of itemList) {
      const result = await create(item)
      if (result) successCount++
    }
    
    console.log(`[DataStore] 批量创建完成：成功 ${successCount}/${itemList.length}`)
    return successCount
  }

  /**
   * 更新或插入数据项（Upsert）
   * 如果 ID 存在则更新，不存在则创建
   * @param item 数据项（必须包含 id 字段）
   * @returns 操作类型：'created' | 'updated'
   * 
   * @example
   * ```ts
   * const result = await store.upsert({ id: '1', name: '测试', value: 100 })
   * console.log(result) // 'created' 或 'updated'
   * ```
   */
  const upsert = async (item: DataItem): Promise<'created' | 'updated'> => {
    if (!item || !item.id) {
      console.warn('[DataStore] Upsert 失败：缺少 id 字段')
      throw new Error('数据项必须包含 id 字段')
    }

    const id = String(item.id)
    const exists = Object.prototype.hasOwnProperty.call(items.value, id)
    
    // 深拷贝后存储
    items.value[id] = JSON.parse(JSON.stringify(item))
    
    if (exists) {
      console.log(`[DataStore] Upsert 更新：${id}`)
      return 'updated'
    } else {
      console.log(`[DataStore] Upsert 创建：${id}`)
      return 'created'
    }
  }

  /**
   * 批量更新或插入数据项（Batch Upsert）
   * @param itemList 数据项数组
   * @returns 统计信息：{ created: number, updated: number }
   * 
   * @example
   * ```ts
   * const stats = await store.upsertBatch([
   *   { id: '1', name: '项目1' },  // 如果存在则更新，否则创建
   *   { id: '2', name: '项目2' }
   * ])
   * console.log(stats) // { created: 1, updated: 1 }
   * ```
   */
  const upsertBatch = async (itemList: DataItem[]): Promise<{ created: number; updated: number }> => {
    let createdCount = 0
    let updatedCount = 0
    
    for (const item of itemList) {
      const result = await upsert(item)
      if (result === 'created') {
        createdCount++
      } else {
        updatedCount++
      }
    }
    
    console.log(`[DataStore] 批量 Upsert 完成：创建 ${createdCount} 条，更新 ${updatedCount} 条，共 ${itemList.length} 条`)
    return { created: createdCount, updated: updatedCount }
  }

  /**
   * 读取单个数据项
   * @param id 数据项 ID
   * @returns 数据项副本，不存在则返回 null
   * 
   * @example
   * ```ts
   * const item = await store.read('1')
   * if (item) {
   *   console.log(item.name)
   * }
   * ```
   */
  const read = async (id: string): Promise<DataItem | null> => {
    const key = String(id)
    
    if (!items.value[key]) {
      return null
    }

    // 返回深拷贝，避免外部修改影响 store
    return JSON.parse(JSON.stringify(items.value[key]))
  }

  /**
   * 批量读取数据项
   * @param ids ID 数组
   * @returns 数据项数组（按传入顺序）
   * 
   * @example
   * ```ts
   * const items = await store.readBatch(['1', '2', '3'])
   * ```
   */
  const readBatch = async (ids: string[]): Promise<DataItem[]> => {
    const results: DataItem[] = []
    
    for (const id of ids) {
      const item = await read(id)
      if (item) {
        results.push(item)
      }
    }
    
    return results
  }

  /**
   * 读取所有数据项
   * @returns 所有数据项的数组副本
   */
  const readAll = async (): Promise<DataItem[]> => {
    return JSON.parse(JSON.stringify(allItems.value))
  }

  /**
   * 更新数据项（全量替换）
   * @param id 数据项 ID
   * @param newItem 新的数据项（必须包含 id 字段）
   * @returns 是否成功
   * 
   * @example
   * ```ts
   * await store.update('1', { id: '1', name: '新名称', value: 200 })
   * ```
   */
  const update = async (id: string, newItem: DataItem): Promise<boolean> => {
    const key = String(id)
    
    if (!items.value[key]) {
      console.warn(`[DataStore] 更新失败：ID "${key}" 不存在`)
      return false
    }

    if (!newItem || newItem.id !== id) {
      console.warn('[DataStore] 更新失败：ID 不匹配')
      return false
    }

    // 全量替换
    items.value[key] = JSON.parse(JSON.stringify(newItem))
    console.log(`[DataStore] 更新成功：${key}`)
    return true
  }

  /**
   * 部分更新数据项（合并更新）
   * @param id 数据项 ID
   * @param partialData 要更新的字段（不需要包含 id）
   * @returns 是否成功
   * 
   * @example
   * ```ts
   * await store.patch('1', { name: '新名称' })  // 只更新 name 字段
   * ```
   */
  const patch = async (id: string, partialData: Partial<DataItem>): Promise<boolean> => {
    const key = String(id)
    
    if (!items.value[key]) {
      console.warn(`[DataStore] 部分更新失败：ID "${key}" 不存在`)
      return false
    }

    // 合并更新
    items.value[key] = {
      ...items.value[key],
      ...partialData,
      id: key  // 确保 id 不被修改
    }

    console.log(`[DataStore] 部分更新成功：${key}`)
    return true
  }

  /**
   * 批量更新数据项
   * @param updates 更新操作数组 [{ id, data }]
   * @returns 成功更新的数量
   * 
   * @example
   * ```ts
   * await store.updateBatch([
   *   { id: '1', data: { name: '新名称1' } },
   *   { id: '2', data: { value: 200 } }
   * ])
   * ```
   */
  const updateBatch = async (updates: Array<{ id: string; data: Partial<DataItem> }>): Promise<number> => {
    let successCount = 0
    
    for (const { id, data } of updates) {
      const result = await patch(id, data)
      if (result) successCount++
    }
    
    console.log(`[DataStore] 批量更新完成：成功 ${successCount}/${updates.length}`)
    return successCount
  }

  /**
   * 删除单个数据项
   * @param id 数据项 ID
   * @returns 是否成功
   * 
   * @example
   * ```ts
   * await store.delete('1')
   * ```
   */
  const deleteItem = async (id: string): Promise<boolean> => {
    const key = String(id)
    
    if (!items.value[key]) {
      console.warn(`[DataStore] 删除失败：ID "${key}" 不存在`)
      return false
    }

    delete items.value[key]
    console.log(`[DataStore] 删除成功：${key}`)
    return true
  }

  /**
   * 批量删除数据项
   * @param ids ID 数组
   * @returns 成功删除的数量
   * 
   * @example
   * ```ts
   * await store.deleteBatch(['1', '2', '3'])
   * ```
   */
  const deleteBatch = async (ids: string[]): Promise<number> => {
    let successCount = 0
    
    for (const id of ids) {
      const result = await deleteItem(id)
      if (result) successCount++
    }
    
    console.log(`[DataStore] 批量删除完成：成功 ${successCount}/${ids.length}`)
    return successCount
  }

  /**
   * 清空所有数据
   */
  const clear = async (): Promise<void> => {
    items.value = {}
    console.log('[DataStore] 已清空所有数据')
  }

  /**
   * 根据条件查询数据项
   * @param conditions 查询条件数组
   * @returns 符合条件的数据项数组
   * 
   * @example
   * ```ts
   * // 查询 name 为 "测试" 且 value > 50 的数据
   * const results = await store.query([
   *   { field: 'name', value: '测试', operator: 'eq' },
   *   { field: 'value', value: 50, operator: 'gt' }
   * ])
   * ```
   */
  const query = async (conditions: QueryCondition[]): Promise<DataItem[]> => {
    const results = allItems.value.filter(item => {
      return conditions.every(condition => {
        if (!condition.field) return true
        
        const fieldValue = item[condition.field]
        const targetValue = condition.value
        const operator = condition.operator || 'eq'

        switch (operator) {
          case 'eq':
            return fieldValue === targetValue
          case 'neq':
            return fieldValue !== targetValue
          case 'gt':
            return fieldValue > targetValue
          case 'lt':
            return fieldValue < targetValue
          case 'gte':
            return fieldValue >= targetValue
          case 'lte':
            return fieldValue <= targetValue
          case 'includes':
            return Array.isArray(fieldValue) 
              ? fieldValue.includes(targetValue)
              : String(fieldValue).includes(String(targetValue))
          default:
            return true
        }
      })
    })

    return JSON.parse(JSON.stringify(results))
  }

  /**
   * 根据单个字段值查询
   * @param field 字段名
   * @param value 字段值
   * @returns 符合条件的第一个数据项，不存在则返回 null
   * 
   * @example
   * ```ts
   * const item = await store.findByField('name', '测试')
   * ```
   */
  const findByField = async (field: string, value: any): Promise<DataItem | null> => {
    const results = await query([{ field, value, operator: 'eq' }])
    return results.length > 0 ? results[0] : null
  }

  /**
   * 检查数据项是否存在
   * @param id 数据项 ID
   * @returns 是否存在
   */
  const exists = async (id: string): Promise<boolean> => {
    const key = String(id)
    return Object.prototype.hasOwnProperty.call(items.value, key)
  }

  /**
   * 导出数据（用于备份或迁移）
   * @returns 所有数据的数组形式
   */
  const exportData = async (): Promise<DataItem[]> => {
    return JSON.parse(JSON.stringify(allItems.value))
  }

  /**
   * 导入数据（用于恢复或迁移）
   * @param dataList 数据数组
   * @param options 导入选项
   *   - replace: 是否替换现有数据（默认 false，即合并）
   * 
   * @example
   * ```ts
   * // 合并导入
   * await store.importData(dataArray)
   * 
   * // 替换导入
   * await store.importData(dataArray, { replace: true })
   * ```
   */
  const importData = async (
    dataList: DataItem[],
    options?: { replace?: boolean }
  ): Promise<void> => {
    if (options?.replace) {
      await clear()
    }

    for (const item of dataList) {
      if (item && item.id) {
        items.value[String(item.id)] = JSON.parse(JSON.stringify(item))
      }
    }

    console.log(`[DataStore] 导入完成：${dataList.length} 条数据`)
  }

  // ==================== Return ====================
  return {
    // State
    items,
    
    // Getters
    allItems,
    count,
    allIds,
    
    // CRUD Actions
    create,
    createBatch,
    upsert,
    upsertBatch,
    read,
    readBatch,
    readAll,
    update,
    patch,
    updateBatch,
    deleteItem,
    deleteBatch,
    clear,
    
    // Query Actions
    query,
    findByField,
    exists,
    
    // Import/Export
    exportData,
    importData
  }
}, {
  persist: true  // 启用持久化
})
