import { listConvert } from '@/api/system/unitConverter/sysUnitConverter.js'
import { defineStore } from 'pinia'

// 定义计量单位接口
export interface UnitItem {
  id: number
  unitType: string
  unitName: string
  conversionFactor: number
  unitOrder: number
  baseUnit: string
  status: string
  unitTypeName: string
}

export interface UnitQueryParams {
  pageNum: number
  pageSize: number
  unitType: string | null
  unitName: string | null
  baseUnit: string | null
  conversionFactor: number | null
  unitTypeName: string | null
  status: string | null
  unitOrder: number | null
}

// 定义按类型分组的单位数据结构
export interface GroupedUnitData {
  [unitType: string]: UnitItem[]
}

export const useUnitStore = defineStore('unit', {
  state: () => ({
    // 单位数据列表
    unitData: [] as UnitItem[],
    // 按类型分组后的单位数据
    groupedUnitData: {} as GroupedUnitData,
    // 查询参数
    queryParams: {
      pageNum: 1,
      pageSize: 1000,
      unitType: null,
      unitName: null,
      baseUnit: null,
      conversionFactor: null,
      unitTypeName: null,
      status: null,
      unitOrder: null
    } as UnitQueryParams,
    // 加载状态
    loading: false,
    // 总条数
    total: 0,
    // 错误信息
    error: null as string | null
  }),

  getters: {
    // 获取所有单位类型
    unitTypes: (state) => {
      return Object.keys(state.groupedUnitData)
    },

    // 获取特定类型的单位列表
    getUnitsByType: (state) => {
      return (unitType: string) => {
        return state.groupedUnitData[unitType] || []
      }
    },

    // 获取基本单位
    getBaseUnit: (state) => {
      return (unitType: string) => {
        const units = state.groupedUnitData[unitType] || []
        // 微信小程序中baseUnit可能是'1'，APP可能是'Y'，做兼容处理
        return units.find(unit => unit.baseUnit === '1' || unit.baseUnit === 'Y') || units[0]
      }
    },

    // 按类型排序的单位数据
    sortedUnitTypes: (state) => {
      return Object.keys(state.groupedUnitData).sort()
    },
    
    // 是否有错误
    hasError: (state) => {
      return !!state.error
    }
  },

  actions: {
    // 按单位类型分组
    groupByUnitType(data: UnitItem[]): GroupedUnitData {
      return data.reduce((acc: GroupedUnitData, unit: UnitItem) => {
        const type = unit.unitType
        if (!acc[type]) {
          acc[type] = []
        }
        acc[type].push({
          id: unit.id,
          unitType: unit.unitType,
          unitName: unit.unitName,
          conversionFactor: unit.conversionFactor,
          unitOrder: unit.unitOrder,
          baseUnit: unit.baseUnit,
          status: unit.status,
          unitTypeName: unit.unitTypeName
        })
        // 按单位排序
        acc[type].sort((a, b) => (a.unitOrder || 0) - (b.unitOrder || 0))
        return acc
      }, {})
    },

    // 设置查询参数
    setQueryParams(params: Partial<UnitQueryParams>) {
      this.queryParams = { ...this.queryParams, ...params }
    },

    // 重置查询参数
    resetQueryParams() {
      this.queryParams = {
        pageNum: 1,
        pageSize: 1000,
        unitType: null,
        unitName: null,
        baseUnit: null,
        conversionFactor: null,
        unitTypeName: null,
        status: null,
        unitOrder: null
      }
    },

    // 获取单位列表 - 兼容多平台，带错误处理
    async getList() {
      this.loading = true
      this.error = null
      
      try {
        const response = await listConvert(this.queryParams)
        console.log('单位数据:', response)
        this.unitData = response.rows || []
        this.total = response.total || 0
        this.groupedUnitData = this.groupByUnitType(this.unitData)
        
        // 兼容多平台存储
        this.saveUnitDataToStorage()
        
        console.log('单位数据获取成功，类型数量:', Object.keys(this.groupedUnitData).length)
        return response
      } catch (error) {
        this.error = error instanceof Error ? error.message : '获取单位数据失败'
        console.error('获取单位数据出错:', error)
        throw error
      } finally {
        this.loading = false
      }
    },
    
    // 安全获取单位列表（失败时使用默认数据）
    async safeGetList() {
      try {
        return await this.getList()
      } catch (error) {
        // 如果已经有默认数据，直接返回
        if (this.unitData.length > 0) {
          console.log('使用现有单位数据')
          return { rows: this.unitData, total: this.unitData.length }
        }
        // 尝试从缓存加载
        const cachedData = this.loadFromStorage()
        if (cachedData && Object.keys(cachedData).length > 0) {
          console.log('使用缓存中的单位数据')
          return { rows: this.unitData, total: this.unitData.length }
        }
        return { rows: [], total: 0 }
      }
    },

    // 从存储加载缓存的单位数据 - 兼容多平台
    loadFromStorage(): GroupedUnitData | false {
      try {
        let storedData = null
        
        // 统一使用uni API作为基础（跨平台兼容）
        try {
          storedData = uni.getStorageSync('unitData')
        } catch (e) {
          // 备用方案：H5/localStorage
          if (typeof localStorage !== 'undefined') {
            storedData = localStorage.getItem('unitData')
          }
        }
        
        if (!storedData) {
          console.log('无缓存的单位数据')
          return false // 明确返回false，避免undefined
        }
        
        // 处理JSON字符串和对象两种情况
        const parsedData = typeof storedData === 'string' 
          ? JSON.parse(storedData) 
          : storedData
        
        // 验证数据结构
        if (typeof parsedData !== 'object' || parsedData === null) {
          console.warn('缓存的单位数据格式无效')
          return false
        }
        
        this.groupedUnitData = parsedData
        // 从分组数据中提取所有单位
        this.unitData = Object.values(this.groupedUnitData).flat()
        
        console.log('从缓存加载单位数据成功，类型数:', Object.keys(this.groupedUnitData).length)
        return this.groupedUnitData
      } catch (error) {
        console.error('从存储加载单位数据失败:', error)
        return false // 明确返回false
      }
    },

    // 保存单位数据到存储 - 兼容多平台
    saveUnitDataToStorage(): boolean {
      try {
        const dataStr = JSON.stringify(this.groupedUnitData)
        
        // 优先使用uni API
        try {
          uni.setStorageSync('unitData', dataStr)
        } catch (e) {
          // 备用方案：H5/localStorage
          if (typeof localStorage !== 'undefined') {
            localStorage.setItem('unitData', dataStr)
          } else {
            throw e
          }
        }
        
        console.log('单位数据已保存到缓存')
        return true
      } catch (error) {
        console.error('保存单位数据到存储失败:', error)
        return false
      }
    },

    // 清除存储中的单位数据 - 兼容多平台
    clearStorage(): boolean {
      try {
        // 优先使用uni API
        try {
          uni.removeStorageSync('unitData')
        } catch (e) {
          // 备用方案：H5/localStorage
          if (typeof localStorage !== 'undefined') {
            localStorage.removeItem('unitData')
          } else {
            throw e
          }
        }
        
        return true
      } catch (error) {
        console.error('清除存储单位数据失败:', error)
        return false
      }
    },

    // 单位转换方法
    convertUnit(value: number, fromUnit: UnitItem, toUnit: UnitItem): number {
      if (!fromUnit || !toUnit) {
        throw new Error('单位参数不能为空')
      }
      
      if (fromUnit.unitType !== toUnit.unitType) {
        throw new Error('单位类型不匹配，无法转换')
      }
      
      // 先转换到基本单位，再从基本单位转换到目标单位
      const valueInBaseUnit = value * (fromUnit.conversionFactor || 1)
      return valueInBaseUnit / (toUnit.conversionFactor || 1)
    },

    // 根据单位名称查找单位
    findUnitByName(unitName: string): UnitItem | undefined {
      return this.unitData.find(unit => unit.unitName === unitName)
    },

    // 根据ID查找单位
    findUnitById(id: number): UnitItem | undefined {
      return this.unitData.find(unit => unit.id === id)
    },

    // 刷新单位数据
    async refresh() {
      return await this.safeGetList()
    },

    // 获取有效的单位列表（状态为正常的）
    getActiveUnits(unitType?: string): UnitItem[] {
      const units = unitType 
        ? (this.groupedUnitData[unitType] || [])
        : this.unitData
      
      // 状态可能为'0'或'正常'，做兼容处理
      return units.filter(unit => 
        unit.status === '0' || unit.status === '正常' || unit.status === '1'
      )
    },

    // 根据类型和名称模糊查询单位
    searchUnits(type: string, keyword: string): UnitItem[] {
      const units = this.groupedUnitData[type] || []
      return units.filter(unit => 
        unit.unitName.includes(keyword) || 
        (unit.unitTypeName && unit.unitTypeName.includes(keyword))
      )
    },

    // 恢复单位数据（兼容旧接口名）
    restoreUnitDataFromLocal() {
      return this.loadFromStorage()
    },

    // 清除错误
    clearError() {
      this.error = null
    }
  }
})

export default useUnitStore