/**
 * 批量删除优化工具
 * 用于高性能批量删除token和bin文件
 */

import indexedDBStorage from './indexedDBStorage.js'

/**
 * 批量删除tokens（优化版）
 * @param {Array} tokenIds - 要删除的token ID数组
 * @param {Function} closeConnectionFn - 关闭WebSocket连接的函数
 * @returns {Object} 删除结果统计
 */
export async function batchDeleteTokens(tokenIds, closeConnectionFn) {
  const startTime = performance.now()
  
  console.log(`🗑️ 开始批量删除 ${tokenIds.length} 个token...`)
  
  const stats = {
    total: tokenIds.length,
    tokensDeleted: 0,
    binFilesDeleted: 0,
    connectionsCloses: 0,
    errors: []
  }
  
  try {
    // 1. 关闭所有WebSocket连接（同步，快速）
    tokenIds.forEach(tokenId => {
      if (closeConnectionFn) {
        try {
          closeConnectionFn(tokenId)
          stats.connectionsCloses++
        } catch (e) {
          stats.errors.push({ type: 'closeConnection', tokenId, error: e.message })
        }
      }
    })
    
    // 2. 收集所有binFileId
    // （注意：这里需要从外部传入tokens数组，因为这个工具类不应该依赖store）
    
    // 3. 删除操作将在调用方完成
    
    const duration = performance.now() - startTime
    console.log(`✅ 批量删除完成，耗时: ${duration.toFixed(2)}ms`)
    console.log(`   关闭连接: ${stats.connectionsCloses}个`)
    
    return stats
  } catch (error) {
    console.error('❌ 批量删除失败:', error)
    throw error
  }
}

/**
 * 批量并行删除bin文件（优化版）
 * 使用分批并行策略，平衡性能和内存占用
 * 
 * @param {Array} binFileIds - bin文件ID数组
 * @param {Number} batchSize - 每批处理数量，默认100
 * @returns {Object} 删除结果
 */
export async function batchDeleteBinFiles(binFileIds, batchSize = 100) {
  if (!binFileIds || binFileIds.length === 0) {
    return { deleted: 0, errors: [] }
  }
  
  const startTime = performance.now()
  const total = binFileIds.length
  
  console.log(`🗑️ 开始批量删除 ${total} 个bin文件...`)
  console.log(`⚡ 使用分批并行策略，每批 ${batchSize} 个`)
  
  let deleted = 0
  const errors = []
  
  try {
    // 分批并行删除
    for (let i = 0; i < total; i += batchSize) {
      const batch = binFileIds.slice(i, i + batchSize)
      const batchNum = Math.floor(i / batchSize) + 1
      const totalBatches = Math.ceil(total / batchSize)
      
      console.log(`📦 处理第 ${batchNum}/${totalBatches} 批（${batch.length}个文件）...`)
      
      // 并行删除当前批次
      const results = await Promise.allSettled(
        batch.map(binFileId => 
          indexedDBStorage.deleteBinFile(binFileId)
        )
      )
      
      // 统计结果
      results.forEach((result, index) => {
        if (result.status === 'fulfilled') {
          deleted++
        } else {
          errors.push({
            binFileId: batch[index],
            error: result.reason?.message || '未知错误'
          })
        }
      })
      
      // 显示进度
      if (batchNum % 5 === 0 || batchNum === totalBatches) {
        const progress = ((i + batch.length) / total * 100).toFixed(1)
        console.log(`  ✅ 进度: ${deleted}/${total} (${progress}%)`)
      }
    }
    
    const duration = performance.now() - startTime
    const avgTime = duration / total
    
    console.log(`✅ 批量删除完成！`)
    console.log(`   总数: ${total}`)
    console.log(`   成功: ${deleted}`)
    console.log(`   失败: ${errors.length}`)
    console.log(`   耗时: ${duration.toFixed(2)}ms`)
    console.log(`   平均: ${avgTime.toFixed(3)}ms/个`)
    
    return {
      total,
      deleted,
      failed: errors.length,
      errors,
      duration,
      avgTime
    }
  } catch (error) {
    console.error('❌ 批量删除bin文件失败:', error)
    throw error
  }
}

/**
 * 智能删除策略选择器
 * 根据数据量自动选择最优删除策略
 * 
 * @param {Array} binFileIds - bin文件ID数组
 * @returns {Object} 删除结果
 */
export async function smartDeleteBinFiles(binFileIds) {
  const count = binFileIds ? binFileIds.length : 0
  
  if (count === 0) {
    return { strategy: 'none', deleted: 0 }
  }
  
  // 策略1: 单个删除（<= 5个）
  if (count <= 5) {
    console.log(`💡 少量数据（${count}个），使用单个删除策略`)
    const results = await Promise.all(
      binFileIds.map(id => indexedDBStorage.deleteBinFile(id))
    )
    return {
      strategy: 'individual',
      deleted: results.filter(r => r).length
    }
  }
  
  // 策略2: 批量并行删除（6-50个）
  if (count <= 50) {
    console.log(`💡 中等数据（${count}个），使用批量并行删除`)
    return {
      strategy: 'batch',
      ...(await batchDeleteBinFiles(binFileIds, 20))
    }
  }
  
  // 策略3: 大批量并行（51-500个）
  if (count <= 500) {
    console.log(`💡 大量数据（${count}个），使用大批量并行删除`)
    return {
      strategy: 'largeBatch',
      ...(await batchDeleteBinFiles(binFileIds, 100))
    }
  }
  
  // 策略4: 直接清空（>500个，最快）
  console.log(`💡 超大量数据（${count}个），使用直接清空策略（最快）`)
  await indexedDBStorage.clearBinFiles()
  return {
    strategy: 'clear',
    deleted: count,
    note: '使用clear()直接清空，最快速度'
  }
}

/**
 * 清理localStorage分段存储（优化版）
 * 直接删除key而非读取修改保存
 * 
 * @param {Array} binFileIds - bin文件ID数组（可选，用于计算段数）
 */
export function fastCleanLocalStorageBinFiles(binFileIds = null) {
  try {
    // 策略1: 如果知道binFileIds，计算段数
    if (binFileIds && binFileIds.length > 0) {
      const segmentCount = Math.ceil(binFileIds.length / 30)
      console.log(`🧹 清理 ${segmentCount} 个localStorage分段...`)
      
      for (let i = 0; i < segmentCount; i++) {
        localStorage.removeItem(`storedBinFiles_${i}`)
      }
    } 
    // 策略2: 不知道数量，扫描所有可能的key（最多100个段=3000个文件）
    else {
      console.log(`🧹 扫描并清理localStorage分段...`)
      
      for (let i = 0; i < 100; i++) {
        const key = `storedBinFiles_${i}`
        if (localStorage.getItem(key) !== null) {
          localStorage.removeItem(key)
        } else if (i > 10) {
          // 如果连续10个段都不存在，停止扫描
          break
        }
      }
    }
    
    // 清理索引和旧方式
    localStorage.removeItem('storedBinFiles_index')
    localStorage.removeItem('storedBinFiles')
    
    console.log(`✅ localStorage清理完成`)
    return true
  } catch (error) {
    console.error('❌ 清理localStorage失败:', error)
    return false
  }
}

/**
 * 计算最优批次大小
 * 根据数据量动态调整
 */
export function calculateOptimalBatchSize(totalCount) {
  if (totalCount <= 50) return 10
  if (totalCount <= 200) return 50
  if (totalCount <= 1000) return 100
  return 200
}

export default {
  batchDeleteTokens,
  batchDeleteBinFiles,
  smartDeleteBinFiles,
  fastCleanLocalStorageBinFiles,
  calculateOptimalBatchSize
}

