import { listConvert } from '@/api/system/convert.js'

// 创建一个简单的单位数据管理器
const UnitStore = {
  // 状态数据
  data: {
    unitData: [],
    groupedUnitData: {},
    queryParams: {
      pageNum: 1,
      pageSize: 1000,
      unitType: null,
      unitName: null,
      baseUnit: null,
      conversionFactor: null,
      unitTypeName: null,
      status: null,
      unitOrder: null
    },
    loading: false,
    total: 0
  },

  // 按单位类型分组
  groupByUnitType(data) {
    return data.reduce((acc, unit) => {
      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) {
    Object.assign(this.data.queryParams, params)
  },

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

  // 获取单位列表
  async getList() {
    this.data.loading = true
    try {
      const res = await listConvert(this.data.queryParams)
      this.data.unitData = res.rows || []
      this.data.total = res.total || 0
      this.data.groupedUnitData = this.groupByUnitType(this.data.unitData)
      
      // 保存到localStorage
      localStorage.setItem('unitData', JSON.stringify(this.data.groupedUnitData))
      
      return res
    } catch (error) {
      console.error('获取单位数据失败:', error)
      throw error
    } finally {
      this.data.loading = false
    }
  },

  // 从localStorage加载缓存的单位数据
  loadFromLocalStorage() {
    try {
      const storedData = localStorage.getItem('unitData')
      if (storedData) {
        this.data.groupedUnitData = JSON.parse(storedData)
        // 从分组数据中提取所有单位
        this.data.unitData = Object.values(this.data.groupedUnitData).flat()
        return true
      }
    } catch (error) {
      console.error('从localStorage加载单位数据失败:', error)
    }
    return false
  },

  // 清除localStorage中的单位数据
  clearLocalStorage() {
    localStorage.removeItem('unitData')
  },

  // 单位转换方法
  convertUnit(value, fromUnit, toUnit) {
    if (fromUnit.unitType !== toUnit.unitType) {
      throw new Error('单位类型不匹配，无法转换')
    }
    
    const valueInBaseUnit = value * (fromUnit.conversionFactor || 1)
    return valueInBaseUnit / (toUnit.conversionFactor || 1)
  },

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

  // 根据ID查找单位
  findUnitById(id) {
    return this.data.unitData.find(unit => unit.id === id)
  },

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

  // 获取有效的单位列表
  getActiveUnits(unitType) {
    const units = unitType 
      ? (this.data.groupedUnitData[unitType] || [])
      : this.data.unitData
    
    return units.filter(unit => unit.status === '0')
  },

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

  // getter 方法
  getUnitTypes() {
    return Object.keys(this.data.groupedUnitData)
  },

  getUnitsByType(unitType) {
    return this.data.groupedUnitData[unitType] || []
  },

  getBaseUnit(unitType) {
    const units = this.data.groupedUnitData[unitType] || []
    return units.find(unit => unit.baseUnit === '1') || units[0]
  },

  getSortedUnitTypes() {
    return Object.keys(this.data.groupedUnitData).sort()
  }
}

export default UnitStore