const express = require('express');
const WebSocket = require('ws');
const http = require('http');
const { EventEmitter } = require('events');
const fs = require('fs');
const path = require('path');
const { firefox } = require('playwright');
const os = require('os');


// ===================================================================================
// 认证源管理模块 (已升级以支持动态管理)
// ===================================================================================

class AuthSource {
  constructor(logger) {
    this.logger = logger;
    this.authMode = 'file'; // 默认模式
    this.initialIndices = []; // 启动时发现的索引
    this.runtimeAuths = new Map(); // 用于动态添加的账号

    if (process.env.AUTH_JSON_1) {
      this.authMode = 'env';
      this.logger.info('[认证] 检测到 AUTH_JSON_1 环境变量，切换到环境变量认证模式。');
    } else {
      this.logger.info('[认证] 未检测到环境变量认证，将使用 "auth/" 目录下的文件。');
    }

    this._discoverAvailableIndices();

    if (this.getAvailableIndices().length === 0) {
      this.logger.error(`[认证] 致命错误：在 '${this.authMode}' 模式下未找到任何有效的认证源。`);
      throw new Error("未找到有效的认证源。");
    }
  }

  _discoverAvailableIndices() {
    let indices = [];
    if (this.authMode === 'env') {
      const regex = /^AUTH_JSON_(\d+)$/;
      for (const key in process.env) {
        const match = key.match(regex);
        // 修正：正确解析捕获组 (match[1]) 而不是整个匹配对象
        if (match && match[1]) {
          indices.push(parseInt(match[1], 10));
        }
      }
    } else { // 'file' 模式
      const authDir = path.join(__dirname, 'auth');
      if (!fs.existsSync(authDir)) {
        this.logger.warn('[认证] "auth/" 目录不存在。');
        this.initialIndices = [];
        return;
      }
      try {
        const files = fs.readdirSync(authDir);
        const authFiles = files.filter(file => /^auth-\d+\.json$/.test(file));
        // 修正：正确解析文件名中的捕获组 (match[1])
        indices = authFiles.map(file => {
          const match = file.match(/^auth-(\d+)\.json$/);
          return parseInt(match[1], 10);
        });
      } catch (error) {
        this.logger.error(`[认证] 扫描 "auth/" 目录失败: ${error.message}`);
        this.initialIndices = [];
        return;
      }
    }
    this.initialIndices = [...new Set(indices)].sort((a, b) => a - b);
    this.logger.info(`[认证] 在 '${this.authMode}' 模式下，检测到 ${this.initialIndices.length} 个认证源。`);
    if (this.initialIndices.length > 0) {
      this.logger.info(`[认证] 可用初始索引: [${this.initialIndices.join(', ')}]`);
    }
  }

  getAvailableIndices() {
    const runtimeIndices = Array.from(this.runtimeAuths.keys());
    const allIndices = [...new Set([...this.initialIndices, ...runtimeIndices])].sort((a, b) => a - b);
    return allIndices;
  }

  // 新增方法：为仪表盘获取详细信息
  getAccountDetails() {
    const allIndices = this.getAvailableIndices();
    return allIndices.map(index => ({
      index,
      source: this.runtimeAuths.has(index) ? 'temporary' : this.authMode
    }));
  }


  getFirstAvailableIndex() {
    const indices = this.getAvailableIndices();
    return indices.length > 0 ? indices[0] : null;
  }

  getAuth(index) {
    if (!this.getAvailableIndices().includes(index)) {
      this.logger.error(`[认证] 请求了无效或不存在的认证索引: ${index}`);
      return null;
    }

    // 优先使用运行时（临时）的认证信息
    if (this.runtimeAuths.has(index)) {
      this.logger.info(`[认证] 使用索引 ${index} 的临时认证源。`);
      return this.runtimeAuths.get(index);
    }

    let jsonString;
    let sourceDescription;

    if (this.authMode === 'env') {
      jsonString = process.env[`AUTH_JSON_${index}`];
      sourceDescription = `环境变量 AUTH_JSON_${index}`;
    } else {
      const authFilePath = path.join(__dirname, 'auth', `auth-${index}.json`);
      sourceDescription = `文件 ${authFilePath}`;
      if (!fs.existsSync(authFilePath)) {
        this.logger.error(`[认证] ${sourceDescription} 在读取时突然消失。`);
        return null;
      }
      try {
        jsonString = fs.readFileSync(authFilePath, 'utf-8');
      } catch (e) {
        this.logger.error(`[认证] 读取 ${sourceDescription} 失败: ${e.message}`);
        return null;
      }
    }

    try {
      return JSON.parse(jsonString);
    } catch (e) {
      this.logger.error(`[认证] 解析来自 ${sourceDescription} 的JSON内容失败: ${e.message}`);
      return null;
    }
  }

  // 新增方法：动态添加账号
  addAccount(index, authData) {
    if (typeof index !== 'number' || index <= 0) {
      return { success: false, message: "索引必须是一个正数。" };
    }
    if (this.initialIndices.includes(index)) {
      return { success: false, message: `索引 ${index} 已作为永久账号存在。` };
    }
    try {
      // 验证 authData 是否为有效的JSON对象
      if (typeof authData !== 'object' || authData === null) {
        throw new Error("提供的数据不是一个有效的对象。");
      }
      this.runtimeAuths.set(index, authData);
      this.logger.info(`[认证] 成功添加索引为 ${index} 的临时账号。`);
      return { success: true, message: `账号 ${index} 已临时添加。` };
    } catch (e) {
      this.logger.error(`[认证] 添加临时账号 ${index} 失败: ${e.message}`);
      return { success: false, message: `添加账号失败: ${e.message}` };
    }
  }

  // 新增方法：动态删除账号
  removeAccount(index) {
    if (!this.runtimeAuths.has(index)) {
      return { success: false, message: `索引 ${index} 不是一个临时账号，无法移除。` };
    }
    this.runtimeAuths.delete(index);
    this.logger.info(`[认证] 成功移除索引为 ${index} 的临时账号。`);
    return { success: true, message: `账号 ${index} 已移除。` };
  }
}


// ===================================================================================
// 浏览器管理模块
// ===================================================================================

class BrowserManager {
  constructor(logger, config, authSource) {
    this.logger = logger;
    this.config = config;
    this.authSource = authSource;
    this.browser = null;
    this.context = null;
    this.page = null;
    this.currentAuthIndex = 0;
    this.scriptFileName = 'dark-browser.js';

    if (this.config.browserExecutablePath) {
      this.browserExecutablePath = this.config.browserExecutablePath;
      this.logger.info(`[系统] 使用环境变量 CAMOUFOX_EXECUTABLE_PATH 指定的浏览器路径。`);
    } else {
      const platform = os.platform();
      if (platform === 'win32') {
        this.browserExecutablePath = path.join(__dirname, 'camoufox', 'camoufox.exe');
        this.logger.info(`[系统] 检测到操作系统: Windows. 将使用 'camoufox' 目录下的浏览器。`);
      } else if (platform === 'linux') {
        this.browserExecutablePath = path.join(__dirname, 'camoufox-linux', 'camoufox');
        this.logger.info(`[系统] 检测到操作系统: Linux. 将使用 'camoufox-linux' 目录下的浏览器。`);
      } else {
        this.logger.error(`[系统] 不支持的操作系统: ${platform}.`);
        throw new Error(`不支持的操作系统: ${platform}`);
      }
    }
  }

  async launchBrowser(authIndex) {
    if (this.browser) {
      this.logger.warn('尝试启动一个已在运行的浏览器实例，操作已取消。');
      return;
    }

    const sourceDescription = this.authSource.authMode === 'env' ? `环境变量 AUTH_JSON_${authIndex}` : `文件 auth-${authIndex}.json`;
    this.logger.info('==================================================');
    this.logger.info(`🚀 [浏览器] 准备启动浏览器`);
    this.logger.info(`   • 认证源: ${sourceDescription}`);
    this.logger.info(`   • 浏览器路径: ${this.browserExecutablePath}`);
    this.logger.info('==================================================');

    if (!fs.existsSync(this.browserExecutablePath)) {
      this.logger.error(`❌ [浏览器] 找不到浏览器可执行文件: ${this.browserExecutablePath}`);
      throw new Error(`找不到浏览器可执行文件路径: ${this.browserExecutablePath}`);
    }

    const storageStateObject = this.authSource.getAuth(authIndex);
    if (!storageStateObject) {
      this.logger.error(`❌ [浏览器] 无法获取或解析索引为 ${authIndex} 的认证信息。`);
      throw new Error(`获取或解析索引 ${authIndex} 的认证源失败。`);
    }

    if (storageStateObject.cookies && Array.isArray(storageStateObject.cookies)) {
      let fixedCount = 0;
      const validSameSiteValues = ['Lax', 'Strict', 'None'];
      storageStateObject.cookies.forEach(cookie => {
        if (!validSameSiteValues.includes(cookie.sameSite)) {
          this.logger.warn(`[认证] 发现无效的 sameSite 值: '${cookie.sameSite}'，正在自动修正为 'None'。`);
          cookie.sameSite = 'None';
          fixedCount++;
        }
      });
      if (fixedCount > 0) {
        this.logger.info(`[认证] 自动修正了 ${fixedCount} 个无效的 Cookie 'sameSite' 属性。`);
      }
    }

    let buildScriptContent;
    try {
      const scriptFilePath = path.join(__dirname, this.scriptFileName);
      if (fs.existsSync(scriptFilePath)) {
        buildScriptContent = fs.readFileSync(scriptFilePath, 'utf-8');
        this.logger.info(`✅ [浏览器] 成功读取注入脚本 "${this.scriptFileName}"`);
      } else {
        this.logger.warn(`[浏览器] 未找到注入脚本 "${this.scriptFileName}"。将无注入继续运行。`);
        buildScriptContent = "console.log('dark-browser.js not found, running without injection.');";
      }
    } catch (error) {
      this.logger.error(`❌ [浏览器] 无法读取注入脚本 "${this.scriptFileName}"！`);
      throw error;
    }

    try {
      this.browser = await firefox.launch({
        headless: true,
        executablePath: this.browserExecutablePath,
      });
      this.browser.on('disconnected', () => {
        this.logger.error('❌ [浏览器] 浏览器意外断开连接！服务器可能需要重启。');
        this.browser = null; this.context = null; this.page = null;
      });
      this.context = await this.browser.newContext({
        storageState: storageStateObject,
        viewport: { width: 1280, height: 720 },
      });
      this.page = await this.context.newPage();
      this.logger.info(`[浏览器] 正在加载账号 ${authIndex} 并访问目标网页...`);
      const targetUrl = 'https://aistudio.google.com/u/0/apps/bundled/blank?showPreview=true&showCode=true&showAssistant=true';
      await this.page.goto(targetUrl, { timeout: 120000, waitUntil: 'networkidle' });
      this.logger.info('[浏览器] 网页加载完成，正在注入客户端脚本...');

      const editorContainerLocator = this.page.locator('div.monaco-editor').first();

      this.logger.info('[浏览器] 等待编辑器出现，最长120秒...');
      await editorContainerLocator.waitFor({ state: 'visible', timeout: 120000 });
      this.logger.info('[浏览器] 编辑器已出现，准备粘贴脚本。');

      this.logger.info('[浏览器] 等待5秒，之后将在页面下方执行一次模拟点击以确保页面激活...');
      await this.page.waitForTimeout(5000);

      const viewport = this.page.viewportSize();
      if (viewport) {
        const clickX = viewport.width / 2;
        const clickY = viewport.height - 120;
        this.logger.info(`[浏览器] 在页面底部中心位置 (x≈${Math.round(clickX)}, y=${clickY}) 执行点击。`);
        await this.page.mouse.click(clickX, clickY);
      } else {
        this.logger.warn('[浏览器] 无法获取视窗大小，跳过页面底部模拟点击。');
      }

      await editorContainerLocator.click({ timeout: 120000 });
      await this.page.evaluate(text => navigator.clipboard.writeText(text), buildScriptContent);
      const isMac = os.platform() === 'darwin';
      const pasteKey = isMac ? 'Meta+V' : 'Control+V';
      await this.page.keyboard.press(pasteKey);
      this.logger.info('[浏览器] 脚本已粘贴。浏览器端初始化完成。');


      this.currentAuthIndex = authIndex;
      this.logger.info('==================================================');
      this.logger.info(`✅ [浏览器] 账号 ${authIndex} 初始化成功！`);
      this.logger.info('✅ [浏览器] 浏览器客户端已准备就绪。');
      this.logger.info('==================================================');
    } catch (error) {
      this.logger.error(`❌ [浏览器] 账号 ${authIndex} 初始化失败: ${error.message}`);
      if (this.browser) {
        await this.browser.close();
        this.browser = null;
      }
      throw error;
    }
  }

  async closeBrowser() {
    if (this.browser) {
      this.logger.info('[浏览器] 正在关闭当前浏览器实例...');
      await this.browser.close();
      this.browser = null; this.context = null; this.page = null;
      this.logger.info('[浏览器] 浏览器已关闭。');
    }
  }

  async switchAccount(newAuthIndex) {
    this.logger.info(`🔄 [浏览器] 开始账号切换: 从 ${this.currentAuthIndex} 到 ${newAuthIndex}`);
    await this.closeBrowser();
    await this.launchBrowser(newAuthIndex);
    this.logger.info(`✅ [浏览器] 账号切换完成，当前账号: ${this.currentAuthIndex}`);
  }
}

// ===================================================================================
// 代理服务模块
// ===================================================================================

class LoggingService {
  constructor(serviceName = 'ProxyServer') {
    this.serviceName = serviceName;
  }

  _getFormattedTime() {
    // 使用 toLocaleTimeString 并指定 en-GB 区域来保证输出为 HH:mm:ss 格式
    return new Date().toLocaleTimeString('en-GB', { hour12: false });
  }

  // 用于 ERROR, WARN, DEBUG 等带有级别标签的日志
  _formatMessage(level, message) {
    const time = this._getFormattedTime();
    return `[${level}] ${time} [${this.serviceName}] - ${message}`;
  }

  // info 级别使用特殊格式，不显示 [INFO]
  info(message) {
    const time = this._getFormattedTime();
    console.log(`${time} [${this.serviceName}] - ${message}`);
  }

  error(message) {
    console.error(this._formatMessage('ERROR', message));
  }

  warn(message) {
    console.warn(this._formatMessage('WARN', message));
  }

  debug(message) {
    if (process.env.DEBUG_MODE === 'true') {
      console.debug(this._formatMessage('DEBUG', message));
    }
  }
}

class MessageQueue extends EventEmitter {
  constructor(timeoutMs = 1200000) {
    super();
    this.messages = [];
    this.waitingResolvers = [];
    this.defaultTimeout = timeoutMs;
    this.closed = false;
  }
  enqueue(message) {
    if (this.closed) return;
    if (this.waitingResolvers.length > 0) {
      const resolver = this.waitingResolvers.shift();
      resolver.resolve(message);
    } else {
      this.messages.push(message);
    }
  }
  async dequeue(timeoutMs = this.defaultTimeout) {
    if (this.closed) {
      throw new Error('队列已关闭');
    }
    return new Promise((resolve, reject) => {
      if (this.messages.length > 0) {
        resolve(this.messages.shift());
        return;
      }
      const resolver = { resolve, reject };
      this.waitingResolvers.push(resolver);
      const timeoutId = setTimeout(() => {
        const index = this.waitingResolvers.indexOf(resolver);
        if (index !== -1) {
          this.waitingResolvers.splice(index, 1);
          reject(new Error('队列超时'));
        }
      }, timeoutMs);
      resolver.timeoutId = timeoutId;
    });
  }
  close() {
    this.closed = true;
    this.waitingResolvers.forEach(resolver => {
      clearTimeout(resolver.timeoutId);
      resolver.reject(new Error('队列已关闭'));
    });
    this.waitingResolvers = [];
    this.messages = [];
  }
}

class ConnectionRegistry extends EventEmitter {
  constructor(logger) {
    super();
    this.logger = logger;
    this.connections = new Set();
    this.messageQueues = new Map();
  }
  addConnection(websocket, clientInfo) {
    this.connections.add(websocket);
    this.logger.info(`[服务器] 内部WebSocket客户端已连接 (来自: ${clientInfo.address})`);
    websocket.on('message', (data) => this._handleIncomingMessage(data.toString()));
    websocket.on('close', () => this._removeConnection(websocket));
    websocket.on('error', (error) => this.logger.error(`[服务器] 内部WebSocket连接错误: ${error.message}`));
    this.emit('connectionAdded', websocket);
  }
  _removeConnection(websocket) {
    this.connections.delete(websocket);
    this.logger.warn('[服务器] 内部WebSocket客户端连接断开');
    this.messageQueues.forEach(queue => queue.close());
    this.messageQueues.clear();
    this.emit('connectionRemoved', websocket);
  }
  _handleIncomingMessage(messageData) {
    try {
      const parsedMessage = JSON.parse(messageData);
      const requestId = parsedMessage.request_id;
      if (!requestId) {
        this.logger.warn('[服务器] 收到无效消息：缺少request_id');
        return;
      }
      const queue = this.messageQueues.get(requestId);
      if (queue) {
        this._routeMessage(parsedMessage, queue);
      }
    } catch (error) {
      this.logger.error('[服务器] 解析内部WebSocket消息失败');
    }
  }
  _routeMessage(message, queue) {
    const { event_type } = message;
    switch (event_type) {
      case 'response_headers': case 'chunk': case 'error':
        queue.enqueue(message);
        break;
      case 'stream_close':
        queue.enqueue({ type: 'STREAM_END' });
        break;
      default:
        this.logger.warn(`[服务器] 未知的内部事件类型: ${event_type}`);
    }
  }
  hasActiveConnections() { return this.connections.size > 0; }
  getFirstConnection() { return this.connections.values().next().value; }
  createMessageQueue(requestId) {
    const queue = new MessageQueue();
    this.messageQueues.set(requestId, queue);
    return queue;
  }
  removeMessageQueue(requestId) {
    const queue = this.messageQueues.get(requestId);
    if (queue) {
      queue.close();
      this.messageQueues.delete(requestId);
    }
  }
}

class RequestHandler {
  constructor(serverSystem, connectionRegistry, logger, browserManager, config, authSource) {
    this.serverSystem = serverSystem;
    this.connectionRegistry = connectionRegistry;
    this.logger = logger;
    this.browserManager = browserManager;
    this.config = config;
    this.authSource = authSource;
    this.maxRetries = this.config.maxRetries;
    this.retryDelay = this.config.retryDelay;
    this.failureCount = 0;
    this.isAuthSwitching = false;
  }

  get currentAuthIndex() {
    return this.browserManager.currentAuthIndex;
  }

  _getNextAuthIndex() {
    const available = this.authSource.getAvailableIndices();
    if (available.length === 0) return null;
    if (available.length === 1) return available[0];

    const currentIndexInArray = available.indexOf(this.currentAuthIndex);

    if (currentIndexInArray === -1) {
      this.logger.warn(`[认证] 当前索引 ${this.currentAuthIndex} 不在可用列表中，将切换到第一个可用索引。`);
      return available[0];
    }

    const nextIndexInArray = (currentIndexInArray + 1) % available.length;
    return available[nextIndexInArray];
  }

  async _switchToNextAuth() {
    if (this.isAuthSwitching) {
      this.logger.info('🔄 [认证] 正在切换账号，跳过重复切换');
      return;
    }

    this.isAuthSwitching = true;
    const nextAuthIndex = this._getNextAuthIndex();
    const totalAuthCount = this.authSource.getAvailableIndices().length;

    if (nextAuthIndex === null) {
      this.logger.error('🔴 [认证] 无法切换账号，因为没有可用的认证源！');
      this.isAuthSwitching = false;
      throw new Error('没有可用的认证源可以切换。');
    }

    this.logger.info('==================================================');
    this.logger.info(`🔄 [认证] 开始账号切换流程`);
    this.logger.info(`   • 失败次数: ${this.failureCount}/${this.config.failureThreshold > 0 ? this.config.failureThreshold : 'N/A'}`);
    this.logger.info(`   • 当前账号索引: ${this.currentAuthIndex}`);
    this.logger.info(`   • 目标账号索引: ${nextAuthIndex}`);
    this.logger.info(`   • 可用账号总数: ${totalAuthCount}`);
    this.logger.info('==================================================');

    try {
      await this.browserManager.switchAccount(nextAuthIndex);
      this.failureCount = 0;
      this.logger.info('==================================================');
      this.logger.info(`✅ [认证] 成功切换到账号索引 ${this.currentAuthIndex}`);
      this.logger.info(`✅ [认证] 失败计数已重置为0`);
      this.logger.info('==================================================');
    } catch (error) {
      this.logger.error('==================================================');
      this.logger.error(`❌ [认证] 切换账号失败: ${error.message}`);
      this.logger.error('==================================================');
      throw error;
    } finally {
      this.isAuthSwitching = false;
    }
  }

  _parseAndCorrectErrorDetails(errorDetails) {
    const correctedDetails = { ...errorDetails };
    this.logger.debug(`[错误解析器] 原始错误详情: status=${correctedDetails.status}, message="${correctedDetails.message}"`);

    if (correctedDetails.message && typeof correctedDetails.message === 'string') {
      const regex = /(?:HTTP|status code)\s+(\d{3})/;
      const match = correctedDetails.message.match(regex);

      if (match && match[1]) {
        const parsedStatus = parseInt(match[1], 10);
        if (parsedStatus >= 400 && parsedStatus <= 599) {
          if (correctedDetails.status !== parsedStatus) {
            this.logger.warn(`[错误解析器] 修正了错误状态码！原始: ${correctedDetails.status}, 从消息中解析得到: ${parsedStatus}`);
            correctedDetails.status = parsedStatus;
          } else {
            this.logger.debug(`[错误解析器] 解析的状态码 (${parsedStatus}) 与原始状态码一致，无需修正。`);
          }
        }
      }
    }
    return correctedDetails;
  }

  async _handleRequestFailureAndSwitch(errorDetails, res) {
    const correctedDetails = { ...errorDetails };
    if (correctedDetails.message && typeof correctedDetails.message === 'string') {
      const regex = /(?:HTTP|status code)\s*(\d{3})|"code"\s*:\s*(\d{3})/;
      const match = correctedDetails.message.match(regex);
      const parsedStatusString = match ? (match[1] || match[2]) : null;

      if (parsedStatusString) {
        const parsedStatus = parseInt(parsedStatusString, 10);
        if (parsedStatus >= 400 && parsedStatus <= 599 && correctedDetails.status !== parsedStatus) {
          this.logger.warn(`[认证] 修正了错误状态码！原始: ${correctedDetails.status}, 从消息中解析得到: ${parsedStatus}`);
          correctedDetails.status = parsedStatus;
        }
      }
    }

    const isImmediateSwitch = this.config.immediateSwitchStatusCodes.includes(correctedDetails.status);

    if (isImmediateSwitch) {
      this.logger.warn(`🔴 [认证] 收到状态码 ${correctedDetails.status} (已修正)，触发立即切换账号...`);
      if (res) this._sendErrorChunkToClient(res, `收到状态码 ${correctedDetails.status}，正在尝试切换账号...`);
      try {
        await this._switchToNextAuth();
        if (res) this._sendErrorChunkToClient(res, `已切换到账号索引 ${this.currentAuthIndex}，请重试`);
      } catch (switchError) {
        this.logger.error(`🔴 [认证] 账号切换失败: ${switchError.message}`);
        if (res) this._sendErrorChunkToClient(res, `切换账号失败: ${switchError.message}`);
      }
      return;
    }

    if (this.config.failureThreshold > 0) {
      this.failureCount++;
      this.logger.warn(`⚠️ [认证] 请求失败 - 失败计数: ${this.failureCount}/${this.config.failureThreshold} (当前账号索引: ${this.currentAuthIndex}, 状态码: ${correctedDetails.status})`);
      if (this.failureCount >= this.config.failureThreshold) {
        this.logger.warn(`🔴 [认证] 达到失败阈值！准备切换账号...`);
        if (res) this._sendErrorChunkToClient(res, `连续失败${this.failureCount}次，正在尝试切换账号...`);
        try {
          await this._switchToNextAuth();
          if (res) this._sendErrorChunkToClient(res, `已切换到账号索引 ${this.currentAuthIndex}，请重试`);
        } catch (switchError) {
          this.logger.error(`🔴 [认证] 账号切换失败: ${switchError.message}`);
          if (res) this._sendErrorChunkToClient(res, `切换账号失败: ${switchError.message}`);
        }
      }
    } else {
      this.logger.warn(`[认证] 请求失败 (状态码: ${correctedDetails.status})。基于计数的自动切换已禁用 (failureThreshold=0)`);
    }
  }

  _getModelFromRequest(req) {
    let body = req.body;

    if (Buffer.isBuffer(body)) {
      try {
        body = JSON.parse(body.toString('utf-8'));
      } catch (e) { body = {}; }
    } else if (typeof body === 'string') {
      try {
        body = JSON.parse(body);
      } catch (e) { body = {}; }
    }

    if (body && typeof body === 'object') {
      if (body.model) return body.model;
      if (body.generation_config && body.generation_config.model) return body.generation_config.model;
    }

    const match = req.path.match(/\/models\/([^/:]+)/);
    if (match && match[1]) {
      return match[1];
    }
    return 'unknown_model';
  }

  async processRequest(req, res) {
    // 提前获取模型名称和当前账号
    const modelName = this._getModelFromRequest(req);
    const currentAccount = this.currentAuthIndex;

    // 新增的合并日志行，报告路径、账号和模型
    this.logger.info(`[请求] ${req.method} ${req.path} | 账号: ${currentAccount} | 模型: 🤖 ${modelName}`);

    // --- 升级的统计逻辑 ---
    this.serverSystem.stats.totalCalls++;
    if (this.serverSystem.stats.accountCalls[currentAccount]) {
      this.serverSystem.stats.accountCalls[currentAccount].total = (this.serverSystem.stats.accountCalls[currentAccount].total || 0) + 1;
      this.serverSystem.stats.accountCalls[currentAccount].models[modelName] = (this.serverSystem.stats.accountCalls[currentAccount].models[modelName] || 0) + 1;
    } else {
      this.serverSystem.stats.accountCalls[currentAccount] = {
        total: 1,
        models: { [modelName]: 1 }
      };
    }

    if (!this.connectionRegistry.hasActiveConnections()) {
      return this._sendErrorResponse(res, 503, '没有可用的浏览器连接');
    }
    const requestId = this._generateRequestId();
    const proxyRequest = this._buildProxyRequest(req, requestId);
    const messageQueue = this.connectionRegistry.createMessageQueue(requestId);
    try {
      if (this.serverSystem.streamingMode === 'fake') {
        await this._handlePseudoStreamResponse(proxyRequest, messageQueue, req, res);
      } else {
        await this._handleRealStreamResponse(proxyRequest, messageQueue, res);
      }
    } catch (error) {
      this._handleRequestError(error, res);
    } finally {
      this.connectionRegistry.removeMessageQueue(requestId);
    }
  }
  _generateRequestId() { return `${Date.now()}_${Math.random().toString(36).substring(2, 11)}`; }
  _buildProxyRequest(req, requestId) {
    let requestBodyString;
    if (typeof req.body === 'object' && req.body !== null) {
      requestBodyString = JSON.stringify(req.body);
    } else if (typeof req.body === 'string') {
      requestBodyString = req.body;
    } else if (Buffer.isBuffer(req.body)) {
      requestBodyString = req.body.toString('utf-8');
    } else {
      requestBodyString = '';
    }

    return {
      path: req.path, method: req.method, headers: req.headers, query_params: req.query,
      body: requestBodyString,
      request_id: requestId, streaming_mode: this.serverSystem.streamingMode
    };
  }
  _forwardRequest(proxyRequest) {
    const connection = this.connectionRegistry.getFirstConnection();
    if (connection) {
      connection.send(JSON.stringify(proxyRequest));
    } else {
      throw new Error("无法转发请求：没有可用的WebSocket连接。");
    }
  }
  _sendErrorChunkToClient(res, errorMessage) {
    const errorPayload = {
      error: { message: `[代理系统提示] ${errorMessage}`, type: 'proxy_error', code: 'proxy_error' }
    };
    const chunk = `data: ${JSON.stringify(errorPayload)}\n\n`;
    if (res && !res.writableEnded) {
      res.write(chunk);
      this.logger.info(`[请求] 已向客户端发送标准错误信号: ${errorMessage}`);
    }
  }

  _getKeepAliveChunk(req) {
    if (req.path.includes('chat/completions')) {
      const payload = { id: `chatcmpl-${this._generateRequestId()}`, object: "chat.completion.chunk", created: Math.floor(Date.now() / 1000), model: "gpt-4", choices: [{ index: 0, delta: {}, finish_reason: null }] };
      return `data: ${JSON.stringify(payload)}\n\n`;
    }
    if (req.path.includes('generateContent') || req.path.includes('streamGenerateContent')) {
      const payload = { candidates: [{ content: { parts: [{ text: "" }], role: "model" }, finishReason: null, index: 0, safetyRatings: [] }] };
      return `data: ${JSON.stringify(payload)}\n\n`;
    }
    return 'data: {}\n\n';
  }

  async _handlePseudoStreamResponse(proxyRequest, messageQueue, req, res) {
    const originalPath = req.path;
    const isStreamRequest = originalPath.includes(':stream');

    this.logger.info(`[请求] 假流式处理流程启动，路径: "${originalPath}"，判定为: ${isStreamRequest ? '流式请求' : '非流式请求'}`);

    let connectionMaintainer = null;

    if (isStreamRequest) {
      res.status(200).set({
        'Content-Type': 'text/event-stream',
        'Cache-Control': 'no-cache',
        'Connection': 'keep-alive'
      });
      const keepAliveChunk = this._getKeepAliveChunk(req);
      connectionMaintainer = setInterval(() => { if (!res.writableEnded) res.write(keepAliveChunk); }, 2000);
    }

    try {
      let lastMessage, requestFailed = false;
      for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
        this.logger.info(`[请求] 请求尝试 #${attempt}/${this.maxRetries}...`);
        this._forwardRequest(proxyRequest);
        lastMessage = await messageQueue.dequeue();

        if (lastMessage.event_type === 'error' && lastMessage.status >= 400 && lastMessage.status <= 599) {
          const correctedMessage = this._parseAndCorrectErrorDetails(lastMessage);
          await this._handleRequestFailureAndSwitch(correctedMessage, isStreamRequest ? res : null);

          const errorText = `收到 ${correctedMessage.status} 错误。${attempt < this.maxRetries ? `将在 ${this.retryDelay / 1000}秒后重试...` : '已达到最大重试次数。'}`;
          this.logger.warn(`[请求] ${errorText}`);

          if (isStreamRequest) {
            this._sendErrorChunkToClient(res, errorText);
          }

          if (attempt < this.maxRetries) {
            await new Promise(resolve => setTimeout(resolve, this.retryDelay));
            continue;
          }
          requestFailed = true;
        }
        break;
      }

      if (lastMessage.event_type === 'error' || requestFailed) {
        const finalError = this._parseAndCorrectErrorDetails(lastMessage);
        if (!res.headersSent) {
          this._sendErrorResponse(res, finalError.status, `请求失败: ${finalError.message}`);
        } else {
          this._sendErrorChunkToClient(res, `请求最终失败 (状态码: ${finalError.status}): ${finalError.message}`);
        }
        return;
      }

      if (this.failureCount > 0) {
        this.logger.info(`✅ [认证] 请求成功 - 失败计数已从 ${this.failureCount} 重置为 0`);
      }
      this.failureCount = 0;

      const dataMessage = await messageQueue.dequeue();
      const endMessage = await messageQueue.dequeue();
      if (endMessage.type !== 'STREAM_END') this.logger.warn('[请求] 未收到预期的流结束信号。');

      if (isStreamRequest) {
        if (dataMessage.data) {
          res.write(`data: ${dataMessage.data}\n\n`);
        }
        res.write('data: [DONE]\n\n');
        this.logger.info('[请求] 已将完整响应作为模拟SSE事件发送。');
      } else {
        this.logger.info('[请求] 准备发送 application/json 响应。');
        if (dataMessage.data) {
          try {
            const jsonData = JSON.parse(dataMessage.data);
            res.status(200).json(jsonData);
          } catch (e) {
            this.logger.error(`[请求] 无法将来自浏览器的响应解析为JSON: ${e.message}`);
            this._sendErrorResponse(res, 500, '代理内部错误：无法解析来自后端的响应。');
          }
        } else {
          this._sendErrorResponse(res, 500, '代理内部错误：后端未返回有效数据。');
        }
      }

    } catch (error) {
      this.logger.error(`[请求] 假流式处理期间发生意外错误: ${error.message}`);
      if (!res.headersSent) {
        this._handleRequestError(error, res);
      } else {
        this._sendErrorChunkToClient(res, `处理失败: ${error.message}`);
      }
    } finally {
      if (connectionMaintainer) clearInterval(connectionMaintainer);
      if (!res.writableEnded) res.end();
      this.logger.info('[请求] 假流式响应处理结束。');
    }
  }

  async _handleRealStreamResponse(proxyRequest, messageQueue, res) {
    let headerMessage, requestFailed = false;
    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
      this.logger.info(`[请求] 请求尝试 #${attempt}/${this.maxRetries}...`);
      this._forwardRequest(proxyRequest);
      headerMessage = await messageQueue.dequeue();
      if (headerMessage.event_type === 'error' && headerMessage.status >= 400 && headerMessage.status <= 599) {

        const correctedMessage = this._parseAndCorrectErrorDetails(headerMessage);
        await this._handleRequestFailureAndSwitch(correctedMessage, null);
        this.logger.warn(`[请求] 收到 ${correctedMessage.status} 错误，将在 ${this.retryDelay / 1000}秒后重试...`);

        if (attempt < this.maxRetries) {
          await new Promise(resolve => setTimeout(resolve, this.retryDelay));
          continue;
        }
        requestFailed = true;
      }
      break;
    }
    if (headerMessage.event_type === 'error' || requestFailed) {
      const finalError = this._parseAndCorrectErrorDetails(headerMessage);
      return this._sendErrorResponse(res, finalError.status, finalError.message);
    }
    if (this.failureCount > 0) {
      this.logger.info(`✅ [认证] 请求成功 - 失败计数已从 ${this.failureCount} 重置为 0`);
    }
    this.failureCount = 0;
    this._setResponseHeaders(res, headerMessage);
    this.logger.info('[请求] 已向客户端发送真实响应头，开始流式传输...');
    try {
      while (true) {
        const dataMessage = await messageQueue.dequeue(30000);
        if (dataMessage.type === 'STREAM_END') { this.logger.info('[请求] 收到流结束信号。'); break; }
        if (dataMessage.data) res.write(dataMessage.data);
      }
    } catch (error) {
      if (error.message !== '队列超时') throw error;
      this.logger.warn('[请求] 真流式响应超时，可能流已正常结束。');
    } finally {
      if (!res.writableEnded) res.end();
      this.logger.info('[请求] 真流式响应连接已关闭。');
    }
  }

  _setResponseHeaders(res, headerMessage) {
    res.status(headerMessage.status || 200);
    const headers = headerMessage.headers || {};
    Object.entries(headers).forEach(([name, value]) => {
      if (name.toLowerCase() !== 'content-length') res.set(name, value);
    });
  }
  _handleRequestError(error, res) {
    if (res.headersSent) {
      this.logger.error(`[请求] 请求处理错误 (头已发送): ${error.message}`);
      if (this.serverSystem.streamingMode === 'fake') this._sendErrorChunkToClient(res, `处理失败: ${error.message}`);
      if (!res.writableEnded) res.end();
    } else {
      this.logger.error(`[请求] 请求处理错误: ${error.message}`);
      const status = error.message.includes('超时') ? 504 : 500;
      this._sendErrorResponse(res, status, `代理错误: ${error.message}`);
    }
  }
  _sendErrorResponse(res, status, message) {
    if (!res.headersSent) res.status(status || 500).type('text/plain').send(message);
  }
}

class ProxyServerSystem extends EventEmitter {
  constructor() {
    super();
    this.logger = new LoggingService('ProxySystem');
    this._loadConfiguration();
    this.streamingMode = this.config.streamingMode;

    // 升级后的统计结构
    this.stats = {
      totalCalls: 0,
      accountCalls: {} // e.g., { "1": { total: 10, models: { "gemini-pro": 5, "gpt-4": 5 } } }
    };

    this.authSource = new AuthSource(this.logger);
    this.browserManager = new BrowserManager(this.logger, this.config, this.authSource);
    this.connectionRegistry = new ConnectionRegistry(this.logger);
    this.requestHandler = new RequestHandler(this, this.connectionRegistry, this.logger, this.browserManager, this.config, this.authSource);

    this.httpServer = null;
    this.wsServer = null;
  }

  _loadConfiguration() {
    let config = {
      httpPort: 8889, host: '0.0.0.0', wsPort: 9998, streamingMode: 'real',
      failureThreshold: 0,
      maxRetries: 3, retryDelay: 2000, browserExecutablePath: null,
      apiKeys: [],
      immediateSwitchStatusCodes: [],
      initialAuthIndex: null,
      debugMode: false,
    };

    const configPath = path.join(__dirname, 'config.json');
    try {
      if (fs.existsSync(configPath)) {
        const fileConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
        config = { ...config, ...fileConfig };
        this.logger.info('[系统] 已从 config.json 加载配置。');
      }
    } catch (error) {
      this.logger.warn(`[系统] 无法读取或解析 config.json: ${error.message}`);
    }

    if (process.env.PORT) config.httpPort = parseInt(process.env.PORT, 10) || config.httpPort;
    if (process.env.HOST) config.host = process.env.HOST;
    if (process.env.STREAMING_MODE) config.streamingMode = process.env.STREAMING_MODE;
    if (process.env.FAILURE_THRESHOLD) config.failureThreshold = parseInt(process.env.FAILURE_THRESHOLD, 10) || config.failureThreshold;
    if (process.env.MAX_RETRIES) config.maxRetries = parseInt(process.env.MAX_RETRIES, 10) || config.maxRetries;
    if (process.env.RETRY_DELAY) config.retryDelay = parseInt(process.env.RETRY_DELAY, 10) || config.retryDelay;
    if (process.env.CAMOUFOX_EXECUTABLE_PATH) config.browserExecutablePath = process.env.CAMOUFOX_EXECUTABLE_PATH;
    if (process.env.API_KEYS) {
      config.apiKeys = process.env.API_KEYS.split(',');
    }
    if (process.env.DEBUG_MODE) {
      config.debugMode = process.env.DEBUG_MODE === 'true';
    }
    if (process.env.INITIAL_AUTH_INDEX) {
      const envIndex = parseInt(process.env.INITIAL_AUTH_INDEX, 10);
      if (!isNaN(envIndex) && envIndex > 0) {
        config.initialAuthIndex = envIndex;
      }
    }

    let rawCodes = process.env.IMMEDIATE_SWITCH_STATUS_CODES;
    let codesSource = '环境变量';

    if (!rawCodes && config.immediateSwitchStatusCodes && Array.isArray(config.immediateSwitchStatusCodes)) {
      rawCodes = config.immediateSwitchStatusCodes.join(',');
      codesSource = 'config.json 文件';
    }

    if (rawCodes && typeof rawCodes === 'string') {
      config.immediateSwitchStatusCodes = rawCodes
        .split(',')
        .map(code => parseInt(String(code).trim(), 10))
        .filter(code => !isNaN(code) && code >= 400 && code <= 599);
      if (config.immediateSwitchStatusCodes.length > 0) {
        this.logger.info(`[系统] 已从 ${codesSource} 加载“立即切换状态码”。`);
      }
    } else {
      config.immediateSwitchStatusCodes = [];
    }

    if (Array.isArray(config.apiKeys)) {
      config.apiKeys = config.apiKeys.map(k => String(k).trim()).filter(k => k);
    } else {
      config.apiKeys = [];
    }

    this.config = config;
    this.logger.info('================ [ 生效配置 ] ================');
    this.logger.info(`  HTTP 服务端口: ${this.config.httpPort}`);
    this.logger.info(`  监听地址: ${this.config.host}`);
    this.logger.info(`  流式模式: ${this.config.streamingMode}`);
    this.logger.info(`  调试模式: ${this.config.debugMode ? '已开启' : '已关闭'}`);
    if (this.config.initialAuthIndex) {
      this.logger.info(`  指定初始认证索引: ${this.config.initialAuthIndex}`);
    }
    this.logger.info(`  失败计数切换: ${this.config.failureThreshold > 0 ? `连续 ${this.config.failureThreshold} 次失败后切换` : '已禁用'}`);
    this.logger.info(`  立即切换状态码: ${this.config.immediateSwitchStatusCodes.length > 0 ? this.config.immediateSwitchStatusCodes.join(', ') : '已禁用'}`);
    this.logger.info(`  单次请求最大重试: ${this.config.maxRetries}次`);
    this.logger.info(`  重试间隔: ${this.config.retryDelay}ms`);
    if (this.config.apiKeys && this.config.apiKeys.length > 0) {
      this.logger.info(`  API 密钥认证: 已启用 (${this.config.apiKeys.length} 个密钥)`);
    } else {
      this.logger.info(`  API 密钥认证: 已禁用`);
    }
    this.logger.info('=============================================================');
  }

  async start() {
    try {
      // 初始化统计对象
      this.authSource.getAvailableIndices().forEach(index => {
        this.stats.accountCalls[index] = { total: 0, models: {} };
      });

      let startupIndex = this.authSource.getFirstAvailableIndex();
      const suggestedIndex = this.config.initialAuthIndex;

      if (suggestedIndex) {
        if (this.authSource.getAvailableIndices().includes(suggestedIndex)) {
          this.logger.info(`[系统] 使用配置中指定的有效启动索引: ${suggestedIndex}`);
          startupIndex = suggestedIndex;
        } else {
          this.logger.warn(`[系统] 配置中指定的启动索引 ${suggestedIndex} 无效或不存在，将使用第一个可用索引: ${startupIndex}`);
        }
      } else {
        this.logger.info(`[系统] 未指定启动索引，将自动使用第一个可用索引: ${startupIndex}`);
      }

      await this.browserManager.launchBrowser(startupIndex);
      await this._startHttpServer();
      await this._startWebSocketServer();
      this.logger.info(`[系统] 代理服务器系统启动完成。`);
      this.emit('started');
    } catch (error) {
      this.logger.error(`[系统] 启动失败: ${error.message}`);
      this.emit('error', error);
      process.exit(1); // 启动失败时退出
    }
  }

  _createDebugLogMiddleware() {
    return (req, res, next) => {
      if (!this.config.debugMode) {
        return next();
      }

      const requestId = this.requestHandler._generateRequestId();
      const log = this.logger.info.bind(this.logger);

      log(`\n\n--- [调试] 开始处理入站请求 (${requestId}) ---`);
      log(`[调试][${requestId}] 客户端 IP: ${req.ip}`);
      log(`[调试][${requestId}] 方法: ${req.method}`);
      log(`[调试][${requestId}] URL: ${req.originalUrl}`);
      log(`[调试][${requestId}] 请求头: ${JSON.stringify(req.headers, null, 2)}`);

      let bodyContent = '无或空';
      if (req.body) {
        if (Buffer.isBuffer(req.body) && req.body.length > 0) {
          try {
            bodyContent = JSON.stringify(JSON.parse(req.body.toString('utf-8')), null, 2);
          } catch (e) {
            bodyContent = `[无法解析为JSON的Buffer, 大小: ${req.body.length} 字节]`;
          }
        } else if (typeof req.body === 'object' && Object.keys(req.body).length > 0) {
          bodyContent = JSON.stringify(req.body, null, 2);
        }
      }

      log(`[调试][${requestId}] 请求体:\n${bodyContent}`);
      log(`--- [调试] 结束处理入站请求 (${requestId}) ---\n\n`);

      next();
    };
  }


  _createAuthMiddleware() {
    return (req, res, next) => {
      const serverApiKeys = this.config.apiKeys;
      if (!serverApiKeys || serverApiKeys.length === 0) {
        return next();
      }

      let clientKey = null;
      let keySource = null;

      const headers = req.headers;
      const xGoogApiKey = headers['x-goog-api-key'] || headers['x_goog_api_key'];
      const xApiKey = headers['x-api-key'] || headers['x_api_key'];
      const authHeader = headers.authorization;

      if (xGoogApiKey) {
        clientKey = xGoogApiKey;
        keySource = 'x-goog-api-key 请求头';
      } else if (authHeader && authHeader.startsWith('Bearer ')) {
        clientKey = authHeader.substring(7);
        keySource = 'Authorization 请求头';
      } else if (xApiKey) {
        clientKey = xApiKey;
        keySource = 'X-API-Key 请求头';
      } else if (req.query.key) {
        clientKey = req.query.key;
        keySource = '查询参数';
      }

      if (clientKey) {
        if (serverApiKeys.includes(clientKey)) {
          if (this.config.debugMode) {
            this.logger.debug(`[认证][调试] 在 '${keySource}' 中找到API密钥，验证通过。`);
          }
          if (keySource === '查询参数') {
            delete req.query.key;
          }
          return next();
        } else {
          if (this.config.debugMode) {
            this.logger.warn(`[认证][调试] 拒绝请求: 无效的API密钥。IP: ${req.ip}, 路径: ${req.path}`);
            this.logger.debug(`[认证][调试] 来源: ${keySource}`);
            this.logger.debug(`[认证][调试] 提供的错误密钥: '${clientKey}'`);
            this.logger.debug(`[认证][调试] 已加载的有效密钥: [${serverApiKeys.join(', ')}]`);
          } else {
            this.logger.warn(`[认证] 拒绝请求: 无效的API密钥。IP: ${req.ip}, 路径: ${req.path}`);
          }
          return res.status(401).json({ error: { message: "提供了无效的API密钥。" } });
        }
      }

      this.logger.warn(`[认证] 拒绝受保护的请求: 缺少API密钥。IP: ${req.ip}, 路径: ${req.path}`);

      if (this.config.debugMode) {
        this.logger.debug(`[认证][调试] 未在任何标准位置找到API密钥。`);
        this.logger.debug(`[认证][调试] 搜索的请求头: ${JSON.stringify(headers, null, 2)}`);
        this.logger.debug(`[认证][调试] 搜索的查询参数: ${JSON.stringify(req.query)}`);
        this.logger.debug(`[认证][调试] 已加载的有效密钥: [${serverApiKeys.join(', ')}]`);
      }

      return res.status(401).json({ error: { message: "访问被拒绝。未在请求头或查询参数中找到有效的API密钥。" } });
    };
  }

  async _startHttpServer() {
    const app = this._createExpressApp();
    this.httpServer = http.createServer(app);
    return new Promise((resolve) => {
      this.httpServer.listen(this.config.httpPort, this.config.host, () => {
        this.logger.info(`[系统] HTTP服务器已在 http://${this.config.host}:${this.config.httpPort} 上监听`);
        this.logger.info(`[系统] 仪表盘可在 http://${this.config.host}:${this.config.httpPort}/dashboard 访问`);
        resolve();
      });
    });
  }

  // [可复制并覆盖]
  // 请用此版本完整替换您文件中的 _createExpressApp 方法
  _createExpressApp() {
    const app = express();
    app.use(express.json({ limit: '100mb' }));
    app.use(express.raw({ type: '*/*', limit: '100mb' }));
    app.use((req, res, next) => {
      if (req.is('application/json') && typeof req.body === 'object' && !Buffer.isBuffer(req.body)) {
        // Already parsed correctly by express.json()
      } else if (Buffer.isBuffer(req.body)) {
        const bodyStr = req.body.toString('utf-8');
        if (bodyStr) {
          try {
            req.body = JSON.parse(bodyStr);
          } catch (e) {
            // Not JSON, leave as buffer.
          }
        }
      }
      next();
    });

    app.use(this._createDebugLogMiddleware());

    // --- 仪表盘和API端点 ---

    // 公开端点：提供仪表盘HTML
    app.get('/dashboard', (req, res) => {
      res.send(this._getDashboardHtml());
    });

    // 公开端点：用于仪表盘验证API密钥
    app.post('/dashboard/verify-key', (req, res) => {
      const { key } = req.body;
      const serverApiKeys = this.config.apiKeys;

      if (!serverApiKeys || serverApiKeys.length === 0) {
        this.logger.info('[管理] 服务器未配置API密钥，自动授予仪表盘访问权限。');
        return res.json({ success: true });
      }

      if (key && serverApiKeys.includes(key)) {
        this.logger.info('[管理] 仪表盘API密钥验证成功。');
        return res.json({ success: true });
      }

      this.logger.warn(`[管理] 仪表盘API密钥验证失败。`);
      res.status(401).json({ success: false, message: '无效的API密钥。' });
    });

    // 中间件：保护仪表盘API路由
    const dashboardApiAuth = (req, res, next) => {
      const serverApiKeys = this.config.apiKeys;
      if (!serverApiKeys || serverApiKeys.length === 0) {
        return next(); // 未配置密钥，跳过认证
      }

      const clientKey = req.headers['x-dashboard-auth'];
      if (clientKey && serverApiKeys.includes(clientKey)) {
        return next();
      }

      this.logger.warn(`[管理] 拒绝未经授权的仪表盘API请求。IP: ${req.ip}, 路径: ${req.path}`);
      res.status(401).json({ error: { message: 'Unauthorized dashboard access' } });
    };

    const dashboardApiRouter = express.Router();
    dashboardApiRouter.use(dashboardApiAuth);

    dashboardApiRouter.get('/data', (req, res) => {
      res.json({
        status: {
          uptime: process.uptime(),
          streamingMode: this.streamingMode,
          debugMode: this.config.debugMode,
          authMode: this.authSource.authMode,
          apiKeyAuth: (this.config.apiKeys && this.config.apiKeys.length > 0) ? '已启用' : '已禁用',
          isAuthSwitching: this.requestHandler.isAuthSwitching,
          browserConnected: !!this.browserManager.browser,
          internalWsClients: this.connectionRegistry.connections.size
        },
        auth: {
          currentAuthIndex: this.requestHandler.currentAuthIndex,
          accounts: this.authSource.getAccountDetails(),
          failureCount: this.requestHandler.failureCount,
        },
        stats: this.stats,
        config: this.config
      });
    });

    dashboardApiRouter.post('/config', (req, res) => {
      const newConfig = req.body;
      try {
        if (newConfig.hasOwnProperty('streamingMode') && ['real', 'fake'].includes(newConfig.streamingMode)) {
          this.config.streamingMode = newConfig.streamingMode;
          this.streamingMode = newConfig.streamingMode;
          this.requestHandler.serverSystem.streamingMode = newConfig.streamingMode;
        }
        if (newConfig.hasOwnProperty('debugMode') && typeof newConfig.debugMode === 'boolean') {
          this.config.debugMode = newConfig.debugMode;
        }
        if (newConfig.hasOwnProperty('failureThreshold')) {
          this.config.failureThreshold = parseInt(newConfig.failureThreshold, 10) || 0;
        }
        if (newConfig.hasOwnProperty('maxRetries')) {
          const retries = parseInt(newConfig.maxRetries, 10);
          this.config.maxRetries = retries >= 0 ? retries : 3;
          this.requestHandler.maxRetries = this.config.maxRetries;
        }
        if (newConfig.hasOwnProperty('retryDelay')) {
          this.config.retryDelay = parseInt(newConfig.retryDelay, 10) || 2000;
          this.requestHandler.retryDelay = this.config.retryDelay;
        }
        if (newConfig.hasOwnProperty('immediateSwitchStatusCodes')) {
          if (Array.isArray(newConfig.immediateSwitchStatusCodes)) {
            this.config.immediateSwitchStatusCodes = newConfig.immediateSwitchStatusCodes
              .map(c => parseInt(c, 10))
              .filter(c => !isNaN(c));
          }
        }
        this.logger.info('[管理] 配置已通过仪表盘动态更新。');
        res.status(200).json({ success: true, message: '配置已临时更新。' });
      } catch (error) {
        this.logger.error(`[管理] 更新配置失败: ${error.message}`);
        res.status(500).json({ success: false, message: error.message });
      }
    });

    dashboardApiRouter.post('/accounts', (req, res) => {
      const { index, authData } = req.body;
      if (!index || !authData) {
        return res.status(400).json({ success: false, message: "必须提供索引和认证数据。" });
      }

      let parsedData;
      try {
        parsedData = (typeof authData === 'string') ? JSON.parse(authData) : authData;
      } catch (e) {
        return res.status(400).json({ success: false, message: "认证数据的JSON格式无效。" });
      }

      const result = this.authSource.addAccount(parseInt(index, 10), parsedData);
      if (result.success) {
        if (!this.stats.accountCalls.hasOwnProperty(index)) {
          this.stats.accountCalls[index] = { total: 0, models: {} };
        }
      }
      res.status(result.success ? 200 : 400).json(result);
    });

    dashboardApiRouter.delete('/accounts/:index', (req, res) => {
      const index = parseInt(req.params.index, 10);
      const result = this.authSource.removeAccount(index);
      res.status(result.success ? 200 : 400).json(result);
    });

    // 挂载受保护的仪表盘API路由
    app.use('/dashboard', dashboardApiRouter);

    // 保护 /switch 路由
    app.post('/switch', dashboardApiAuth, async (req, res) => {
      this.logger.info('[管理] 接到 /switch 请求，手动触发账号切换。');
      if (this.requestHandler.isAuthSwitching) {
        const msg = '账号切换已在进行中，请稍后。';
        this.logger.warn(`[管理] /switch 请求被拒绝: ${msg}`);
        return res.status(429).send(msg);
      }
      const oldIndex = this.requestHandler.currentAuthIndex;
      try {
        await this.requestHandler._switchToNextAuth();
        const newIndex = this.requestHandler.currentAuthIndex;
        const message = `成功将账号从索引 ${oldIndex} 切换到 ${newIndex}。`;
        this.logger.info(`[管理] 手动切换成功。 ${message}`);
        res.status(200).send(message);
      } catch (error) {
        const errorMessage = `切换账号失败: ${error.message}`;
        this.logger.error(`[管理] 手动切换失败。错误: ${errorMessage}`);
        res.status(500).send(errorMessage);
      }
    });

    app.get('/health', (req, res) => {
      res.status(200).json({
        status: 'healthy',
        uptime: process.uptime(),
        config: {
          streamingMode: this.streamingMode,
          debugMode: this.config.debugMode,
          failureThreshold: this.config.failureThreshold,
          immediateSwitchStatusCodes: this.config.immediateSwitchStatusCodes,
          maxRetries: this.config.maxRetries,
          authMode: this.authSource.authMode,
          apiKeyAuth: (this.config.apiKeys && this.config.apiKeys.length > 0) ? '已启用' : '已禁用',
        },
        auth: {
          currentAuthIndex: this.requestHandler.currentAuthIndex,
          availableIndices: this.authSource.getAvailableIndices(),
          totalAuthSources: this.authSource.getAvailableIndices().length,
          failureCount: this.requestHandler.failureCount,
          isAuthSwitching: this.requestHandler.isAuthSwitching,
        },
        stats: this.stats,
        browser: {
          connected: !!this.browserManager.browser,
        },
        websocket: {
          internalClients: this.connectionRegistry.connections.size
        }
      });
    });

    // 主API代理
    app.use(this._createAuthMiddleware());
    app.all(/(.*)/, (req, res) => {
      if (req.path === '/favicon.ico' || req.path.startsWith('/dashboard')) {
        return res.status(204).send();
      }
      this.requestHandler.processRequest(req, res);
    });

    return app;
  }

    _getDashboardHtml() {
    return `
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>服务器仪表盘</title>
    <style>
        :root {
            --pico-font-size: 16px;
            --pico-background-color: #11191f;
            --pico-color: #dce3e9;
            --pico-card-background-color: #1a242c;
            --pico-card-border-color: #2b3a47;
            --pico-primary: #3d8bfd;
            --pico-primary-hover: #529bff;
            --pico-primary-focus: rgba(61, 139, 253, 0.25);
            --pico-primary-inverse: #fff;
            --pico-form-element-background-color: #1a242c;
            --pico-form-element-border-color: #2b3a47;
            --pico-form-element-focus-color: var(--pico-primary);
            --pico-h1-color: #fff;
            --pico-h2-color: #f1f1f1;
            --pico-muted-color: #7a8c99;
            --pico-border-radius: 0.5rem;
            --info-color: #17a2b8; /* 天蓝色，用于状态文本 */
        }
        body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol"; margin: 0; padding: 2rem; background-color: var(--pico-background-color); color: var(--pico-color); }
        main.container { max-width: 1200px; margin: 0 auto; padding-top: 30px; display: none; /* Initially hidden */ }
        .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(350px, 1fr)); gap: 1.5rem; }
        article { border: 1px solid var(--pico-card-border-color); border-radius: var(--pico-border-radius); padding: 1.5rem; background: var(--pico-card-background-color); }
        h1, h2 { margin-top: 0; color: var(--pico-h1-color); }
        h2 { border-bottom: 1px solid var(--pico-card-border-color); padding-bottom: 0.5rem; margin-bottom: 1rem; color: var(--pico-h2-color); }
        .status-grid { display: grid; grid-template-columns: auto 1fr; gap: 0.5rem 1rem; align-items: center;}
        .status-grid strong { color: var(--pico-color); white-space: nowrap;}
        .status-grid span { color: var(--pico-muted-color); text-align: right; }
        .status-text-info { color: var(--info-color); font-weight: bold; }
        .status-text-red { color: #dc3545; font-weight: bold; }
        .status-text-yellow { color: #ffc107; font-weight: bold; }
        .status-text-gray { color: var(--pico-muted-color); font-weight: bold; }
        .tag { display: inline-block; padding: 0.25em 0.6em; font-size: 0.75em; font-weight: 700; line-height: 1; text-align: center; white-space: nowrap; vertical-align: baseline; border-radius: 0.35rem; color: #fff; }
        .tag-info { background-color: #17a2b8; }
        .tag-blue { background-color: #007bff; }
        .tag-yellow { color: #212529; background-color: #ffc107; }
        ul { list-style: none; padding: 0; margin: 0; }
        .scrollable-list { max-height: 220px; overflow-y: auto; padding-right: 5px; border: 1px solid var(--pico-form-element-border-color); border-radius: 0.25rem; padding: 0.5rem;}
        .account-list li { display: flex; justify-content: space-between; align-items: center; padding: 0.5rem; border-radius: 0.25rem; }
        .account-list li:nth-child(odd) { background-color: rgba(255,255,255,0.03); }
        .account-list .current { font-weight: bold; color: var(--pico-primary); }
        details { width: 100%; border-bottom: 1px solid var(--pico-form-element-border-color); }
        details:last-child { border-bottom: none; }
        details summary { cursor: pointer; display: flex; justify-content: space-between; align-items: center; padding: 0.5rem 0.2rem; list-style: none; }
        details summary::-webkit-details-marker { display: none; }
        details summary:hover { background-color: rgba(255,255,255,0.05); }
        .model-stats-list { padding: 0.5rem 0 0.5rem 1.5rem; font-size: 0.9em; background-color: rgba(0,0,0,0.1); }
        .model-stats-list li { display: flex; justify-content: space-between; padding: 0.2rem; }
        button, input[type="text"], input[type="number"] { background-color: var(--pico-form-element-background-color); border: 1px solid var(--pico-form-element-border-color); color: var(--pico-color); padding: 0.5rem 1rem; border-radius: var(--pico-border-radius); }
        button { cursor: pointer; background-color: var(--pico-primary); border-color: var(--pico-primary); color: var(--pico-primary-inverse); }
        button:hover { background-color: var(--pico-primary-hover); }
        .btn-danger { background-color: #dc3545; border-color: #dc3545; }
        .btn-sm { font-size: 0.8em; padding: 0.2rem 0.5rem; }
        .top-banner { position: fixed; top: 0; right: 0; background-color: #ffc107; color: #212529; padding: 5px 15px; font-size: 0.9em; z-index: 1001; border-bottom-left-radius: 0.5rem; }
        .toast { position: fixed; bottom: 20px; right: 20px; background-color: var(--pico-primary); color: white; padding: 15px; border-radius: 5px; z-index: 1000; opacity: 0; transition: opacity 0.5s; }
        .toast.show { opacity: 1; }
        .toast.error { background-color: #dc3545; }
        form label { display: block; margin-bottom: 0.5rem; }
        form input { width: 100%; box-sizing: border-box; }
        .form-group { margin-bottom: 1rem; }
        .switch-field { display: flex; overflow: hidden; }
        .switch-field input { position: absolute !important; clip: rect(0, 0, 0, 0); height: 1px; width: 1px; border: 0; overflow: hidden; }
        .switch-field label { background-color: var(--pico-form-element-background-color); color: var(--pico-muted-color); font-size: 14px; line-height: 1; text-align: center; padding: 8px 16px; margin-right: -1px; border: 1px solid var(--pico-form-element-border-color); transition: all 0.1s ease-in-out; width: 50%; }
        .switch-field label:hover { cursor: pointer; }
        .switch-field input:checked + label { background-color: var(--pico-primary); color: var(--pico-primary-inverse); box-shadow: none; }
        .switch-field label:first-of-type { border-radius: 4px 0 0 4px; }
        .switch-field label:last-of-type { border-radius: 0 4px 4px 0; }
    </style>
</head>
<body data-theme="dark">
    <div class="top-banner">注意: 此面板中添加的账号和修改的变量均是临时的，重启后会丢失</div>
    <main class="container">
        <h1>🐢 服务器仪表盘</h1>
        <div class="grid">
            <article>
                <h2>服务器状态</h2>
                <div class="status-grid">
                    <strong>运行时间:</strong> <span id="uptime">--</span>
                    <strong>浏览器:</strong> <span id="browserConnected">--</span>
                    <strong>认证模式:</strong> <span id="authMode">--</span>
                    <strong>API密钥认证:</strong> <span id="apiKeyAuth">--</span>
                    <strong>调试模式:</strong> <span id="debugMode">--</span>
                    <strong>API总调用次数:</strong> <span id="totalCalls">0</span>
                </div>
            </article>
            <article>
                <h2>调用统计</h2>
                <div id="accountCalls" class="scrollable-list"></div>
            </article>
            
            <article>
                <h2>账号管理</h2>
                <div style="display: flex; gap: 1rem; margin-bottom: 1rem;">
                    <button id="switchAccountBtn">切换到下一个账号</button>
                    <button id="addAccountBtn">添加临时账号</button>
                </div>
                <h3>账号池</h3>
                <div id="accountPool" class="scrollable-list"></div>
            </article>
            
            <article>
                <h2>实时配置</h2>
                <form id="configForm">
                    <div class="form-group">
                      <label>流式模式</label>
                      <div class="switch-field">
                        <input type="radio" id="streamingMode_fake" name="streamingMode" value="fake" />
                        <label for="streamingMode_fake">Fake</label>
                        <input type="radio" id="streamingMode_real" name="streamingMode" value="real" checked/>
                        <label for="streamingMode_real">Real</label>
                      </div>
                    </div>

                    <div class="form-group">
                        <label for="configFailureThreshold">几次失败后切换账号 (0为禁用)</label>
                        <input type="number" id="configFailureThreshold" name="failureThreshold">
                    </div>
                    
                    <div class="form-group">
                        <label for="configMaxRetries">单次请求内部重试次数</label>
                        <input type="number" id="configMaxRetries" name="maxRetries">
                    </div>
                    
                    <div class="form-group">
                        <label for="configRetryDelay">重试间隔 (毫秒)</label>
                        <input type="number" id="configRetryDelay" name="retryDelay">
                    </div>

                    <div class="form-group">
                        <label for="configImmediateSwitchStatusCodes">立即切换的状态码 (逗号分隔)</label>
                        <input type="text" id="configImmediateSwitchStatusCodes" name="immediateSwitchStatusCodes">
                    </div>
                    
                    <button type="submit">应用临时更改</button>
                </form>
            </article>
        </div>
    </main>
    <div id="toast" class="toast"></div>
    <script>
        document.addEventListener('DOMContentLoaded', () => {
            const API_KEY_SESSION_STORAGE = 'dashboard_api_key';
            const API_BASE = '/dashboard';

            // DOM Elements
            const mainContainer = document.querySelector('main.container');
            const uptimeEl = document.getElementById('uptime');
            const debugModeEl = document.getElementById('debugMode');
            const browserConnectedEl = document.getElementById('browserConnected');
            const authModeEl = document.getElementById('authMode');
            const apiKeyAuthEl = document.getElementById('apiKeyAuth');
            const totalCallsEl = document.getElementById('totalCalls');
            const accountCallsEl = document.getElementById('accountCalls');
            const accountPoolEl = document.getElementById('accountPool');
            const switchAccountBtn = document.getElementById('switchAccountBtn');
            const addAccountBtn = document.getElementById('addAccountBtn');
            const configForm = document.getElementById('configForm');
            const toastEl = document.getElementById('toast');

            function getAuthHeaders(hasBody = false) {
                const headers = {
                    'X-Dashboard-Auth': sessionStorage.getItem(API_KEY_SESSION_STORAGE) || ''
                };
                if (hasBody) {
                    headers['Content-Type'] = 'application/json';
                }
                return headers;
            }

            function showToast(message, isError = false) {
                toastEl.textContent = message;
                toastEl.className = isError ? 'toast show error' : 'toast show';
                setTimeout(() => { toastEl.className = 'toast'; }, 3000);
            }

            function formatUptime(seconds) {
                const d = Math.floor(seconds / (3600*24));
                const h = Math.floor(seconds % (3600*24) / 3600);
                const m = Math.floor(seconds % 3600 / 60);
                const s = Math.floor(seconds % 60);
                return \`\${d}天 \${h}小时 \${m}分钟 \${s}秒\`;
            }

            function handleAuthFailure() {
                sessionStorage.removeItem(API_KEY_SESSION_STORAGE);
                mainContainer.style.display = 'none';
                document.body.insertAdjacentHTML('afterbegin', '<h1>认证已过期或无效，请刷新页面重试。</h1>');
                showToast('认证失败', true);
            }

            async function fetchData() {
                try {
                    const response = await fetch(\`\${API_BASE}/data\`, { headers: getAuthHeaders() });
                    if (response.status === 401) return handleAuthFailure();
                    if (!response.ok) throw new Error('获取数据失败');
                    const data = await response.json();
                    
                    uptimeEl.textContent = formatUptime(data.status.uptime);
                    browserConnectedEl.innerHTML = data.status.browserConnected ? '<span class="status-text-info">已连接</span>' : '<span class="status-text-red">已断开</span>';
                    authModeEl.innerHTML = data.status.authMode === 'env' ? '<span class="status-text-info">环境变量</span>' : '<span class="status-text-info">Cookie文件</span>';
                    apiKeyAuthEl.innerHTML = data.status.apiKeyAuth === '已启用' ? '<span class="status-text-info">已启用</span>' : '<span class="status-text-gray">已禁用</span>';
                    debugModeEl.innerHTML = data.status.debugMode ? '<span class="status-text-yellow">已启用</span>' : '<span class="status-text-gray">已禁用</span>';
                    totalCallsEl.textContent = data.stats.totalCalls;
                    
                    accountCallsEl.innerHTML = '';
                    const sortedAccounts = Object.entries(data.stats.accountCalls).sort((a,b) => parseInt(a[0]) - parseInt(b[0]));
                    const callsUl = document.createElement('ul');
                    callsUl.className = 'account-list';
                    for (const [index, stats] of sortedAccounts) {
                        const li = document.createElement('li');
                        const isCurrent = parseInt(index, 10) === data.auth.currentAuthIndex;
                        let modelStatsHtml = '<ul class="model-stats-list">';
                        const sortedModels = Object.entries(stats.models).sort((a,b) => b[1] - a[1]);
                        sortedModels.length > 0 ? sortedModels.forEach(([model, count]) => { modelStatsHtml += \`<li><span>\${model}:</span> <strong>\${count}</strong></li>\`; }) : modelStatsHtml += '<li>无模型调用记录</li>';
                        modelStatsHtml += '</ul>';
                        li.innerHTML = \`<details><summary><span class="\${isCurrent ? 'current' : ''}">账号 \${index}</span><strong>总计: \${stats.total}</strong></summary>\${modelStatsHtml}</details>\`;
                        if(isCurrent) { li.querySelector('summary').style.color = 'var(--pico-primary)'; }
                        callsUl.appendChild(li);
                    }
                    accountCallsEl.appendChild(callsUl);

                    accountPoolEl.innerHTML = '';
                    const poolUl = document.createElement('ul');
                    poolUl.className = 'account-list';
                    data.auth.accounts.forEach(acc => {
                        const li = document.createElement('li');
                        const isCurrent = acc.index === data.auth.currentAuthIndex;
                        const sourceTag = acc.source === 'temporary' ? '<span class="tag tag-yellow">临时</span>' : (acc.source === 'env' ? '<span class="tag tag-info">变量</span>' : '<span class="tag tag-blue">文件</span>');
                        let html = \`<span class="\${isCurrent ? 'current' : ''}">账号 \${acc.index} \${sourceTag}</span>\`;
                        if (acc.source === 'temporary') { html += \`<button class="btn-danger btn-sm" data-index="\${acc.index}">删除</button>\`; } else { html += '<span></span>'; }
                        li.innerHTML = html;
                        poolUl.appendChild(li);
                    });
                    accountPoolEl.appendChild(poolUl);
                    
                    const streamingModeInput = document.querySelector(\`input[name="streamingMode"][value="\${data.config.streamingMode}"]\`);
                    if(streamingModeInput) streamingModeInput.checked = true;
                    configForm.failureThreshold.value = data.config.failureThreshold;
                    configForm.maxRetries.value = data.config.maxRetries;
                    configForm.retryDelay.value = data.config.retryDelay;
                    configForm.immediateSwitchStatusCodes.value = data.config.immediateSwitchStatusCodes.join(', ');
                } catch (error) {
                    console.error('获取数据时出错:', error);
                    showToast(error.message, true);
                }
            }

            function initializeDashboardListeners() {
                switchAccountBtn.addEventListener('click', async () => {
                    switchAccountBtn.disabled = true;
                    switchAccountBtn.textContent = '切换中...';
                    try {
                        const response = await fetch('/switch', { method: 'POST', headers: getAuthHeaders() });
                        const text = await response.text();
                        if (!response.ok) throw new Error(text);
                        showToast(text);
                        await fetchData();
                    } catch (error) {
                        showToast(error.message, true);
                    } finally {
                        switchAccountBtn.disabled = false;
                        switchAccountBtn.textContent = '切换到下一个账号';
                    }
                });
            
                addAccountBtn.addEventListener('click', () => {
                    const index = prompt("为新的临时账号输入一个唯一的数字索引：");
                    if (!index || isNaN(parseInt(index))) { if(index !== null) alert("索引无效。"); return; }
                    const authDataStr = prompt("请输入单行压缩后的Cookie内容:");
                    if (!authDataStr) return;
                    let authData;
                    try { authData = JSON.parse(authDataStr); } catch(e) { alert("Cookie JSON格式无效。"); return; }
                    
                    fetch(\`\${API_BASE}/accounts\`, { method: 'POST', headers: getAuthHeaders(true), body: JSON.stringify({ index: parseInt(index), authData }) })
                        .then(res => res.json().then(data => ({ ok: res.ok, data }))).then(({ok, data}) => {
                        if (!ok) throw new Error(data.message);
                        showToast(data.message); fetchData(); }).catch(err => showToast(err.message, true));
                });
            
                accountPoolEl.addEventListener('click', e => {
                    if (e.target.matches('button.btn-danger')) {
                        const index = e.target.dataset.index;
                        if (confirm(\`您确定要删除临时账号 \${index} 吗？\`)) {
                            fetch(\`\${API_BASE}/accounts/\${index}\`, { method: 'DELETE', headers: getAuthHeaders() })
                                .then(res => res.json().then(data => ({ ok: res.ok, data }))).then(({ok, data}) => {
                                if (!ok) throw new Error(data.message);
                                showToast(data.message); fetchData(); }).catch(err => showToast(err.message, true));
                        }
                    }
                });

                configForm.addEventListener('submit', e => {
                    e.preventDefault();
                    const formData = new FormData(configForm);
                    const data = Object.fromEntries(formData.entries());
                    data.immediateSwitchStatusCodes = data.immediateSwitchStatusCodes.split(',').map(s => s.trim()).filter(Boolean);
                    fetch(\`\${API_BASE}/config\`, { method: 'POST', headers: getAuthHeaders(true), body: JSON.stringify(data) })
                        .then(res => res.json().then(data => ({ ok: res.ok, data }))).then(({ok, data}) => {
                        if (!ok) throw new Error(data.message);
                        showToast('配置已应用。'); fetchData(); }).catch(err => showToast(err.message, true));
                });

                configForm.addEventListener('change', e => {
                    if (e.target.name === 'streamingMode') {
                        fetch(\`\${API_BASE}/config\`, { method: 'POST', headers: getAuthHeaders(true), body: JSON.stringify({ streamingMode: e.target.value }) })
                            .then(res => res.json().then(d => ({ ok: res.ok, data: d }))).then(({ok, data}) => {
                            if (!ok) throw new Error(data.message);
                            showToast(\`流式模式已更新为: \${e.target.value.charAt(0).toUpperCase() + e.target.value.slice(1)}\`);
                            }).catch(err => showToast(err.message, true));
                    }
                });
            }

            async function verifyAndLoad(keyToVerify) {
                try {
                    const response = await fetch(\`\${API_BASE}/verify-key\`, {
                        method: 'POST',
                        headers: { 'Content-Type': 'application/json' },
                        body: JSON.stringify({ key: keyToVerify || '' })
                    });
                    const result = await response.json();
                    
                    if (response.ok && result.success) {
                        if (keyToVerify) {
                           sessionStorage.setItem(API_KEY_SESSION_STORAGE, keyToVerify);
                        }
                        mainContainer.style.display = 'block';
                        initializeDashboardListeners();
                        fetchData();
                        setInterval(fetchData, 5000);
                        return true;
                    } else {
                        sessionStorage.removeItem(API_KEY_SESSION_STORAGE);
                        return false;
                    }
                } catch (err) {
                    document.body.innerHTML = \`<h1>认证时发生错误: \${err.message}</h1>\`;
                    return false;
                }
            }

            async function checkAndInitiate() {
                const storedApiKey = sessionStorage.getItem(API_KEY_SESSION_STORAGE);
                
                // 尝试使用已存储的密钥或空密钥进行验证
                const initialCheckSuccess = await verifyAndLoad(storedApiKey);

                // 如果初次验证失败，说明服务器需要密钥，而我们没有提供或提供了错误的密钥
                if (!initialCheckSuccess) {
                    const newApiKey = prompt("请输入API密钥以访问仪表盘 (服务器需要认证):");
                    if (newApiKey) {
                        // 使用用户新输入的密钥再次尝试
                        const secondCheckSuccess = await verifyAndLoad(newApiKey);
                        if (!secondCheckSuccess) {
                           document.body.innerHTML = \`<h1>认证失败: 无效的API密钥</h1>\`;
                        }
                    } else {
                        // 用户取消了输入
                        document.body.innerHTML = '<h1>访问被拒绝</h1>';
                    }
                }
            }
            
            checkAndInitiate();
        });
    </script>
</body>
</html>
    `;
  }



  async _startWebSocketServer() {
    this.wsServer = new WebSocket.Server({ port: this.config.wsPort, host: this.config.host });
    this.wsServer.on('connection', (ws, req) => {
      this.connectionRegistry.addConnection(ws, { address: req.socket.remoteAddress });
    });
  }
}

// ===================================================================================
// 主初始化
// ===================================================================================

async function initializeServer() {
  try {
    const serverSystem = new ProxyServerSystem();
    await serverSystem.start();
  } catch (error) {
    console.error('❌ 服务器启动失败:', error.message);
    process.exit(1);
  }
}

if (require.main === module) {
  initializeServer();
}

module.exports = { ProxyServerSystem, BrowserManager, initializeServer };