Aether/frontend/src/mocks/handler.ts

/**
 * Mock API Handler
 * 演示模式的 API 请求拦截和模拟响应
 */

import type { AxiosRequestConfig, AxiosResponse } from 'axios'
import { isDemoMode, DEMO_ACCOUNTS } from '@/config/demo'
import {
  MOCK_ADMIN_USER,
  MOCK_NORMAL_USER,
  MOCK_LOGIN_RESPONSE_ADMIN,
  MOCK_LOGIN_RESPONSE_USER,
  MOCK_ADMIN_PROFILE,
  MOCK_USER_PROFILE,
  MOCK_DASHBOARD_STATS,
  MOCK_RECENT_REQUESTS,
  MOCK_PROVIDER_STATUS,
  MOCK_DAILY_STATS,
  MOCK_ALL_USERS,
  MOCK_USER_API_KEYS,
  MOCK_ADMIN_API_KEYS,
  MOCK_PROVIDERS,
  MOCK_GLOBAL_MODELS,
  MOCK_SYSTEM_CONFIGS,
  MOCK_API_FORMATS
} from './data'

// 当前登录用户的 token（用于判断角色）
let currentUserToken: string | null = null

// 模拟网络延迟
function delay(ms: number = 150): Promise<void> {
  return new Promise(resolve => setTimeout(resolve, ms + Math.random() * 200))
}

// 创建模拟响应
function createMockResponse<T>(data: T, status: number = 200): AxiosResponse<T> {
  return {
    data,
    status,
    statusText: status === 200 ? 'OK' : 'Error',
    headers: {},
    config: {} as any
  }
}

// 判断当前是否为管理员
function isCurrentUserAdmin(): boolean {
  return currentUserToken === 'demo-access-token-admin'
}

// 获取当前用户
function getCurrentUser() {
  return isCurrentUserAdmin() ? MOCK_ADMIN_USER : MOCK_NORMAL_USER
}

// 获取当前用户 Profile
function getCurrentProfile() {
  return isCurrentUserAdmin() ? MOCK_ADMIN_PROFILE : MOCK_USER_PROFILE
}

// 检查管理员权限
function requireAdmin() {
  if (!isCurrentUserAdmin()) {
    throw { response: createMockResponse({ detail: '需要管理员权限' }, 403) }
  }
}

// Mock 公告数据
const MOCK_ANNOUNCEMENTS = [
  {
    id: 'ann-001',
    title: '系统升级通知',
    content: '系统将于本周六凌晨 2:00-4:00 进行维护升级，届时服务将暂停访问。',
    type: 'maintenance',
    priority: 100,
    is_pinned: true,
    is_active: true,
    author: { id: 'demo-admin-uuid-0001', username: 'Demo Admin' },
    created_at: '2024-12-01T00:00:00Z',
    updated_at: '2024-12-01T00:00:00Z',
    is_read: false
  },
  {
    id: 'ann-002',
    title: '新模型上线：Claude Sonnet 4',
    content: 'Anthropic 最新模型 Claude Sonnet 4 已上线，支持更长上下文和更强推理能力。',
    type: 'info',
    priority: 50,
    is_pinned: false,
    is_active: true,
    author: { id: 'demo-admin-uuid-0001', username: 'Demo Admin' },
    created_at: '2024-11-28T00:00:00Z',
    updated_at: '2024-11-28T00:00:00Z',
    is_read: true
  }
]

// 生成模拟健康事件
// status: success(绿), failed(红), skipped(黄)
// 无事件的时间段会显示为灰色
function generateHealthEvents(
  count: number,
  successRate: number,
  failRate: number,
  _skipRate: number,
  baseLatency: number,
  latencyVariance: number
) {
  const events = []
  const now = Date.now()
  // 6小时内随机分布事件，留一些空白时段（灰色）
  const timeSpan = 6 * 60 * 60 * 1000
  // skipRate 由 1 - successRate - failRate 隐含计算
  for (let i = 0; i < count; i++) {
    const rand = Math.random()
    let status: string
    let statusCode: number
    if (rand < successRate) {
      status = 'success'
      statusCode = 200
    } else if (rand < successRate + failRate) {
      status = 'failed'
      statusCode = [500, 502, 503, 429, 400][Math.floor(Math.random() * 5)]
    } else {
      status = 'skipped'
      statusCode = 0
    }
    events.push({
      timestamp: new Date(now - Math.random() * timeSpan).toISOString(),
      status,
      status_code: statusCode,
      latency_ms: Math.round(baseLatency + Math.random() * latencyVariance),
      error_type: status === 'failed' ? ['RateLimitError', 'TimeoutError', 'ServerError'][Math.floor(Math.random() * 3)] : undefined
    })
  }
  // 按时间排序
  return events.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime())
}

// Mock 端点健康数据
// 注意：success_rate 使用 0-1 之间的小数，前端会乘以 100 显示为百分比
// 事件的成功/失败/跳过比例必须与 success_rate 保持一致
// 覆盖所有 API 格式：claude, claude_cli, openai, openai_cli, gemini, gemini_cli
const MOCK_ENDPOINT_STATUS = {
  generated_at: new Date().toISOString(),
  formats: [
    {
      api_format: 'CLAUDE',
      api_path: '/v1/messages',
      total_attempts: 2580,
      success_count: 2540,
      failed_count: 30,
      skipped_count: 10,
      success_rate: 0.984,
      provider_count: 2,
      key_count: 4,
      last_event_at: new Date().toISOString(),
      // 98.4% 成功率：successRate=0.984, failRate=0.012, skipRate=0.004
      events: generateHealthEvents(80, 0.984, 0.012, 0.004, 900, 500)
    },
    {
      api_format: 'CLAUDE_CLI',
      api_path: '/v1/messages',
      total_attempts: 1890,
      success_count: 1780,
      failed_count: 85,
      skipped_count: 25,
      success_rate: 0.942,
      provider_count: 5,
      key_count: 9,
      last_event_at: new Date().toISOString(),
      // 94.2% 成功率：successRate=0.942, failRate=0.045, skipRate=0.013
      events: generateHealthEvents(120, 0.942, 0.045, 0.013, 1200, 800)
    },
    {
      api_format: 'GEMINI',
      api_path: '/v1beta/models',
      total_attempts: 890,
      success_count: 890,
      failed_count: 0,
      skipped_count: 0,
      success_rate: 1.0,
      provider_count: 3,
      key_count: 3,
      last_event_at: new Date().toISOString(),
      // 100% 成功率：全部成功
      events: generateHealthEvents(45, 1.0, 0, 0, 400, 200)
    },
    {
      api_format: 'GEMINI_CLI',
      api_path: '/v1beta/models',
      total_attempts: 456,
      success_count: 450,
      failed_count: 4,
      skipped_count: 2,
      success_rate: 0.987,
      provider_count: 3,
      key_count: 3,
      last_event_at: new Date().toISOString(),
      // 98.7% 成功率：successRate=0.987, failRate=0.009, skipRate=0.004
      events: generateHealthEvents(25, 0.987, 0.009, 0.004, 500, 300)
    },
    {
      api_format: 'OPENAI',
      api_path: '/v1/chat/completions',
      total_attempts: 1560,
      success_count: 1520,
      failed_count: 35,
      skipped_count: 5,
      success_rate: 0.974,
      provider_count: 1,
      key_count: 2,
      last_event_at: new Date().toISOString(),
      // 97.4% 成功率：successRate=0.974, failRate=0.022, skipRate=0.004
      events: generateHealthEvents(60, 0.974, 0.022, 0.004, 700, 400)
    },
    {
      api_format: 'OPENAI_CLI',
      api_path: '/responses',
      total_attempts: 2340,
      success_count: 2200,
      failed_count: 100,
      skipped_count: 40,
      success_rate: 0.940,
      provider_count: 4,
      key_count: 5,
      last_event_at: new Date().toISOString(),
      // 94.0% 成功率：successRate=0.940, failRate=0.043, skipRate=0.017
      events: generateHealthEvents(100, 0.940, 0.043, 0.017, 800, 600)
    }
  ]
}

// 生成活跃热力图数据（最近365天）
function generateActivityHeatmap() {
  const days: Array<{
    date: string
    requests: number
    total_tokens: number
    total_cost: number
    actual_total_cost?: number
  }> = []

  const now = new Date()
  const startDate = new Date(now)
  startDate.setDate(startDate.getDate() - 364) // 365天数据（一年）

  let maxRequests = 0

  // 生成每天的数据
  for (let i = 0; i < 365; i++) {
    const date = new Date(startDate)
    date.setDate(startDate.getDate() + i)
    const dateStr = date.toISOString().split('T')[0]

    // 工作日请求量更高
    const dayOfWeek = date.getDay()
    const isWeekend = dayOfWeek === 0 || dayOfWeek === 6

    // 基础请求量 + 随机波动 + 周末减少
    // 加入一些趋势：越近的日期请求量可能越高
    const trendFactor = 0.7 + (i / 365) * 0.5 // 从0.7到1.2的增长趋势
    const baseRequests = isWeekend ? 40 : 120
    const variance = Math.floor(Math.random() * 80)
    // 有些天可能没有请求（约5%的天数）
    const noActivity = Math.random() < 0.05
    const requests = noActivity ? 0 : Math.round((baseRequests + variance) * trendFactor)

    if (requests > maxRequests) maxRequests = requests

    // 根据请求量计算 tokens 和 cost
    const avgTokensPerRequest = 3000 + Math.floor(Math.random() * 2000)
    const totalTokens = requests * avgTokensPerRequest
    const avgCostPerRequest = 0.02 + Math.random() * 0.03
    const totalCost = Number((requests * avgCostPerRequest).toFixed(2))
    const actualTotalCost = Number((totalCost * 0.8).toFixed(2)) // 实际成本约为 80%

    days.push({
      date: dateStr,
      requests,
      total_tokens: totalTokens,
      total_cost: totalCost,
      actual_total_cost: actualTotalCost
    })
  }

  return {
    start_date: days[0].date,
    end_date: days[days.length - 1].date,
    total_days: days.length,
    max_requests: maxRequests,
    days
  }
}

// 缓存热力图数据（避免每次请求都重新生成）
let cachedHeatmap: ReturnType<typeof generateActivityHeatmap> | null = null
function getActivityHeatmap() {
  if (!cachedHeatmap) {
    cachedHeatmap = generateActivityHeatmap()
  }
  return cachedHeatmap
}

// 生成更真实的使用记录
function generateMockUsageRecords(count: number = 100) {
  const records = []
  const now = Date.now()

  const models = [
    { name: 'claude-sonnet-4-5-20250929', provider: 'anthropic', inputPrice: 3, outputPrice: 15 },
    { name: 'claude-haiku-4-5-20251001', provider: 'anthropic', inputPrice: 1, outputPrice: 5 },
    { name: 'claude-opus-4-5-20251101', provider: 'anthropic', inputPrice: 15, outputPrice: 75 },
    { name: 'gpt-5.1', provider: 'openai', inputPrice: 2.5, outputPrice: 10 },
    { name: 'gpt-5.1-codex', provider: 'openai', inputPrice: 2.5, outputPrice: 10 },
    { name: 'gemini-3-pro-preview', provider: 'google', inputPrice: 2, outputPrice: 12 }
  ]

  const users = [
    { id: 'demo-admin-uuid-0001', username: 'Demo Admin', email: 'admin@demo.aether.ai' },
    { id: 'demo-user-uuid-0002', username: 'Demo User', email: 'user@demo.aether.ai' },
    { id: 'demo-user-uuid-0003', username: 'Alice Chen', email: 'alice@demo.aether.ai' },
    { id: 'demo-user-uuid-0004', username: 'Bob Zhang', email: 'bob@demo.aether.ai' }
  ]

  const apiFormats = ['CLAUDE', 'CLAUDE_CLI', 'OPENAI', 'OPENAI_CLI', 'GEMINI', 'GEMINI_CLI']
  const statusOptions: Array<'completed' | 'failed' | 'streaming'> = ['completed', 'completed', 'completed', 'completed', 'failed', 'streaming']

  for (let i = 0; i < count; i++) {
    const model = models[Math.floor(Math.random() * models.length)]
    const user = users[Math.floor(Math.random() * users.length)]
    const status = statusOptions[Math.floor(Math.random() * statusOptions.length)]

    // 根据模型类型选择 API 格式
    let apiFormat = apiFormats[0]
    if (model.provider === 'anthropic') {
      apiFormat = Math.random() > 0.3 ? 'CLAUDE_CLI' : 'CLAUDE'
    } else if (model.provider === 'openai') {
      apiFormat = Math.random() > 0.3 ? 'OPENAI_CLI' : 'OPENAI'
    } else {
      apiFormat = Math.random() > 0.3 ? 'GEMINI_CLI' : 'GEMINI'
    }

    const inputTokens = 500 + Math.floor(Math.random() * 10000)
    const outputTokens = 200 + Math.floor(Math.random() * 4000)
    const cacheCreation = Math.random() > 0.7 ? Math.floor(Math.random() * 2000) : 0
    const cacheRead = Math.random() > 0.5 ? Math.floor(Math.random() * 5000) : 0
    const totalTokens = inputTokens + outputTokens

    // 计算成本（每百万 token）
    const inputCost = (inputTokens / 1000000) * model.inputPrice
    const outputCost = (outputTokens / 1000000) * model.outputPrice
    const cost = Number((inputCost + outputCost).toFixed(6))
    const actualCost = Number((cost * (0.7 + Math.random() * 0.3)).toFixed(6))

    // 时间分布：最近的记录更密集
    const timeOffset = Math.pow(i / count, 1.5) * 7 * 24 * 60 * 60 * 1000 // 7天内
    const createdAt = new Date(now - timeOffset)

    // 响应时间：根据模型和 token 数量
    const baseResponseTime = model.name.includes('opus') ? 2000 : model.name.includes('haiku') ? 500 : 1000
    const responseTime = status === 'failed' ? null : baseResponseTime + Math.floor(Math.random() * outputTokens * 0.5)

    records.push({
      id: `usage-${String(i + 1).padStart(4, '0')}`,
      user_id: user.id,
      username: user.username,
      user_email: user.email,
      provider: model.provider,
      api_key_name: `${model.provider}-key-${Math.ceil(Math.random() * 3)}`,
      rate_multiplier: 1.0,
      model: model.name,
      target_model: model.name,
      api_format: apiFormat,
      input_tokens: inputTokens,
      output_tokens: outputTokens,
      cache_creation_input_tokens: cacheCreation,
      cache_read_input_tokens: cacheRead,
      total_tokens: totalTokens,
      cost,
      actual_cost: actualCost,
      response_time_ms: responseTime,
      is_stream: apiFormat.includes('CLI'),
      status_code: status === 'failed' ? [500, 502, 429, 400][Math.floor(Math.random() * 4)] : 200,
      error_message: status === 'failed' ? ['Rate limit exceeded', 'Internal server error', 'Model overloaded'][Math.floor(Math.random() * 3)] : undefined,
      status,
      created_at: createdAt.toISOString(),
      has_fallback: Math.random() > 0.9,
      request_metadata: model.provider === 'google' ? { model_version: 'gemini-3-pro-preview-2025-01' } : undefined
    })
  }

  return records
}

// 缓存使用记录
let cachedUsageRecords: ReturnType<typeof generateMockUsageRecords> | null = null
function getUsageRecords() {
  if (!cachedUsageRecords) {
    cachedUsageRecords = generateMockUsageRecords(100)
  }
  return cachedUsageRecords
}

// Mock 别名数据
const MOCK_ALIASES = [
  { id: 'alias-001', source_model: 'claude-4-sonnet', target_global_model_id: 'gm-001', target_global_model_name: 'claude-sonnet-4-20250514', target_global_model_display_name: 'Claude Sonnet 4', provider_id: null, provider_name: null, scope: 'global', mapping_type: 'alias', is_active: true, created_at: '2024-01-01T00:00:00Z', updated_at: '2024-01-01T00:00:00Z' },
  { id: 'alias-002', source_model: 'claude-4-opus', target_global_model_id: 'gm-002', target_global_model_name: 'claude-opus-4-20250514', target_global_model_display_name: 'Claude Opus 4', provider_id: null, provider_name: null, scope: 'global', mapping_type: 'alias', is_active: true, created_at: '2024-01-01T00:00:00Z', updated_at: '2024-01-01T00:00:00Z' },
  { id: 'alias-003', source_model: 'gpt4o', target_global_model_id: 'gm-004', target_global_model_name: 'gpt-4o', target_global_model_display_name: 'GPT-4o', provider_id: null, provider_name: null, scope: 'global', mapping_type: 'alias', is_active: true, created_at: '2024-01-01T00:00:00Z', updated_at: '2024-01-01T00:00:00Z' },
  { id: 'alias-004', source_model: 'gemini-flash', target_global_model_id: 'gm-005', target_global_model_name: 'gemini-2.0-flash', target_global_model_display_name: 'Gemini 2.0 Flash', provider_id: null, provider_name: null, scope: 'global', mapping_type: 'alias', is_active: true, created_at: '2024-01-01T00:00:00Z', updated_at: '2024-01-01T00:00:00Z' }
]

// Mock Endpoint Keys
const MOCK_ENDPOINT_KEYS = [
  { id: 'ekey-001', endpoint_id: 'ep-001', api_key_masked: 'sk-ant...abc1', name: 'Primary Key', rate_multiplier: 1.0, internal_priority: 1, health_score: 98, consecutive_failures: 0, request_count: 5000, success_count: 4950, error_count: 50, success_rate: 99, avg_response_time_ms: 1200, is_active: true, created_at: '2024-01-01T00:00:00Z', updated_at: new Date().toISOString() },
  { id: 'ekey-002', endpoint_id: 'ep-001', api_key_masked: 'sk-ant...def2', name: 'Backup Key', rate_multiplier: 1.0, internal_priority: 2, health_score: 95, consecutive_failures: 1, request_count: 2000, success_count: 1950, error_count: 50, success_rate: 97.5, avg_response_time_ms: 1350, is_active: true, created_at: '2024-02-01T00:00:00Z', updated_at: new Date().toISOString() },
  { id: 'ekey-003', endpoint_id: 'ep-002', api_key_masked: 'sk-oai...ghi3', name: 'OpenAI Main', rate_multiplier: 1.0, internal_priority: 1, health_score: 97, consecutive_failures: 0, request_count: 3500, success_count: 3450, error_count: 50, success_rate: 98.6, avg_response_time_ms: 900, is_active: true, created_at: '2024-01-15T00:00:00Z', updated_at: new Date().toISOString() }
]

// Mock Endpoints
const MOCK_ENDPOINTS = [
  { id: 'ep-001', provider_id: 'provider-001', provider_name: 'anthropic', api_format: 'claude', base_url: 'https://api.anthropic.com', auth_type: 'bearer', timeout: 120, max_retries: 3, priority: 100, weight: 100, health_score: 98, consecutive_failures: 0, is_active: true, total_keys: 2, active_keys: 2, created_at: '2024-01-01T00:00:00Z', updated_at: new Date().toISOString() },
  { id: 'ep-002', provider_id: 'provider-002', provider_name: 'openai', api_format: 'openai', base_url: 'https://api.openai.com', auth_type: 'bearer', timeout: 60, max_retries: 3, priority: 90, weight: 100, health_score: 97, consecutive_failures: 0, is_active: true, total_keys: 1, active_keys: 1, created_at: '2024-01-01T00:00:00Z', updated_at: new Date().toISOString() },
  { id: 'ep-003', provider_id: 'provider-003', provider_name: 'google', api_format: 'gemini', base_url: 'https://generativelanguage.googleapis.com', auth_type: 'api_key', timeout: 60, max_retries: 3, priority: 80, weight: 100, health_score: 96, consecutive_failures: 0, is_active: true, total_keys: 1, active_keys: 1, created_at: '2024-01-15T00:00:00Z', updated_at: new Date().toISOString() }
]

// Mock 能力定义
const MOCK_CAPABILITIES = [
  { name: 'cache_1h', display_name: '1小时缓存', description: '支持1小时prompt缓存', match_mode: 'exclusive', short_name: '1h' },
  { name: 'context_1m', display_name: '1M上下文', description: '支持1M上下文窗口', match_mode: 'compatible', short_name: '1M' }
]

/**
 * Mock API 路由处理器
 */
const mockHandlers: Record<string, (config: AxiosRequestConfig) => Promise<AxiosResponse<any>>> = {
  // ========== 认证相关 ==========
  'POST /api/auth/login': async (config) => {
    await delay()
    const body = JSON.parse(config.data || '{}')
    const { email, password } = body

    if (email === DEMO_ACCOUNTS.admin.email && password === DEMO_ACCOUNTS.admin.password) {
      currentUserToken = 'demo-access-token-admin'
      return createMockResponse(MOCK_LOGIN_RESPONSE_ADMIN)
    }

    if (email === DEMO_ACCOUNTS.user.email && password === DEMO_ACCOUNTS.user.password) {
      currentUserToken = 'demo-access-token-user'
      return createMockResponse(MOCK_LOGIN_RESPONSE_USER)
    }

    throw { response: createMockResponse({ detail: '邮箱或密码错误' }, 401) }
  },

  'POST /api/auth/logout': async () => {
    await delay(100)
    currentUserToken = null
    return createMockResponse({ message: '已登出' })
  },

  'POST /api/auth/refresh': async () => {
    await delay(100)
    if (isCurrentUserAdmin()) {
      return createMockResponse(MOCK_LOGIN_RESPONSE_ADMIN)
    }
    return createMockResponse(MOCK_LOGIN_RESPONSE_USER)
  },

  // ========== 用户信息 ==========
  'GET /api/users/me': async () => {
    await delay()
    return createMockResponse(getCurrentUser())
  },

  'PUT /api/users/me': async () => {
    await delay()
    return createMockResponse({ message: '更新成功（演示模式）' })
  },

  'PATCH /api/users/me/password': async () => {
    await delay()
    return createMockResponse({ message: '密码修改成功（演示模式）' })
  },

  'GET /api/users/me/api-keys': async () => {
    await delay()
    return createMockResponse(MOCK_USER_API_KEYS)
  },

  'POST /api/users/me/api-keys': async (config) => {
    await delay()
    const body = JSON.parse(config.data || '{}')
    const newKey = {
      id: `key-demo-${Date.now()}`,
      key: `sk-aether-demo-${Math.random().toString(36).substring(2, 15)}`,
      key_display: 'sk-ae...demo',
      name: body.name || '新密钥（演示）',
      created_at: new Date().toISOString(),
      is_active: true,
      is_standalone: false,
      total_requests: 0,
      total_cost_usd: 0
    }
    return createMockResponse(newKey)
  },

  'GET /api/users/me/usage': async () => {
    await delay()
    const heatmap = getActivityHeatmap()
    const records = getUsageRecords()
    // 只返回当前用户的数据
    const userRecords = records.filter(r => r.user_id === getCurrentUser().id)
    const totalRequests = userRecords.length
    const totalTokens = userRecords.reduce((sum, r) => sum + r.total_tokens, 0)
    const totalInputTokens = userRecords.reduce((sum, r) => sum + r.input_tokens, 0)
    const totalOutputTokens = userRecords.reduce((sum, r) => sum + r.output_tokens, 0)
    const totalCost = userRecords.reduce((sum, r) => sum + r.cost, 0)
    const totalActualCost = userRecords.reduce((sum, r) => sum + (r.actual_cost || 0), 0)
    const avgResponseTime = userRecords.filter(r => r.response_time_ms).reduce((sum, r) => sum + (r.response_time_ms || 0), 0) / userRecords.filter(r => r.response_time_ms).length / 1000

    // 按模型聚合
    const modelStats = new Map<string, { requests: number; input_tokens: number; output_tokens: number; total_tokens: number; total_cost_usd: number; actual_total_cost_usd: number }>()
    for (const r of userRecords) {
      const existing = modelStats.get(r.model) || { requests: 0, input_tokens: 0, output_tokens: 0, total_tokens: 0, total_cost_usd: 0, actual_total_cost_usd: 0 }
      existing.requests++
      existing.input_tokens += r.input_tokens
      existing.output_tokens += r.output_tokens
      existing.total_tokens += r.total_tokens
      existing.total_cost_usd += r.cost
      existing.actual_total_cost_usd += r.actual_cost || 0
      modelStats.set(r.model, existing)
    }

    return createMockResponse({
      total_requests: totalRequests * 20,
      total_input_tokens: totalInputTokens * 20,
      total_output_tokens: totalOutputTokens * 20,
      total_tokens: totalTokens * 20,
      total_cost: Number((totalCost * 20).toFixed(2)),
      total_actual_cost: Number((totalActualCost * 20).toFixed(2)),
      avg_response_time: Number(avgResponseTime.toFixed(2)) || 1.23,
      quota_usd: 100,
      used_usd: Number((totalCost * 20).toFixed(2)),
      activity_heatmap: heatmap,
      summary_by_model: Array.from(modelStats.entries()).map(([model, stats]) => ({
        model,
        requests: stats.requests * 20,
        input_tokens: stats.input_tokens * 20,
        output_tokens: stats.output_tokens * 20,
        total_tokens: stats.total_tokens * 20,
        total_cost_usd: Number((stats.total_cost_usd * 20).toFixed(2)),
        actual_total_cost_usd: Number((stats.actual_total_cost_usd * 20).toFixed(2))
      })),
      records: userRecords.slice(0, 10).map(r => ({
        id: r.id,
        provider: r.provider,
        model: r.model,
        input_tokens: r.input_tokens,
        output_tokens: r.output_tokens,
        total_tokens: r.total_tokens,
        cost: r.cost,
        response_time_ms: r.response_time_ms,
        is_stream: r.is_stream,
        created_at: r.created_at,
        status_code: r.status_code,
        input_price_per_1m: 3,
        output_price_per_1m: 15
      }))
    })
  },

  'GET /api/users/me/providers': async () => {
    await delay()
    return createMockResponse(MOCK_PROVIDERS.map(p => ({
      id: p.id,
      name: p.name,
      display_name: p.display_name,
      is_active: p.is_active
    })))
  },

  'GET /api/users/me/endpoint-status': async () => {
    await delay()
    return createMockResponse(MOCK_ENDPOINTS.map(e => ({
      api_format: e.api_format,
      health_score: e.health_score,
      is_active: e.is_active
    })))
  },

  'GET /api/users/me/preferences': async () => {
    await delay()
    return createMockResponse(getCurrentProfile().preferences || { theme: 'auto', language: 'zh-CN' })
  },

  'PUT /api/users/me/preferences': async () => {
    await delay()
    return createMockResponse({ message: '偏好设置已更新（演示模式）' })
  },

  'GET /api/users/me/model-capabilities': async () => {
    await delay()
    return createMockResponse({ model_capability_settings: {} })
  },

  'PUT /api/users/me/model-capabilities': async () => {
    await delay()
    return createMockResponse({ message: '已更新', model_capability_settings: {} })
  },

  // ========== Dashboard ==========
  'GET /api/dashboard/stats': async () => {
    await delay()
    return createMockResponse(MOCK_DASHBOARD_STATS)
  },

  'GET /api/dashboard/recent-requests': async () => {
    await delay()
    return createMockResponse({ requests: MOCK_RECENT_REQUESTS })
  },

  'GET /api/dashboard/provider-status': async () => {
    await delay()
    return createMockResponse({ providers: MOCK_PROVIDER_STATUS })
  },

  'GET /api/dashboard/daily-stats': async () => {
    await delay()
    return createMockResponse(MOCK_DAILY_STATS)
  },

  // ========== 公告 ==========
  'GET /api/announcements': async () => {
    await delay()
    return createMockResponse({ items: MOCK_ANNOUNCEMENTS, total: MOCK_ANNOUNCEMENTS.length, unread_count: 1 })
  },

  'GET /api/announcements/active': async () => {
    await delay()
    return createMockResponse({ items: MOCK_ANNOUNCEMENTS.filter(a => a.is_active), total: MOCK_ANNOUNCEMENTS.filter(a => a.is_active).length, unread_count: 1 })
  },

  'GET /api/announcements/users/me/unread-count': async () => {
    await delay()
    return createMockResponse({ unread_count: 1 })
  },

  'PATCH /api/announcements': async () => {
    await delay()
    return createMockResponse({ message: '已标记为已读' })
  },

  'POST /api/announcements': async (config) => {
    await delay()
    requireAdmin()
    const body = JSON.parse(config.data || '{}')
    return createMockResponse({ id: `ann-demo-${Date.now()}`, title: body.title, message: '公告已创建（演示模式）' })
  },

  'POST /api/announcements/read-all': async () => {
    await delay()
    return createMockResponse({ message: '已全部标记为已读' })
  },

  // ========== Admin: 用户管理 ==========
  'GET /api/admin/users': async () => {
    await delay()
    requireAdmin()
    return createMockResponse(MOCK_ALL_USERS)
  },

  'POST /api/admin/users': async (config) => {
    await delay()
    requireAdmin()
    const body = JSON.parse(config.data || '{}')
    const newUser = {
      id: `user-demo-${Date.now()}`,
      username: body.username,
      email: body.email,
      role: body.role || 'user',
      is_active: true,
      quota_usd: body.quota_usd || null,
      used_usd: 0,
      total_usd: 0,
      allowed_providers: null,
      allowed_endpoints: null,
      allowed_models: null,
      created_at: new Date().toISOString()
    }
    return createMockResponse(newUser)
  },

  // ========== Admin: API Keys ==========
  'GET /api/admin/api-keys': async () => {
    await delay()
    requireAdmin()
    return createMockResponse(MOCK_ADMIN_API_KEYS)
  },

  'POST /api/admin/api-keys': async (config) => {
    await delay()
    requireAdmin()
    const body = JSON.parse(config.data || '{}')
    const newKey = {
      id: `standalone-demo-${Date.now()}`,
      key: `sk-sa-demo-${Math.random().toString(36).substring(2, 15)}`,
      user_id: 'demo-user-uuid-0002',
      name: body.name || '新独立 Key（演示）',
      key_display: 'sk-sa...demo',
      is_active: true,
      is_standalone: true,
      balance_used_usd: 0,
      current_balance_usd: body.initial_balance_usd || 100,
      total_requests: 0,
      created_at: new Date().toISOString()
    }
    return createMockResponse(newKey)
  },

  // ========== Admin: Providers ==========
  'GET /api/admin/providers/summary': async () => {
    await delay()
    requireAdmin()
    return createMockResponse(MOCK_PROVIDERS)
  },

  'GET /api/admin/providers': async () => {
    await delay()
    requireAdmin()
    return createMockResponse(MOCK_PROVIDERS)
  },

  'POST /api/admin/providers': async (config) => {
    await delay()
    requireAdmin()
    const body = JSON.parse(config.data || '{}')
    return createMockResponse({ ...body, id: `provider-demo-${Date.now()}`, created_at: new Date().toISOString() })
  },

  // ========== Admin: Endpoints ==========
  'GET /api/admin/endpoints/providers': async () => {
    await delay()
    requireAdmin()
    return createMockResponse(MOCK_ENDPOINTS)
  },

  'GET /api/admin/endpoints': async () => {
    await delay()
    requireAdmin()
    return createMockResponse(MOCK_ENDPOINTS)
  },

  'GET /api/admin/endpoints/health/summary': async () => {
    await delay()
    requireAdmin()
    return createMockResponse({
      endpoints: { total: 6, active: 5, unhealthy: 1 },
      keys: { total: 15, active: 12, unhealthy: 3 }
    })
  },

  'GET /api/admin/endpoints/health/api-formats': async () => {
    await delay()
    requireAdmin()
    return createMockResponse(MOCK_ENDPOINT_STATUS)
  },

  'GET /api/admin/endpoints/keys': async () => {
    await delay()
    requireAdmin()
    return createMockResponse(MOCK_ENDPOINT_KEYS)
  },

  // ========== Admin: Global Models ==========
  'GET /api/admin/models/global': async () => {
    await delay()
    requireAdmin()
    return createMockResponse({ models: MOCK_GLOBAL_MODELS, total: MOCK_GLOBAL_MODELS.length })
  },

  'POST /api/admin/models/global': async (config) => {
    await delay()
    requireAdmin()
    const body = JSON.parse(config.data || '{}')
    return createMockResponse({ ...body, id: `gm-demo-${Date.now()}`, created_at: new Date().toISOString() })
  },

  // ========== Admin: Model Mappings / Aliases ==========
  'GET /api/admin/models/mappings': async () => {
    await delay()
    requireAdmin()
    return createMockResponse(MOCK_ALIASES)
  },

  'POST /api/admin/models/mappings': async (config) => {
    await delay()
    requireAdmin()
    const body = JSON.parse(config.data || '{}')
    return createMockResponse({ ...body, id: `alias-demo-${Date.now()}`, created_at: new Date().toISOString(), updated_at: new Date().toISOString() })
  },

  // ========== Admin: Usage ==========
  'GET /api/admin/usage/stats': async () => {
    await delay()
    requireAdmin()
    const heatmap = getActivityHeatmap()
    const records = getUsageRecords()
    const totalRequests = records.length
    const totalTokens = records.reduce((sum, r) => sum + r.total_tokens, 0)
    const totalCost = records.reduce((sum, r) => sum + r.cost, 0)
    const totalActualCost = records.reduce((sum, r) => sum + (r.actual_cost || 0), 0)
    const avgResponseTime = records.filter(r => r.response_time_ms).reduce((sum, r) => sum + (r.response_time_ms || 0), 0) / records.filter(r => r.response_time_ms).length / 1000

    // 今日数据
    const today = new Date().toISOString().split('T')[0]
    const todayRecords = records.filter(r => r.created_at.startsWith(today))

    return createMockResponse({
      total_requests: totalRequests * 100, // 放大显示
      total_tokens: totalTokens * 100,
      total_cost: Number((totalCost * 100).toFixed(2)),
      total_actual_cost: Number((totalActualCost * 100).toFixed(2)),
      avg_response_time: Number(avgResponseTime.toFixed(2)),
      today: {
        requests: todayRecords.length * 10,
        tokens: todayRecords.reduce((sum, r) => sum + r.total_tokens, 0) * 10,
        cost: Number((todayRecords.reduce((sum, r) => sum + r.cost, 0) * 10).toFixed(2))
      },
      activity_heatmap: heatmap
    })
  },

  'GET /api/admin/usage/records': async (config) => {
    await delay()
    requireAdmin()
    const records = getUsageRecords()
    const params = config.params || {}
    const limit = parseInt(params.limit) || 20
    const offset = parseInt(params.offset) || 0
    return createMockResponse({
      records: records.slice(offset, offset + limit),
      total: records.length,
      limit,
      offset
    })
  },

  'GET /api/admin/usage/aggregation/stats': async (config) => {
    await delay()
    requireAdmin()
    const params = config.params || {}
    const groupBy = params.group_by || 'model'
    const records = getUsageRecords()

    if (groupBy === 'model') {
      // 按模型聚合
      const modelStats = new Map<string, { request_count: number; total_tokens: number; total_cost: number }>()
      for (const r of records) {
        const existing = modelStats.get(r.model) || { request_count: 0, total_tokens: 0, total_cost: 0 }
        existing.request_count++
        existing.total_tokens += r.total_tokens
        existing.total_cost += r.cost
        modelStats.set(r.model, existing)
      }
      return createMockResponse(
        Array.from(modelStats.entries()).map(([model, stats]) => ({
          model,
          request_count: stats.request_count * 50,
          total_tokens: stats.total_tokens * 50,
          total_cost: Number((stats.total_cost * 50).toFixed(2))
        }))
      )
    }

    if (groupBy === 'provider') {
      const providerStats = new Map<string, { request_count: number; total_tokens: number; total_cost: number; actual_cost: number; response_times: number[]; errors: number }>()
      for (const r of records) {
        const existing = providerStats.get(r.provider) || { request_count: 0, total_tokens: 0, total_cost: 0, actual_cost: 0, response_times: [], errors: 0 }
        existing.request_count++
        existing.total_tokens += r.total_tokens
        existing.total_cost += r.cost
        existing.actual_cost += r.actual_cost || 0
        if (r.response_time_ms) existing.response_times.push(r.response_time_ms)
        if (r.status === 'failed') existing.errors++
        providerStats.set(r.provider, existing)
      }
      return createMockResponse(
        Array.from(providerStats.entries()).map(([provider, stats]) => ({
          provider_id: `provider-${provider}`,
          provider,
          request_count: stats.request_count * 50,
          total_tokens: stats.total_tokens * 50,
          total_cost: Number((stats.total_cost * 50).toFixed(2)),
          actual_cost: Number((stats.actual_cost * 50).toFixed(2)),
          avg_response_time_ms: Math.round(stats.response_times.reduce((a, b) => a + b, 0) / stats.response_times.length || 0),
          success_rate: (stats.request_count - stats.errors) / stats.request_count,
          error_count: stats.errors * 50
        }))
      )
    }

    if (groupBy === 'user') {
      const userStats = new Map<string, { user_id: string; username: string; email: string; request_count: number; total_tokens: number; total_cost: number }>()
      for (const r of records) {
        const existing = userStats.get(r.user_id) || { user_id: r.user_id, username: r.username, email: r.user_email || '', request_count: 0, total_tokens: 0, total_cost: 0 }
        existing.request_count++
        existing.total_tokens += r.total_tokens
        existing.total_cost += r.cost
        userStats.set(r.user_id, existing)
      }
      return createMockResponse(
        Array.from(userStats.values()).map(stats => ({
          user_id: stats.user_id,
          email: stats.email,
          username: stats.username,
          request_count: stats.request_count * 50,
          total_tokens: stats.total_tokens * 50,
          total_cost: Number((stats.total_cost * 50).toFixed(2))
        }))
      )
    }

    if (groupBy === 'api_format') {
      const formatStats = new Map<string, { request_count: number; total_tokens: number; total_cost: number; actual_cost: number; response_times: number[] }>()
      for (const r of records) {
        const existing = formatStats.get(r.api_format) || { request_count: 0, total_tokens: 0, total_cost: 0, actual_cost: 0, response_times: [] }
        existing.request_count++
        existing.total_tokens += r.total_tokens
        existing.total_cost += r.cost
        existing.actual_cost += r.actual_cost || 0
        if (r.response_time_ms) existing.response_times.push(r.response_time_ms)
        formatStats.set(r.api_format, existing)
      }
      return createMockResponse(
        Array.from(formatStats.entries()).map(([api_format, stats]) => ({
          api_format,
          request_count: stats.request_count * 50,
          total_tokens: stats.total_tokens * 50,
          total_cost: Number((stats.total_cost * 50).toFixed(2)),
          actual_cost: Number((stats.actual_cost * 50).toFixed(2)),
          avg_response_time_ms: Math.round(stats.response_times.reduce((a, b) => a + b, 0) / stats.response_times.length || 0)
        }))
      )
    }

    return createMockResponse([])
  },

  'GET /api/admin/usage/active': async () => {
    await delay()
    requireAdmin()
    return createMockResponse({ requests: [] })
  },

  // ========== Admin: System ==========
  'GET /api/admin/system/configs': async () => {
    await delay()
    requireAdmin()
    return createMockResponse(MOCK_SYSTEM_CONFIGS)
  },

  'GET /api/admin/system/api-formats': async () => {
    await delay()
    return createMockResponse(MOCK_API_FORMATS)
  },

  'GET /api/admin/system/stats': async () => {
    await delay()
    requireAdmin()
    return createMockResponse({
      total_requests_today: 1234,
      total_requests_month: 45678,
      total_users: 156,
      active_users_today: 28,
      total_cost_today: 45.67,
      total_cost_month: 1234.56,
      uptime_hours: 720,
      cache_hit_rate: 0.35
    })
  },

  // ========== 能力接口 ==========
  'GET /api/capabilities': async () => {
    await delay()
    return createMockResponse({ capabilities: MOCK_CAPABILITIES })
  },

  'GET /api/capabilities/user-configurable': async () => {
    await delay()
    return createMockResponse({ capabilities: MOCK_CAPABILITIES.filter(c => c.match_mode === 'exclusive') })
  },

  // ========== 公开接口 ==========
  'GET /api/public/global-models': async () => {
    await delay()
    return createMockResponse({
      models: MOCK_GLOBAL_MODELS.map(m => ({
        id: m.id,
        name: m.name,
        display_name: m.display_name,
        is_active: m.is_active,
        default_tiered_pricing: m.default_tiered_pricing,
        default_price_per_request: m.default_price_per_request,
        supported_capabilities: m.supported_capabilities,
        config: m.config
      })),
      total: MOCK_GLOBAL_MODELS.length
    })
  },

  'GET /api/public/models': async () => {
    await delay()
    return createMockResponse({
      models: MOCK_GLOBAL_MODELS.map(m => ({
        name: m.name,
        display_name: m.display_name,
        description: m.description
      }))
    })
  },

  'GET /api/public/health': async () => {
    await delay(50)
    return createMockResponse({ status: 'healthy', demo_mode: true })
  },

  'GET /api/public/health/api-formats': async () => {
    await delay()
    return createMockResponse({
      generated_at: new Date().toISOString(),
      formats: MOCK_ENDPOINT_STATUS.formats.map(f => ({
        api_format: f.api_format,
        api_path: f.api_path,
        total_attempts: f.total_attempts,
        success_count: f.success_count,
        failed_count: f.failed_count,
        skipped_count: f.skipped_count,
        success_rate: f.success_rate,
        last_event_at: f.last_event_at,
        events: f.events.slice(0, 10)
      }))
    })
  }
}

// 动态路由匹配器 - 支持 :id 形式的参数
interface RouteMatch {
  handler: (config: AxiosRequestConfig, params: Record<string, string>) => Promise<AxiosResponse<any>>
  params: Record<string, string>
}

type DynamicHandler = (config: AxiosRequestConfig, params: Record<string, string>) => Promise<AxiosResponse<any>>

// 动态路由注册表
const dynamicRoutes: Array<{
  method: string
  pattern: RegExp
  paramNames: string[]
  handler: DynamicHandler
}> = []

/**
 * 注册动态路由
 */
function registerDynamicRoute(
  method: string,
  path: string,
  handler: DynamicHandler
) {
  // 将 :param 形式转换为正则
  const paramNames: string[] = []
  const regexStr = path.replace(/:([^/]+)/g, (_, paramName) => {
    paramNames.push(paramName)
    return '([^/]+)'
  })
  dynamicRoutes.push({
    method: method.toUpperCase(),
    pattern: new RegExp(`^${regexStr}$`),
    paramNames,
    handler
  })
}

/**
 * 匹配动态路由
 */
function matchDynamicRoute(method: string, url: string): RouteMatch | null {
  const cleanUrl = url.split('?')[0]
  const upperMethod = method.toUpperCase()

  for (const route of dynamicRoutes) {
    if (route.method !== upperMethod) continue
    const match = cleanUrl.match(route.pattern)
    if (match) {
      const params: Record<string, string> = {}
      route.paramNames.forEach((name, index) => {
        params[name] = match[index + 1]
      })
      return { handler: route.handler, params }
    }
  }
  return null
}

/**
 * 匹配请求到 handler
 */
function matchHandler(method: string, url: string): ((config: AxiosRequestConfig) => Promise<AxiosResponse<any>>) | null {
  // 移除查询参数
  const cleanUrl = url.split('?')[0]
  const upperMethod = method.toUpperCase()

  // 精确匹配
  const exactKey = `${upperMethod} ${cleanUrl}`
  if (mockHandlers[exactKey]) {
    return mockHandlers[exactKey]
  }

  // 动态路由匹配
  const dynamicMatch = matchDynamicRoute(method, url)
  if (dynamicMatch) {
    return (config) => dynamicMatch.handler(config, dynamicMatch.params)
  }

  // 路径前缀匹配（按优先级排序）
  const sortedPatterns = Object.keys(mockHandlers).sort((a, b) => b.length - a.length)

  for (const pattern of sortedPatterns) {
    const [patternMethod, patternPath] = pattern.split(' ')
    if (patternMethod !== upperMethod) continue

    // 检查是否为前缀匹配（用于处理带 ID 的路由）
    if (cleanUrl.startsWith(patternPath) || patternPath === cleanUrl) {
      return mockHandlers[pattern]
    }
  }

  return null
}

/**
 * 处理 Mock 请求
 */
export async function handleMockRequest(config: AxiosRequestConfig): Promise<AxiosResponse<any> | null> {
  if (!isDemoMode()) {
    return null
  }

  const method = config.method?.toUpperCase() || 'GET'
  const url = config.url || ''

  // 尝试匹配 handler
  const handler = matchHandler(method, url)

  if (handler) {
    try {
      return await handler(config)
    } catch (error: any) {
      if (error.response) {
        throw error
      }
      console.error('[Mock] Handler error:', error)
      throw { response: createMockResponse({ detail: '模拟请求处理失败' }, 500) }
    }
  }

  // 未匹配的请求返回默认响应
  console.warn(`[Mock] Unhandled request: ${method} ${url}`)
  return createMockResponse({ message: '演示模式：该接口暂未模拟', demo_mode: true })
}

/**
 * 设置当前用户 token（供 client 初始化使用）
 */
export function setMockUserToken(token: string | null): void {
  currentUserToken = token
}

/**
 * 获取当前 mock token
 */
export function getMockUserToken(): string | null {
  return currentUserToken
}

// ========== Mock Provider Endpoints 数据 ==========
// 为每个 provider 生成对应的 endpoints
function generateMockEndpointsForProvider(providerId: string) {
  const provider = MOCK_PROVIDERS.find(p => p.id === providerId)
  if (!provider || provider.api_formats.length === 0) return []

  return provider.api_formats.map((format, index) => {
    const healthDetail = provider.endpoint_health_details.find(h => h.api_format === format)
    return {
      id: `ep-${providerId}-${index + 1}`,
      provider_id: providerId,
      provider_name: provider.name,
      api_format: format,
      base_url: format.includes('CLAUDE') ? 'https://api.anthropic.com' :
                format.includes('OPENAI') ? 'https://api.openai.com' :
                'https://generativelanguage.googleapis.com',
      auth_type: format.includes('GEMINI') ? 'api_key' : 'bearer',
      timeout: 120,
      max_retries: 3,
      priority: 100 - index * 10,
      weight: 100,
      health_score: healthDetail?.health_score ?? 1.0,
      consecutive_failures: healthDetail?.health_score && healthDetail.health_score < 0.7 ? 2 : 0,
      is_active: healthDetail?.is_active ?? true,
      total_keys: Math.ceil(Math.random() * 3) + 1,
      active_keys: Math.ceil(Math.random() * 2) + 1,
      created_at: provider.created_at,
      updated_at: new Date().toISOString()
    }
  })
}

// 为 endpoint 生成 keys
function generateMockKeysForEndpoint(endpointId: string, count: number = 2) {
  return Array.from({ length: count }, (_, i) => ({
    id: `key-${endpointId}-${i + 1}`,
    endpoint_id: endpointId,
    api_key_masked: `sk-***...${Math.random().toString(36).substring(2, 6)}`,
    name: i === 0 ? 'Primary Key' : `Backup Key ${i}`,
    rate_multiplier: 1.0,
    internal_priority: i + 1,
    health_score: 0.90 + Math.random() * 0.10,  // 0.90-1.00
    consecutive_failures: Math.random() > 0.8 ? 1 : 0,
    request_count: 1000 + Math.floor(Math.random() * 5000),
    success_count: 950 + Math.floor(Math.random() * 4800),
    error_count: Math.floor(Math.random() * 100),
    success_rate: 0.95 + Math.random() * 0.04,  // 0.95-0.99
    avg_response_time_ms: 800 + Math.floor(Math.random() * 600),
    is_active: true,
    created_at: '2024-01-01T00:00:00Z',
    updated_at: new Date().toISOString()
  }))
}

// 为 provider 生成 models
function generateMockModelsForProvider(providerId: string) {
  const provider = MOCK_PROVIDERS.find(p => p.id === providerId)
  if (!provider) return []

  // 基于 provider 的 api_formats 选择合适的模型
  const hasClaude = provider.api_formats.some(f => f.includes('CLAUDE'))
  const hasOpenAI = provider.api_formats.some(f => f.includes('OPENAI'))
  const hasGemini = provider.api_formats.some(f => f.includes('GEMINI'))

  const models: any[] = []
  const now = new Date().toISOString()

  if (hasClaude) {
    models.push(
      {
        id: `pm-${providerId}-claude-1`,
        provider_id: providerId,
        global_model_id: 'gm-003',
        provider_model_name: 'claude-sonnet-4-5-20250929',
        global_model_name: 'claude-sonnet-4-5-20250929',
        global_model_display_name: 'claude-sonnet-4-5',
        effective_input_price: 3.0,
        effective_output_price: 15.0,
        effective_supports_vision: true,
        effective_supports_function_calling: true,
        effective_supports_streaming: true,
        effective_supports_extended_thinking: true,
        is_active: true,
        is_available: true,
        created_at: provider.created_at,
        updated_at: now
      },
      {
        id: `pm-${providerId}-claude-2`,
        provider_id: providerId,
        global_model_id: 'gm-001',
        provider_model_name: 'claude-haiku-4-5-20251001',
        global_model_name: 'claude-haiku-4-5-20251001',
        global_model_display_name: 'claude-haiku-4-5',
        effective_input_price: 1.0,
        effective_output_price: 5.0,
        effective_supports_vision: true,
        effective_supports_function_calling: true,
        effective_supports_streaming: true,
        effective_supports_extended_thinking: true,
        is_active: true,
        is_available: true,
        created_at: provider.created_at,
        updated_at: now
      }
    )
  }
  if (hasOpenAI) {
    models.push(
      {
        id: `pm-${providerId}-openai-1`,
        provider_id: providerId,
        global_model_id: 'gm-006',
        provider_model_name: 'gpt-5.1',
        global_model_name: 'gpt-5.1',
        global_model_display_name: 'gpt-5.1',
        effective_input_price: 1.25,
        effective_output_price: 10.0,
        effective_supports_vision: true,
        effective_supports_function_calling: true,
        effective_supports_streaming: true,
        effective_supports_extended_thinking: true,
        is_active: true,
        is_available: true,
        created_at: provider.created_at,
        updated_at: now
      },
      {
        id: `pm-${providerId}-openai-2`,
        provider_id: providerId,
        global_model_id: 'gm-007',
        provider_model_name: 'gpt-5.1-codex',
        global_model_name: 'gpt-5.1-codex',
        global_model_display_name: 'gpt-5.1-codex',
        effective_input_price: 1.25,
        effective_output_price: 10.0,
        effective_supports_vision: true,
        effective_supports_function_calling: true,
        effective_supports_streaming: true,
        effective_supports_extended_thinking: true,
        is_active: true,
        is_available: true,
        created_at: provider.created_at,
        updated_at: now
      }
    )
  }
  if (hasGemini) {
    models.push(
      {
        id: `pm-${providerId}-gemini-1`,
        provider_id: providerId,
        global_model_id: 'gm-005',
        provider_model_name: 'gemini-3-pro-preview',
        global_model_name: 'gemini-3-pro-preview',
        global_model_display_name: 'gemini-3-pro-preview',
        effective_input_price: 2.0,
        effective_output_price: 12.0,
        effective_supports_vision: true,
        effective_supports_function_calling: true,
        effective_supports_streaming: true,
        effective_supports_extended_thinking: true,
        is_active: true,
        is_available: true,
        created_at: provider.created_at,
        updated_at: now
      }
    )
  }

  return models
}

// ========== 注册动态路由 ==========

// Provider 详情
registerDynamicRoute('GET', '/api/admin/providers/:providerId/summary', async (_config, params) => {
  await delay()
  requireAdmin()
  const provider = MOCK_PROVIDERS.find(p => p.id === params.providerId)
  if (!provider) {
    throw { response: createMockResponse({ detail: '提供商不存在' }, 404) }
  }
  return createMockResponse(provider)
})

// Provider 更新
registerDynamicRoute('PATCH', '/api/admin/providers/:providerId', async (config, params) => {
  await delay()
  requireAdmin()
  const provider = MOCK_PROVIDERS.find(p => p.id === params.providerId)
  if (!provider) {
    throw { response: createMockResponse({ detail: '提供商不存在' }, 404) }
  }
  const body = JSON.parse(config.data || '{}')
  return createMockResponse({ ...provider, ...body, updated_at: new Date().toISOString() })
})

// Provider 删除
registerDynamicRoute('DELETE', '/api/admin/providers/:providerId', async (_config, params) => {
  await delay()
  requireAdmin()
  const provider = MOCK_PROVIDERS.find(p => p.id === params.providerId)
  if (!provider) {
    throw { response: createMockResponse({ detail: '提供商不存在' }, 404) }
  }
  return createMockResponse({ message: '删除成功（演示模式）' })
})

// Provider Endpoints 列表
registerDynamicRoute('GET', '/api/admin/endpoints/providers/:providerId/endpoints', async (_config, params) => {
  await delay()
  requireAdmin()
  const endpoints = generateMockEndpointsForProvider(params.providerId)
  return createMockResponse(endpoints)
})

// 创建 Endpoint
registerDynamicRoute('POST', '/api/admin/endpoints/providers/:providerId/endpoints', async (config, params) => {
  await delay()
  requireAdmin()
  const body = JSON.parse(config.data || '{}')
  return createMockResponse({
    id: `ep-demo-${Date.now()}`,
    provider_id: params.providerId,
    ...body,
    created_at: new Date().toISOString()
  })
})

// Endpoint 详情
registerDynamicRoute('GET', '/api/admin/endpoints/:endpointId', async (_config, params) => {
  await delay()
  requireAdmin()
  // 从所有 providers 的 endpoints 中查找
  for (const provider of MOCK_PROVIDERS) {
    const endpoints = generateMockEndpointsForProvider(provider.id)
    const endpoint = endpoints.find(e => e.id === params.endpointId)
    if (endpoint) {
      return createMockResponse(endpoint)
    }
  }
  throw { response: createMockResponse({ detail: '端点不存在' }, 404) }
})

// Endpoint 更新
registerDynamicRoute('PUT', '/api/admin/endpoints/:endpointId', async (config, params) => {
  await delay()
  requireAdmin()
  const body = JSON.parse(config.data || '{}')
  return createMockResponse({ id: params.endpointId, ...body, updated_at: new Date().toISOString() })
})

// Endpoint 删除
registerDynamicRoute('DELETE', '/api/admin/endpoints/:endpointId', async (_config, _params) => {
  await delay()
  requireAdmin()
  return createMockResponse({ message: '删除成功（演示模式）' })
})

// Endpoint Keys 列表
registerDynamicRoute('GET', '/api/admin/endpoints/:endpointId/keys', async (_config, params) => {
  await delay()
  requireAdmin()
  const keys = generateMockKeysForEndpoint(params.endpointId, 2)
  return createMockResponse(keys)
})

// 创建 Key
registerDynamicRoute('POST', '/api/admin/endpoints/:endpointId/keys', async (config, params) => {
  await delay()
  requireAdmin()
  const body = JSON.parse(config.data || '{}')
  return createMockResponse({
    id: `key-demo-${Date.now()}`,
    endpoint_id: params.endpointId,
    api_key_masked: 'sk-***...demo',
    ...body,
    created_at: new Date().toISOString()
  })
})

// Key 更新
registerDynamicRoute('PUT', '/api/admin/endpoints/keys/:keyId', async (config, params) => {
  await delay()
  requireAdmin()
  const body = JSON.parse(config.data || '{}')
  return createMockResponse({ id: params.keyId, ...body, updated_at: new Date().toISOString() })
})

// Key 删除
registerDynamicRoute('DELETE', '/api/admin/endpoints/keys/:keyId', async (_config, _params) => {
  await delay()
  requireAdmin()
  return createMockResponse({ message: '删除成功（演示模式）' })
})

// Provider Models 列表
registerDynamicRoute('GET', '/api/admin/providers/:providerId/models', async (_config, params) => {
  await delay()
  requireAdmin()
  const models = generateMockModelsForProvider(params.providerId)
  return createMockResponse(models)
})

// Provider Model 详情
registerDynamicRoute('GET', '/api/admin/providers/:providerId/models/:modelId', async (_config, params) => {
  await delay()
  requireAdmin()
  const models = generateMockModelsForProvider(params.providerId)
  const model = models.find(m => m.id === params.modelId)
  if (!model) {
    throw { response: createMockResponse({ detail: '模型不存在' }, 404) }
  }
  return createMockResponse(model)
})

// 创建 Provider Model
registerDynamicRoute('POST', '/api/admin/providers/:providerId/models', async (config, params) => {
  await delay()
  requireAdmin()
  const body = JSON.parse(config.data || '{}')
  return createMockResponse({
    id: `pm-demo-${Date.now()}`,
    provider_id: params.providerId,
    ...body,
    created_at: new Date().toISOString()
  })
})

// 更新 Provider Model
registerDynamicRoute('PATCH', '/api/admin/providers/:providerId/models/:modelId', async (config, params) => {
  await delay()
  requireAdmin()
  const body = JSON.parse(config.data || '{}')
  return createMockResponse({ id: params.modelId, provider_id: params.providerId, ...body, updated_at: new Date().toISOString() })
})

// 删除 Provider Model
registerDynamicRoute('DELETE', '/api/admin/providers/:providerId/models/:modelId', async (_config, _params) => {
  await delay()
  requireAdmin()
  return createMockResponse({ message: '删除成功（演示模式）' })
})

// 批量创建 Provider Models
registerDynamicRoute('POST', '/api/admin/providers/:providerId/models/batch', async (config, params) => {
  await delay()
  requireAdmin()
  const body = JSON.parse(config.data || '{}')
  const models = (body.models || []).map((m: any, i: number) => ({
    id: `pm-demo-${Date.now()}-${i}`,
    provider_id: params.providerId,
    ...m,
    created_at: new Date().toISOString()
  }))
  return createMockResponse({ models, created_count: models.length })
})

// Provider 可用源模型
registerDynamicRoute('GET', '/api/admin/providers/:providerId/available-source-models', async (_config, params) => {
  await delay()
  requireAdmin()
  const provider = MOCK_PROVIDERS.find(p => p.id === params.providerId)
  if (!provider) {
    throw { response: createMockResponse({ detail: '提供商不存在' }, 404) }
  }
  // 返回一些可用的源模型
  const availableModels = [
    'claude-sonnet-4-5-20250929',
    'claude-haiku-4-5-20251001',
    'claude-opus-4-5-20251101',
    'gpt-5.1',
    'gpt-5.1-codex',
    'gemini-3-pro-preview'
  ]
  return createMockResponse({ models: availableModels })
})

// 分配 GlobalModels 到 Provider
registerDynamicRoute('POST', '/api/admin/providers/:providerId/assign-global-models', async (config, _params) => {
  await delay()
  requireAdmin()
  const body = JSON.parse(config.data || '{}')
  const result = {
    success: (body.global_model_ids || []).map((id: string) => ({
      global_model_id: id,
      provider_model_id: `pm-demo-${Date.now()}-${id}`
    })),
    errors: []
  }
  return createMockResponse(result)
})

// GlobalModel 详情
registerDynamicRoute('GET', '/api/admin/models/global/:modelId', async (_config, params) => {
  await delay()
  requireAdmin()
  const model = MOCK_GLOBAL_MODELS.find(m => m.id === params.modelId)
  if (!model) {
    throw { response: createMockResponse({ detail: '模型不存在' }, 404) }
  }
  return createMockResponse(model)
})

// GlobalModel 更新
registerDynamicRoute('PATCH', '/api/admin/models/global/:modelId', async (config, params) => {
  await delay()
  requireAdmin()
  const model = MOCK_GLOBAL_MODELS.find(m => m.id === params.modelId)
  if (!model) {
    throw { response: createMockResponse({ detail: '模型不存在' }, 404) }
  }
  const body = JSON.parse(config.data || '{}')
  return createMockResponse({ ...model, ...body, updated_at: new Date().toISOString() })
})

// GlobalModel 删除
registerDynamicRoute('DELETE', '/api/admin/models/global/:modelId', async (_config, params) => {
  await delay()
  requireAdmin()
  const model = MOCK_GLOBAL_MODELS.find(m => m.id === params.modelId)
  if (!model) {
    throw { response: createMockResponse({ detail: '模型不存在' }, 404) }
  }
  return createMockResponse({ message: '删除成功（演示模式）' })
})

// GlobalModel 批量分配到 Providers
registerDynamicRoute('POST', '/api/admin/models/global/:modelId/assign-to-providers', async (config, _params) => {
  await delay()
  requireAdmin()
  const body = JSON.parse(config.data || '{}')
  const result = {
    success: (body.provider_ids || []).map((providerId: string) => {
      const provider = MOCK_PROVIDERS.find(p => p.id === providerId)
      return {
        provider_id: providerId,
        provider_name: provider?.name || 'unknown',
        model_id: `pm-demo-${Date.now()}-${providerId}`
      }
    }),
    errors: []
  }
  return createMockResponse(result)
})

// Endpoint Health 详情
registerDynamicRoute('GET', '/api/admin/endpoints/health/endpoint/:endpointId', async (_config, params) => {
  await delay()
  requireAdmin()
  return createMockResponse({
    endpoint_id: params.endpointId,
    health_score: 0.95,
    total_requests: 5000,
    success_count: 4750,
    failed_count: 250,
    success_rate: 0.95,
    avg_response_time_ms: 1200,
    last_success_at: new Date().toISOString(),
    last_failure_at: new Date(Date.now() - 3600000).toISOString()
  })
})

// Key Health 详情
registerDynamicRoute('GET', '/api/admin/endpoints/health/key/:keyId', async (_config, params) => {
  await delay()
  requireAdmin()
  return createMockResponse({
    key_id: params.keyId,
    health_score: 0.92,
    total_requests: 2000,
    success_count: 1840,
    failed_count: 160,
    success_rate: 0.92,
    avg_response_time_ms: 1100,
    last_success_at: new Date().toISOString(),
    last_failure_at: new Date(Date.now() - 7200000).toISOString()
  })
})

// 重置 Key Health
registerDynamicRoute('PATCH', '/api/admin/endpoints/health/keys/:keyId', async (_config, params) => {
  await delay()
  requireAdmin()
  return createMockResponse({
    key_id: params.keyId,
    message: '健康状态已重置（演示模式）'
  })
})

// Alias/Mapping 详情
registerDynamicRoute('GET', '/api/admin/models/mappings/:mappingId', async (_config, params) => {
  await delay()
  requireAdmin()
  const alias = MOCK_ALIASES.find(a => a.id === params.mappingId)
  if (!alias) {
    throw { response: createMockResponse({ detail: '别名不存在' }, 404) }
  }
  return createMockResponse(alias)
})

// Alias/Mapping 更新
registerDynamicRoute('PATCH', '/api/admin/models/mappings/:mappingId', async (config, params) => {
  await delay()
  requireAdmin()
  const alias = MOCK_ALIASES.find(a => a.id === params.mappingId)
  if (!alias) {
    throw { response: createMockResponse({ detail: '别名不存在' }, 404) }
  }
  const body = JSON.parse(config.data || '{}')
  return createMockResponse({ ...alias, ...body, updated_at: new Date().toISOString() })
})

// Alias/Mapping 删除
registerDynamicRoute('DELETE', '/api/admin/models/mappings/:mappingId', async (_config, params) => {
  await delay()
  requireAdmin()
  const alias = MOCK_ALIASES.find(a => a.id === params.mappingId)
  if (!alias) {
    throw { response: createMockResponse({ detail: '别名不存在' }, 404) }
  }
  return createMockResponse({ message: '删除成功（演示模式）' })
})

// 公告详情
registerDynamicRoute('GET', '/api/announcements/:announcementId', async (_config, params) => {
  await delay()
  const announcement = MOCK_ANNOUNCEMENTS.find(a => a.id === params.announcementId)
  if (!announcement) {
    throw { response: createMockResponse({ detail: '公告不存在' }, 404) }
  }
  return createMockResponse(announcement)
})

// 公告更新
registerDynamicRoute('PATCH', '/api/announcements/:announcementId', async (config, params) => {
  await delay()
  requireAdmin()
  const announcement = MOCK_ANNOUNCEMENTS.find(a => a.id === params.announcementId)
  if (!announcement) {
    throw { response: createMockResponse({ detail: '公告不存在' }, 404) }
  }
  const body = JSON.parse(config.data || '{}')
  return createMockResponse({ ...announcement, ...body, updated_at: new Date().toISOString() })
})

// 公告删除
registerDynamicRoute('DELETE', '/api/announcements/:announcementId', async (_config, params) => {
  await delay()
  requireAdmin()
  const announcement = MOCK_ANNOUNCEMENTS.find(a => a.id === params.announcementId)
  if (!announcement) {
    throw { response: createMockResponse({ detail: '公告不存在' }, 404) }
  }
  return createMockResponse({ message: '删除成功（演示模式）' })
})

// 用户详情
registerDynamicRoute('GET', '/api/admin/users/:userId', async (_config, params) => {
  await delay()
  requireAdmin()
  const user = MOCK_ALL_USERS.find(u => u.id === params.userId)
  if (!user) {
    throw { response: createMockResponse({ detail: '用户不存在' }, 404) }
  }
  return createMockResponse(user)
})

// 用户更新
registerDynamicRoute('PATCH', '/api/admin/users/:userId', async (config, params) => {
  await delay()
  requireAdmin()
  const user = MOCK_ALL_USERS.find(u => u.id === params.userId)
  if (!user) {
    throw { response: createMockResponse({ detail: '用户不存在' }, 404) }
  }
  const body = JSON.parse(config.data || '{}')
  return createMockResponse({ ...user, ...body })
})

// 用户删除
registerDynamicRoute('DELETE', '/api/admin/users/:userId', async (_config, params) => {
  await delay()
  requireAdmin()
  const user = MOCK_ALL_USERS.find(u => u.id === params.userId)
  if (!user) {
    throw { response: createMockResponse({ detail: '用户不存在' }, 404) }
  }
  return createMockResponse({ message: '删除成功（演示模式）' })
})

// 用户 API Keys
registerDynamicRoute('GET', '/api/admin/users/:userId/api-keys', async (_config, _params) => {
  await delay()
  requireAdmin()
  return createMockResponse(MOCK_USER_API_KEYS)
})

// API Key 详情
registerDynamicRoute('GET', '/api/admin/api-keys/:keyId', async (_config, params) => {
  await delay()
  requireAdmin()
  const key = MOCK_ADMIN_API_KEYS.api_keys.find(k => k.id === params.keyId)
  if (!key) {
    throw { response: createMockResponse({ detail: 'API Key 不存在' }, 404) }
  }
  return createMockResponse(key)
})

// API Key 更新
registerDynamicRoute('PATCH', '/api/admin/api-keys/:keyId', async (config, params) => {
  await delay()
  requireAdmin()
  const key = MOCK_ADMIN_API_KEYS.api_keys.find(k => k.id === params.keyId)
  if (!key) {
    throw { response: createMockResponse({ detail: 'API Key 不存在' }, 404) }
  }
  const body = JSON.parse(config.data || '{}')
  return createMockResponse({ ...key, ...body })
})

// API Key 删除
registerDynamicRoute('DELETE', '/api/admin/api-keys/:keyId', async (_config, params) => {
  await delay()
  requireAdmin()
  const key = MOCK_ADMIN_API_KEYS.api_keys.find(k => k.id === params.keyId)
  if (!key) {
    throw { response: createMockResponse({ detail: 'API Key 不存在' }, 404) }
  }
  return createMockResponse({ message: '删除成功（演示模式）' })
})

// 用户 API Key 删除
registerDynamicRoute('DELETE', '/api/users/me/api-keys/:keyId', async (_config, params) => {
  await delay()
  const key = MOCK_USER_API_KEYS.find(k => k.id === params.keyId)
  if (!key) {
    throw { response: createMockResponse({ detail: 'API Key 不存在' }, 404) }
  }
  return createMockResponse({ message: '删除成功（演示模式）' })
})

// 使用记录详情 - /api/admin/usage/:requestId
registerDynamicRoute('GET', '/api/admin/usage/:requestId', async (_config, params) => {
  await delay()
  requireAdmin()

  const records = getUsageRecords()
  const record = records.find(r => r.id === params.requestId)

  if (!record) {
    throw { response: createMockResponse({ detail: '请求记录不存在' }, 404) }
  }

  // 生成详细的请求信息
  const users = [
    { id: 'demo-admin-uuid-0001', username: 'Demo Admin', email: 'admin@demo.aether.ai' },
    { id: 'demo-user-uuid-0002', username: 'Demo User', email: 'user@demo.aether.ai' },
    { id: 'demo-user-uuid-0003', username: 'Alice Chen', email: 'alice@demo.aether.ai' },
    { id: 'demo-user-uuid-0004', username: 'Bob Zhang', email: 'bob@demo.aether.ai' }
  ]
  const user = users.find(u => u.id === record.user_id) || users[0]

  // 生成模拟的请求/响应数据
  const mockRequestBody = {
    model: record.model,
    max_tokens: 4096,
    messages: [
      {
        role: 'user',
        content: 'Hello! Can you help me understand how API gateways work?'
      }
    ],
    stream: record.is_stream
  }

  const mockResponseBody = record.status === 'failed' ? {
    error: {
      type: 'api_error',
      message: record.error_message || 'An error occurred'
    }
  } : {
    id: `msg_${record.id}`,
    type: 'message',
    role: 'assistant',
    content: [
      {
        type: 'text',
        text: 'API gateways are middleware services that sit between clients and backend services. They handle routing, authentication, rate limiting, and more...'
      }
    ],
    model: record.model,
    stop_reason: 'end_turn',
    usage: {
      input_tokens: record.input_tokens,
      output_tokens: record.output_tokens
    }
  }

  // 计算费用明细
  const inputPricePer1M = record.model.includes('opus') ? 15 : record.model.includes('haiku') ? 1 : 3
  const outputPricePer1M = record.model.includes('opus') ? 75 : record.model.includes('haiku') ? 5 : 15
  const inputCost = (record.input_tokens / 1000000) * inputPricePer1M
  const outputCost = (record.output_tokens / 1000000) * outputPricePer1M
  const cacheCreationCost = (record.cache_creation_input_tokens / 1000000) * (inputPricePer1M * 1.25)
  const cacheReadCost = (record.cache_read_input_tokens / 1000000) * (inputPricePer1M * 0.1)

  const detail = {
    id: record.id,
    request_id: `req_${record.id}`,
    user: {
      id: user.id,
      username: user.username,
      email: user.email
    },
    api_key: {
      id: `key-${record.api_key_name}`,
      name: record.api_key_name,
      display: `sk-***${record.api_key_name.slice(-4)}`
    },
    provider: record.provider,
    api_format: record.api_format,
    model: record.model,
    target_model: record.target_model,
    tokens: {
      input: record.input_tokens,
      output: record.output_tokens,
      total: record.total_tokens
    },
    cost: {
      input: inputCost,
      output: outputCost,
      total: record.cost
    },
    input_tokens: record.input_tokens,
    output_tokens: record.output_tokens,
    total_tokens: record.total_tokens,
    cache_creation_input_tokens: record.cache_creation_input_tokens,
    cache_read_input_tokens: record.cache_read_input_tokens,
    input_cost: inputCost,
    output_cost: outputCost,
    total_cost: record.cost,
    cache_creation_cost: cacheCreationCost,
    cache_read_cost: cacheReadCost,
    input_price_per_1m: inputPricePer1M,
    output_price_per_1m: outputPricePer1M,
    cache_creation_price_per_1m: inputPricePer1M * 1.25,
    cache_read_price_per_1m: inputPricePer1M * 0.1,
    request_type: record.is_stream ? 'stream' : 'standard',
    is_stream: record.is_stream,
    status_code: record.status_code,
    error_message: record.error_message,
    response_time_ms: record.response_time_ms,
    created_at: record.created_at,
    request_headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer sk-aether-***',
      'X-Api-Key': 'sk-***',
      'User-Agent': 'Aether-Client/1.0',
      'Accept': 'application/json',
      'X-Request-ID': `req_${record.id}`
    },
    request_body: mockRequestBody,
    provider_request_headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer sk-${record.provider}-***`,
      'anthropic-version': '2024-01-01',
      'X-Request-ID': `req_${record.id}`
    },
    response_headers: {
      'Content-Type': 'application/json',
      'X-Request-ID': `req_${record.id}`,
      'X-RateLimit-Limit': '1000',
      'X-RateLimit-Remaining': '999',
      'X-RateLimit-Reset': new Date(Date.now() + 60000).toISOString()
    },
    response_body: mockResponseBody,
    metadata: {
      client_ip: '192.168.1.100',
      user_agent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)',
      request_path: `/v1/messages`,
      provider_endpoint: `https://api.${record.provider}.com/v1/messages`,
      gateway_version: '1.0.0',
      processing_time_ms: Math.floor((record.response_time_ms || 1000) * 0.1)
    },
    tiered_pricing: {
      total_input_context: record.input_tokens + record.cache_creation_input_tokens + record.cache_read_input_tokens,
      tier_index: 0,
      source: 'provider',
      tiers: [
        {
          up_to: 200000,
          input_price_per_1m: inputPricePer1M,
          output_price_per_1m: outputPricePer1M,
          cache_creation_price_per_1m: inputPricePer1M * 1.25,
          cache_read_price_per_1m: inputPricePer1M * 0.1
        },
        {
          up_to: null,
          input_price_per_1m: inputPricePer1M * 0.5,
          output_price_per_1m: outputPricePer1M * 0.5,
          cache_creation_price_per_1m: inputPricePer1M * 0.625,
          cache_read_price_per_1m: inputPricePer1M * 0.05
        }
      ]
    }
  }

  return createMockResponse(detail)
})

// 请求链路追踪 - /api/admin/monitoring/trace/:requestId
registerDynamicRoute('GET', '/api/admin/monitoring/trace/:requestId', async (_config, params) => {
  await delay()
  requireAdmin()

  const requestId = params.requestId
  // 从 usage-xxxx 格式中提取记录
  const records = getUsageRecords()
  const recordId = requestId.startsWith('req_') ? requestId.replace('req_', '') : requestId
  const record = records.find(r => r.id === recordId)

  if (!record) {
    throw { response: createMockResponse({ detail: '请求记录不存在' }, 404) }
  }

  // 生成候选记录
  const now = new Date(record.created_at)
  const baseLatency = record.response_time_ms || 1000

  // 根据请求状态生成不同的候选链路
  const candidates = []
  const providerNames = ['AlphaAI', 'BetaClaude', 'GammaCode', 'DeltaAPI']

  if (record.status === 'completed') {
    // 成功请求：可能有1-2个跳过的候选，最后一个成功
    const skipCount = Math.random() > 0.5 ? 1 : 0

    for (let i = 0; i < skipCount; i++) {
      const skipStarted = new Date(now.getTime() + i * 50)
      candidates.push({
        id: `candidate-${requestId}-${i}`,
        request_id: requestId,
        candidate_index: i,
        retry_index: 0,
        provider_id: `provider-${i + 1}`,
        provider_name: providerNames[i % providerNames.length],
        provider_website: `https://${providerNames[i % providerNames.length].toLowerCase()}.com`,
        endpoint_id: `endpoint-${i + 1}`,
        endpoint_name: record.api_format,
        key_id: `key-${i + 1}`,
        key_name: `${record.provider}-key-${i + 1}`,
        key_preview: `sk-***${Math.random().toString(36).substring(2, 6)}`,
        key_capabilities: { 'cache_1h': true, 'vision': true },
        required_capabilities: { 'cache_1h': record.cache_read_input_tokens > 0 },
        status: 'skipped',
        skip_reason: ['并发限制已满', '健康分数过低', '倍率不匹配'][i % 3],
        is_cached: false,
        latency_ms: 10 + Math.floor(Math.random() * 20),
        created_at: skipStarted.toISOString(),
        started_at: skipStarted.toISOString(),
        finished_at: new Date(skipStarted.getTime() + 10).toISOString()
      })
    }

    // 成功的候选
    const successStarted = new Date(now.getTime() + skipCount * 50)
    candidates.push({
      id: `candidate-${requestId}-success`,
      request_id: requestId,
      candidate_index: skipCount,
      retry_index: 0,
      provider_id: `provider-${record.provider}`,
      provider_name: record.provider === 'anthropic' ? 'AlphaAI' : record.provider === 'openai' ? 'BetaClaude' : 'GammaCode',
      provider_website: `https://api.${record.provider}.com`,
      endpoint_id: `endpoint-${record.provider}`,
      endpoint_name: record.api_format,
      key_id: `key-${record.api_key_name}`,
      key_name: record.api_key_name,
      key_preview: `sk-***${Math.random().toString(36).substring(2, 6)}`,
      key_capabilities: { 'cache_1h': true, 'vision': true, 'extended_thinking': true },
      required_capabilities: {
        'cache_1h': record.cache_read_input_tokens > 0,
        'vision': false,
        'extended_thinking': false
      },
      status: 'success',
      is_cached: record.cache_read_input_tokens > 0,
      status_code: 200,
      latency_ms: baseLatency,
      created_at: successStarted.toISOString(),
      started_at: successStarted.toISOString(),
      finished_at: new Date(successStarted.getTime() + baseLatency).toISOString()
    })
  } else if (record.status === 'failed') {
    // 失败请求：多个候选都失败
    const attemptCount = 2 + Math.floor(Math.random() * 2)

    for (let i = 0; i < attemptCount; i++) {
      const attemptStarted = new Date(now.getTime() + i * 200)
      const attemptLatency = 100 + Math.floor(Math.random() * 500)
      candidates.push({
        id: `candidate-${requestId}-${i}`,
        request_id: requestId,
        candidate_index: i,
        retry_index: 0,
        provider_id: `provider-${i + 1}`,
        provider_name: providerNames[i % providerNames.length],
        provider_website: `https://${providerNames[i % providerNames.length].toLowerCase()}.com`,
        endpoint_id: `endpoint-${i + 1}`,
        endpoint_name: record.api_format,
        key_id: `key-${i + 1}`,
        key_name: `${record.provider}-key-${i + 1}`,
        key_preview: `sk-***${Math.random().toString(36).substring(2, 6)}`,
        key_capabilities: { 'cache_1h': true },
        required_capabilities: {},
        status: 'failed',
        is_cached: false,
        status_code: record.status_code,
        error_type: ['rate_limit_error', 'api_error', 'timeout_error'][i % 3],
        error_message: record.error_message || 'Request failed',
        latency_ms: attemptLatency,
        created_at: attemptStarted.toISOString(),
        started_at: attemptStarted.toISOString(),
        finished_at: new Date(attemptStarted.getTime() + attemptLatency).toISOString()
      })
    }
  } else {
    // 进行中的请求
    candidates.push({
      id: `candidate-${requestId}-0`,
      request_id: requestId,
      candidate_index: 0,
      retry_index: 0,
      provider_id: `provider-${record.provider}`,
      provider_name: record.provider === 'anthropic' ? 'AlphaAI' : record.provider === 'openai' ? 'BetaClaude' : 'GammaCode',
      provider_website: `https://api.${record.provider}.com`,
      endpoint_id: `endpoint-${record.provider}`,
      endpoint_name: record.api_format,
      key_id: `key-${record.api_key_name}`,
      key_name: record.api_key_name,
      key_preview: `sk-***${Math.random().toString(36).substring(2, 6)}`,
      key_capabilities: { 'cache_1h': true, 'vision': true },
      required_capabilities: {},
      status: 'streaming',
      is_cached: false,
      latency_ms: undefined,
      created_at: now.toISOString(),
      started_at: now.toISOString(),
      finished_at: undefined
    })
  }

  const totalLatency = candidates.reduce((sum, c) => sum + (c.latency_ms || 0), 0)

  return createMockResponse({
    request_id: requestId,
    total_candidates: candidates.length,
    final_status: record.status === 'completed' ? 'success' : record.status === 'failed' ? 'failed' : 'streaming',
    total_latency_ms: totalLatency,
    candidates
  })
})

// ========== 请求间隔时间线 Mock 数据 ==========

// 生成请求间隔时间线数据（用于散点图）
function generateIntervalTimelineData(
  hours: number = 24,
  limit: number = 5000,
  includeUserInfo: boolean = false
) {
  const now = Date.now()
  const startTime = now - hours * 60 * 60 * 1000
  const points: Array<{ x: string; y: number; user_id?: string; model?: string }> = []

  // 用户列表（用于管理员视图）
  const users = [
    { id: 'demo-admin-uuid-0001', username: 'Demo Admin' },
    { id: 'demo-user-uuid-0002', username: 'Demo User' },
    { id: 'demo-user-uuid-0003', username: 'Alice Chen' },
    { id: 'demo-user-uuid-0004', username: 'Bob Zhang' }
  ]

  // 模型列表（用于按模型区分颜色）
  const models = [
    'claude-sonnet-4-20250514',
    'claude-3-5-sonnet-20241022',
    'claude-3-5-haiku-20241022',
    'claude-opus-4-20250514'
  ]

  // 生成模拟的请求间隔数据
  // 间隔时间分布：大部分在 0-10 分钟，少量在 10-60 分钟，极少数在 60-120 分钟
  const pointCount = Math.min(limit, Math.floor(hours * 80)) // 每小时约 80 个数据点

  let currentTime = startTime + Math.random() * 60 * 1000 // 从起始时间后随机开始

  for (let i = 0; i < pointCount && currentTime < now; i++) {
    // 生成间隔时间（分钟），使用指数分布模拟真实场景
    let interval: number
    const rand = Math.random()
    if (rand < 0.7) {
      // 70% 的请求间隔在 0-5 分钟
      interval = Math.random() * 5
    } else if (rand < 0.9) {
      // 20% 的请求间隔在 5-30 分钟
      interval = 5 + Math.random() * 25
    } else if (rand < 0.98) {
      // 8% 的请求间隔在 30-90 分钟
      interval = 30 + Math.random() * 60
    } else {
      // 2% 的请求间隔在 90-120 分钟
      interval = 90 + Math.random() * 30
    }

    // 添加一些工作时间的模式（工作时间间隔更短）
    const hour = new Date(currentTime).getHours()
    if (hour >= 9 && hour <= 18) {
      interval *= 0.6 // 工作时间间隔更短
    } else if (hour >= 22 || hour <= 6) {
      interval *= 1.5 // 夜间间隔更长
    }

    // 确保间隔不超过 120 分钟
    interval = Math.min(interval, 120)

    const point: { x: string; y: number; user_id?: string; model?: string } = {
      x: new Date(currentTime).toISOString(),
      y: Math.round(interval * 100) / 100,
      model: models[Math.floor(Math.random() * models.length)]
    }

    if (includeUserInfo) {
      // 管理员视图：添加用户信息
      const user = users[Math.floor(Math.random() * users.length)]
      point.user_id = user.id
    }

    points.push(point)

    // 下一个请求时间 = 当前时间 + 间隔 + 一些随机抖动
    currentTime += interval * 60 * 1000 + Math.random() * 30 * 1000
  }

  // 按时间排序
  points.sort((a, b) => new Date(a.x).getTime() - new Date(b.x).getTime())

  // 收集出现的模型
  const usedModels = [...new Set(points.map(p => p.model).filter(Boolean))] as string[]

  const response: {
    analysis_period_hours: number
    total_points: number
    points: typeof points
    users?: Record<string, string>
    models?: string[]
  } = {
    analysis_period_hours: hours,
    total_points: points.length,
    points,
    models: usedModels
  }

  if (includeUserInfo) {
    response.users = Object.fromEntries(users.map(u => [u.id, u.username]))
  }

  return response
}

// 用户 interval-timeline 接口
mockHandlers['GET /api/users/me/usage/interval-timeline'] = async (config) => {
  await delay()
  const params = config.params || {}
  const hours = parseInt(params.hours) || 24
  const limit = parseInt(params.limit) || 5000
  const data = generateIntervalTimelineData(hours, limit, false)
  return createMockResponse(data)
}

// 管理员 interval-timeline 接口
mockHandlers['GET /api/admin/usage/cache-affinity/interval-timeline'] = async (config) => {
  await delay()
  requireAdmin()
  const params = config.params || {}
  const hours = parseInt(params.hours) || 24
  const limit = parseInt(params.limit) || 10000
  const userId = params.user_id
  const includeUserInfo = params.include_user_info === 'true' || params.include_user_info === true

  // 如果指定了 user_id，则不包含用户信息
  const data = generateIntervalTimelineData(hours, limit, includeUserInfo && !userId)
  return createMockResponse(data)
}

// ========== TTL 分析 Mock 数据 ==========

// 生成 TTL 分析数据
function generateTTLAnalysisData(hours: number = 168) {
  const users = [
    { id: 'demo-admin-uuid-0001', username: 'Demo Admin', email: 'admin@demo.aether.io' },
    { id: 'demo-user-uuid-0002', username: 'Demo User', email: 'user@demo.aether.io' },
    { id: 'demo-user-uuid-0003', username: 'Alice Chen', email: 'alice@demo.aether.io' },
    { id: 'demo-user-uuid-0004', username: 'Bob Zhang', email: 'bob@demo.aether.io' }
  ]

  const usersAnalysis = users.map(user => {
    // 为每个用户生成不同的使用模式
    const requestCount = 50 + Math.floor(Math.random() * 500)

    // 根据用户特性生成不同的间隔分布
    let within5min, within15min, within30min, within60min, over60min
    let p50, p75, p90
    let recommendedTtl: number
    let recommendationReason: string

    const userType = Math.random()
    if (userType < 0.3) {
      // 高频用户 (30%)
      within5min = Math.floor(requestCount * (0.6 + Math.random() * 0.2))
      within15min = Math.floor(requestCount * (0.1 + Math.random() * 0.1))
      within30min = Math.floor(requestCount * (0.05 + Math.random() * 0.05))
      within60min = Math.floor(requestCount * (0.02 + Math.random() * 0.03))
      over60min = requestCount - within5min - within15min - within30min - within60min
      p50 = 1.5 + Math.random() * 2
      p75 = 3 + Math.random() * 3
      p90 = 4 + Math.random() * 2
      recommendedTtl = 5
      recommendationReason = `高频用户：90% 的请求间隔在 ${p90.toFixed(1)} 分钟内`
    } else if (userType < 0.6) {
      // 中频用户 (30%)
      within5min = Math.floor(requestCount * (0.3 + Math.random() * 0.15))
      within15min = Math.floor(requestCount * (0.25 + Math.random() * 0.15))
      within30min = Math.floor(requestCount * (0.15 + Math.random() * 0.1))
      within60min = Math.floor(requestCount * (0.1 + Math.random() * 0.05))
      over60min = requestCount - within5min - within15min - within30min - within60min
      p50 = 5 + Math.random() * 5
      p75 = 10 + Math.random() * 8
      p90 = 18 + Math.random() * 10
      recommendedTtl = 15
      recommendationReason = `中高频用户：75% 的请求间隔在 ${p75.toFixed(1)} 分钟内`
    } else if (userType < 0.85) {
      // 中低频用户 (25%)
      within5min = Math.floor(requestCount * (0.15 + Math.random() * 0.1))
      within15min = Math.floor(requestCount * (0.2 + Math.random() * 0.1))
      within30min = Math.floor(requestCount * (0.25 + Math.random() * 0.1))
      within60min = Math.floor(requestCount * (0.15 + Math.random() * 0.1))
      over60min = requestCount - within5min - within15min - within30min - within60min
      p50 = 12 + Math.random() * 8
      p75 = 22 + Math.random() * 10
      p90 = 35 + Math.random() * 15
      recommendedTtl = 30
      recommendationReason = `中频用户：75% 的请求间隔在 ${p75.toFixed(1)} 分钟内`
    } else {
      // 低频用户 (15%)
      within5min = Math.floor(requestCount * (0.05 + Math.random() * 0.1))
      within15min = Math.floor(requestCount * (0.1 + Math.random() * 0.1))
      within30min = Math.floor(requestCount * (0.15 + Math.random() * 0.1))
      within60min = Math.floor(requestCount * (0.25 + Math.random() * 0.1))
      over60min = requestCount - within5min - within15min - within30min - within60min
      p50 = 25 + Math.random() * 15
      p75 = 45 + Math.random() * 20
      p90 = 70 + Math.random() * 30
      recommendedTtl = 60
      recommendationReason = `低频用户：75% 的请求间隔为 ${p75.toFixed(1)} 分钟，建议使用长 TTL`
    }

    // 确保没有负数
    over60min = Math.max(0, over60min)

    const avgInterval = (within5min * 2.5 + within15min * 10 + within30min * 22 + within60min * 45 + over60min * 80) / requestCount

    return {
      group_id: user.id,
      username: user.username,
      email: user.email,
      request_count: requestCount,
      interval_distribution: {
        within_5min: within5min,
        within_15min: within15min,
        within_30min: within30min,
        within_60min: within60min,
        over_60min: over60min
      },
      interval_percentages: {
        within_5min: Math.round(within5min / requestCount * 1000) / 10,
        within_15min: Math.round(within15min / requestCount * 1000) / 10,
        within_30min: Math.round(within30min / requestCount * 1000) / 10,
        within_60min: Math.round(within60min / requestCount * 1000) / 10,
        over_60min: Math.round(over60min / requestCount * 1000) / 10
      },
      percentiles: {
        p50: Math.round(p50 * 100) / 100,
        p75: Math.round(p75 * 100) / 100,
        p90: Math.round(p90 * 100) / 100
      },
      avg_interval_minutes: Math.round(avgInterval * 100) / 100,
      min_interval_minutes: Math.round((0.1 + Math.random() * 0.5) * 100) / 100,
      max_interval_minutes: Math.round((80 + Math.random() * 40) * 100) / 100,
      recommended_ttl_minutes: recommendedTtl,
      recommendation_reason: recommendationReason
    }
  })

  // 汇总 TTL 分布
  const ttlDistribution = {
    '5min': usersAnalysis.filter(u => u.recommended_ttl_minutes === 5).length,
    '15min': usersAnalysis.filter(u => u.recommended_ttl_minutes === 15).length,
    '30min': usersAnalysis.filter(u => u.recommended_ttl_minutes === 30).length,
    '60min': usersAnalysis.filter(u => u.recommended_ttl_minutes === 60).length
  }

  return {
    analysis_period_hours: hours,
    total_users_analyzed: usersAnalysis.length,
    ttl_distribution: ttlDistribution,
    users: usersAnalysis
  }
}

// 生成缓存命中分析数据
function generateCacheHitAnalysisData(hours: number = 168) {
  const totalRequests = 5000 + Math.floor(Math.random() * 10000)
  const requestsWithCacheHit = Math.floor(totalRequests * (0.25 + Math.random() * 0.35))
  const totalInputTokens = totalRequests * (2000 + Math.floor(Math.random() * 3000))
  const totalCacheReadTokens = Math.floor(totalInputTokens * (0.15 + Math.random() * 0.25))
  const totalCacheCreationTokens = Math.floor(totalInputTokens * (0.05 + Math.random() * 0.1))

  // 缓存读取成本：按每百万 token $0.30 计算
  const cacheReadCostPer1M = 0.30
  const cacheCreationCostPer1M = 3.75
  const totalCacheReadCost = (totalCacheReadTokens / 1000000) * cacheReadCostPer1M
  const totalCacheCreationCost = (totalCacheCreationTokens / 1000000) * cacheCreationCostPer1M

  // 缓存读取节省了 90% 的成本
  const estimatedSavings = totalCacheReadCost * 9

  const tokenCacheHitRate = totalCacheReadTokens / (totalInputTokens + totalCacheReadTokens) * 100

  return {
    analysis_period_hours: hours,
    total_requests: totalRequests,
    requests_with_cache_hit: requestsWithCacheHit,
    request_cache_hit_rate: Math.round(requestsWithCacheHit / totalRequests * 10000) / 100,
    total_input_tokens: totalInputTokens,
    total_cache_read_tokens: totalCacheReadTokens,
    total_cache_creation_tokens: totalCacheCreationTokens,
    token_cache_hit_rate: Math.round(tokenCacheHitRate * 100) / 100,
    total_cache_read_cost_usd: Math.round(totalCacheReadCost * 10000) / 10000,
    total_cache_creation_cost_usd: Math.round(totalCacheCreationCost * 10000) / 10000,
    estimated_savings_usd: Math.round(estimatedSavings * 10000) / 10000
  }
}

// TTL 分析接口
mockHandlers['GET /api/admin/usage/cache-affinity/ttl-analysis'] = async (config) => {
  await delay()
  requireAdmin()
  const params = config.params || {}
  const hours = parseInt(params.hours) || 168
  const data = generateTTLAnalysisData(hours)
  return createMockResponse(data)
}

// 缓存命中分析接口
mockHandlers['GET /api/admin/usage/cache-affinity/hit-analysis'] = async (config) => {
  await delay()
  requireAdmin()
  const params = config.params || {}
  const hours = parseInt(params.hours) || 168
  const data = generateCacheHitAnalysisData(hours)
  return createMockResponse(data)
}