/**
 * localStorage缓存管理器
 * 🚀 性能优化：减少localStorage读写频率，批量操作，内存缓存
 * v3.13.5.4 - 700 token优化
 */

class StorageCache {
  constructor() {
    // 内存缓存
    this.cache = new Map()
    
    // 待写入队列
    this.writeQueue = new Map()
    
    // 批量写入定时器
    this.writeTimer = null
    
    // 批量写入延迟（ms）
    this.WRITE_DELAY = 1000
  }
  
  /**
   * 从缓存或localStorage读取数据
   * @param {string} key - 键名
   * @param {*} defaultValue - 默认值
   * @returns {*} 数据值
   */
  get(key, defaultValue = null) {
    // 优先从内存缓存读取
    if (this.cache.has(key)) {
      return this.cache.get(key)
    }
    
    // 从localStorage读取
    try {
      const value = localStorage.getItem(key)
      if (value === null) {
        return defaultValue
      }
      
      // 尝试解析JSON
      try {
        const parsed = JSON.parse(value)
        // 缓存到内存
        this.cache.set(key, parsed)
        return parsed
      } catch {
        // 不是JSON，直接返回字符串
        this.cache.set(key, value)
        return value
      }
    } catch (error) {
      console.error(`[StorageCache] 读取失败 ${key}:`, error)
      return defaultValue
    }
  }
  
  /**
   * 立即写入数据
   * @param {string} key - 键名
   * @param {*} value - 数据值
   */
  setImmediate(key, value) {
    try {
      // 更新内存缓存
      this.cache.set(key, value)
      
      // 立即写入localStorage
      const stringValue = typeof value === 'string' ? value : JSON.stringify(value)
      localStorage.setItem(key, stringValue)
      
      // 从写入队列中移除（如果存在）
      this.writeQueue.delete(key)
    } catch (error) {
      console.error(`[StorageCache] 立即写入失败 ${key}:`, error)
    }
  }
  
  /**
   * 批量写入数据（延迟写入，减少IO）
   * @param {string} key - 键名
   * @param {*} value - 数据值
   */
  set(key, value) {
    // 更新内存缓存
    this.cache.set(key, value)
    
    // 加入写入队列
    this.writeQueue.set(key, value)
    
    // 启动批量写入定时器
    if (!this.writeTimer) {
      this.writeTimer = setTimeout(() => {
        this.flush()
      }, this.WRITE_DELAY)
    }
  }
  
  /**
   * 批量写入多个键值对
   * @param {Object} entries - 键值对对象
   */
  setMultiple(entries) {
    Object.entries(entries).forEach(([key, value]) => {
      this.set(key, value)
    })
  }
  
  /**
   * 刷新写入队列（立即写入所有待写入数据）
   */
  flush() {
    if (this.writeQueue.size === 0) {
      return
    }
    
    try {
      // 批量写入
      this.writeQueue.forEach((value, key) => {
        try {
          const stringValue = typeof value === 'string' ? value : JSON.stringify(value)
          localStorage.setItem(key, stringValue)
        } catch (error) {
          console.error(`[StorageCache] 写入失败 ${key}:`, error)
        }
      })
      
      console.log(`[StorageCache] 批量写入了 ${this.writeQueue.size} 个键值对`)
    } catch (error) {
      console.error('[StorageCache] 批量写入失败:', error)
    } finally {
      // 清空队列和定时器
      this.writeQueue.clear()
      if (this.writeTimer) {
        clearTimeout(this.writeTimer)
        this.writeTimer = null
      }
    }
  }
  
  /**
   * 删除数据
   * @param {string} key - 键名
   */
  remove(key) {
    // 从缓存删除
    this.cache.delete(key)
    
    // 从队列删除
    this.writeQueue.delete(key)
    
    // 从localStorage删除
    try {
      localStorage.removeItem(key)
    } catch (error) {
      console.error(`[StorageCache] 删除失败 ${key}:`, error)
    }
  }
  
  /**
   * 清空缓存（不删除localStorage数据）
   */
  clearCache() {
    this.cache.clear()
    console.log('[StorageCache] 内存缓存已清空')
  }
  
  /**
   * 清空所有数据
   */
  clear() {
    this.cache.clear()
    this.writeQueue.clear()
    if (this.writeTimer) {
      clearTimeout(this.writeTimer)
      this.writeTimer = null
    }
    try {
      localStorage.clear()
      console.log('[StorageCache] 所有数据已清空')
    } catch (error) {
      console.error('[StorageCache] 清空失败:', error)
    }
  }
  
  /**
   * 获取缓存统计信息
   */
  getStats() {
    return {
      cacheSize: this.cache.size,
      queueSize: this.writeQueue.size,
      hasPendingWrites: this.writeQueue.size > 0
    }
  }
}

// 导出单例
export const storageCache = new StorageCache()

// 页面卸载前刷新所有待写入数据
if (typeof window !== 'undefined') {
  window.addEventListener('beforeunload', () => {
    storageCache.flush()
  })
}

