/**
 * IndexedDB存储性能测试脚本
 * 用于测试大规模token存储和读取性能
 * 
 * 在浏览器控制台运行：
 * import('./utils/testIndexedDBStorage.js').then(m => m.runTests())
 */

import indexedDBStorage from './indexedDBStorage.js'

// 生成测试token数据
function generateTestToken(index) {
  return {
    id: `test_token_${index}_${Date.now()}`,
    name: `测试角色${index}`,
    token: `base64_token_data_${index}_${'x'.repeat(100)}`, // 模拟较长的token
    wsUrl: 'wss://game-server.example.com/ws',
    server: `服务器${index % 10 + 1}`,
    level: Math.floor(Math.random() * 100) + 1,
    profession: ['战士', '法师', '刺客', '牧师'][index % 4],
    createdAt: new Date().toISOString(),
    lastUsed: new Date().toISOString(),
    isActive: true,
    importMethod: 'bin',
    binFileId: `bin_${index}`,
    lastRefreshed: new Date().toISOString()
  }
}

// 生成大量测试token
function generateTestTokens(count) {
  console.log(`🔨 生成 ${count} 个测试token...`)
  const tokens = []
  for (let i = 0; i < count; i++) {
    tokens.push(generateTestToken(i))
  }
  console.log(`✅ 已生成 ${count} 个测试token`)
  return tokens
}

// 测试写入性能
async function testWrite(tokenCount) {
  console.log(`\n📝 测试写入 ${tokenCount} 个token...`)
  const tokens = generateTestTokens(tokenCount)
  
  const startTime = performance.now()
  await indexedDBStorage.saveTokens(tokens)
  const endTime = performance.now()
  
  const duration = (endTime - startTime).toFixed(2)
  console.log(`✅ 写入完成，耗时: ${duration}ms`)
  console.log(`   平均每个token: ${(duration / tokenCount).toFixed(3)}ms`)
  
  return { duration, tokenCount, avgPerToken: duration / tokenCount }
}

// 测试读取性能
async function testRead() {
  console.log(`\n📖 测试读取token...`)
  
  const startTime = performance.now()
  const tokens = await indexedDBStorage.getTokens()
  const endTime = performance.now()
  
  const duration = (endTime - startTime).toFixed(2)
  console.log(`✅ 读取完成，读取了 ${tokens.length} 个token，耗时: ${duration}ms`)
  if (tokens.length > 0) {
    console.log(`   平均每个token: ${(duration / tokens.length).toFixed(3)}ms`)
  }
  
  return { duration, tokenCount: tokens.length, avgPerToken: duration / tokens.length }
}

// 测试存储空间使用情况
async function testStorageInfo() {
  console.log(`\n💾 检查存储使用情况...`)
  
  const info = await indexedDBStorage.getStorageEstimate()
  if (info) {
    console.log(`✅ 存储信息:`)
    console.log(`   已使用: ${info.usageMB} MB`)
    console.log(`   总配额: ${info.quotaMB} MB`)
    console.log(`   使用率: ${info.percentUsed}%`)
    console.log(`   剩余空间: ${(info.quotaMB - info.usageMB).toFixed(2)} MB`)
  } else {
    console.log(`⚠️  浏览器不支持存储空间查询`)
  }
  
  return info
}

// 测试token数量统计
async function testCount() {
  console.log(`\n🔢 统计token数量...`)
  
  const count = await indexedDBStorage.getCount()
  console.log(`✅ 当前存储了 ${count} 个token`)
  
  return count
}

// 清理测试数据
async function cleanupTestData() {
  console.log(`\n🧹 清理测试数据...`)
  
  await indexedDBStorage.clearTokens()
  console.log(`✅ 测试数据已清理`)
}

// 运行完整测试套件
export async function runTests(tokenCount = 915) {
  console.log(`\n${'='.repeat(60)}`)
  console.log(`🚀 IndexedDB 大规模Token存储性能测试`)
  console.log(`   测试token数量: ${tokenCount}`)
  console.log(`${'='.repeat(60)}`)
  
  try {
    // 1. 清理旧数据
    await cleanupTestData()
    
    // 2. 测试写入性能
    const writeResult = await testWrite(tokenCount)
    
    // 3. 测试读取性能
    const readResult = await testRead()
    
    // 4. 测试数量统计
    await testCount()
    
    // 5. 检查存储使用情况
    const storageInfo = await testStorageInfo()
    
    // 6. 性能总结
    console.log(`\n${'='.repeat(60)}`)
    console.log(`📊 性能测试总结`)
    console.log(`${'='.repeat(60)}`)
    console.log(`写入性能:`)
    console.log(`  - ${tokenCount} 个token，总耗时: ${writeResult.duration}ms`)
    console.log(`  - 平均每个token: ${writeResult.avgPerToken.toFixed(3)}ms`)
    console.log(`读取性能:`)
    console.log(`  - ${readResult.tokenCount} 个token，总耗时: ${readResult.duration}ms`)
    console.log(`  - 平均每个token: ${readResult.avgPerToken.toFixed(3)}ms`)
    
    if (storageInfo) {
      console.log(`存储使用:`)
      console.log(`  - 使用: ${storageInfo.usageMB} MB / ${storageInfo.quotaMB} MB (${storageInfo.percentUsed}%)`)
      
      // 估算每个token占用空间
      const avgSpacePerToken = (storageInfo.usage / tokenCount / 1024).toFixed(2)
      console.log(`  - 平均每个token: ${avgSpacePerToken} KB`)
    }
    
    console.log(`${'='.repeat(60)}`)
    console.log(`✅ 测试完成！`)
    console.log(`${'='.repeat(60)}\n`)
    
    // 询问是否清理测试数据
    console.log(`💡 提示: 测试数据仍保留在IndexedDB中`)
    console.log(`   运行 cleanupTestData() 可以清理测试数据`)
    
    return {
      write: writeResult,
      read: readResult,
      storage: storageInfo
    }
  } catch (error) {
    console.error(`❌ 测试失败:`, error)
    throw error
  }
}

// 快速测试（100个token）
export async function quickTest() {
  return runTests(100)
}

// 标准测试（915个token，用户场景）
export async function standardTest() {
  return runTests(915)
}

// 压力测试（5000个token）
export async function stressTest() {
  return runTests(5000)
}

// 导出清理函数
export { cleanupTestData }

// 在控制台提供便捷访问
if (typeof window !== 'undefined') {
  window.testIndexedDB = {
    runTests,
    quickTest,
    standardTest,
    stressTest,
    cleanupTestData,
    getStorageInfo: testStorageInfo,
    getCount: testCount
  }
  
  console.log(`
💡 IndexedDB测试工具已加载！

可用命令:
  - window.testIndexedDB.quickTest()      // 快速测试 (100个token)
  - window.testIndexedDB.standardTest()   // 标准测试 (915个token)
  - window.testIndexedDB.stressTest()     // 压力测试 (5000个token)
  - window.testIndexedDB.runTests(N)      // 自定义测试 (N个token)
  - window.testIndexedDB.cleanupTestData() // 清理测试数据
  - window.testIndexedDB.getStorageInfo() // 查看存储信息
  - window.testIndexedDB.getCount()       // 查看token数量
`)
}

