import { _decorator, Component, Node, log, Button, Label } from "cc";
import { ChatAIService } from "../core/ChatAIService";

const { ccclass, property } = _decorator;

interface TestResult {
  roleId: number;
  success: boolean;
  response?: string;
  error?: string;
  duration: number;
}

interface TestReport {
  totalTests: number;
  successCount: number;
  failureCount: number;
  successIds: number[];
  failureIds: number[];
  results: TestResult[];
  totalDuration: number;
}

@ccclass("ChatAIServiceBatchTest")
export class ChatAIServiceBatchTest extends Component {
  @property(Button)
  startTestButton: Button = null;

  @property(Label)
  statusLabel: Label = null;

  @property(Label)
  resultLabel: Label = null;

  private isTestRunning: boolean = false;
  private testReport: TestReport = null;

  onLoad() {
    if (this.startTestButton) {
      this.startTestButton.node.on(
        Button.EventType.CLICK,
        this.startBatchTest,
        this
      );
    }

    this.updateStatus("点击开始按钮进行批量测试");
  }

  /**
   * 延时工具函数
   * @param seconds 延时秒数
   */
  private async delay(seconds: number): Promise<void> {
    return new Promise((resolve) => {
      setTimeout(resolve, seconds * 1000);
    });
  }

  /**
   * 更新状态显示
   */
  private updateStatus(message: string): void {
    if (this.statusLabel) {
      this.statusLabel.string = message;
    }
    log(`[ChatAIBatchTest] ${message}`);
  }

  /**
   * 更新结果显示
   */
  private updateResult(report: TestReport): void {
    if (!this.resultLabel) return;

    const resultText = `测试完成！
总测试数: ${report.totalTests}
成功数: ${report.successCount}
失败数: ${report.failureCount}
总耗时: ${(report.totalDuration / 1000).toFixed(2)}s

成功的ID: ${report.successIds.join(", ")}

失败的ID: ${report.failureIds.join(", ")}`;

    this.resultLabel.string = resultText;
  }

  /**
   * 测试单个角色ID
   */
  private async testSingleRole(roleId: number): Promise<TestResult> {
    const startTime = Date.now();

    try {
      this.updateStatus(`正在测试角色ID: ${roleId}`);

      const response = await ChatAIService.Instance.sendMessage(
        roleId,
        "hello"
      );
      const duration = Date.now() - startTime;

      if (response && response.trim() !== "") {
        log(
          `[ChatAIBatchTest] 角色 ${roleId} 测试成功: ${response.substring(
            0,
            50
          )}...`
        );
        return {
          roleId,
          success: true,
          response: response.substring(0, 100), // 只记录前100字符
          duration,
        };
      } else {
        log(`[ChatAIBatchTest] 角色 ${roleId} 返回空响应`);
        return {
          roleId,
          success: false,
          error: "返回空响应",
          duration,
        };
      }
    } catch (error) {
      const duration = Date.now() - startTime;
      const errorMessage =
        error instanceof Error ? error.message : String(error);
      log(`[ChatAIBatchTest] 角色 ${roleId} 测试失败: ${errorMessage}`);

      return {
        roleId,
        success: false,
        error: errorMessage,
        duration,
      };
    }
  }

  /**
   * 开始批量测试
   */
  public async startBatchTest(): Promise<void> {
    if (this.isTestRunning) {
      this.updateStatus("测试正在进行中，请等待...");
      return;
    }

    this.isTestRunning = true;

    if (this.startTestButton) {
      this.startTestButton.interactable = false;
    }

    if (this.resultLabel) {
      this.resultLabel.string = "";
    }

    const startTime = Date.now();
    const results: TestResult[] = [];
    const successIds: number[] = [];
    const failureIds: number[] = [];

    log("[ChatAIBatchTest] 开始批量测试角色ID 10001-10030");
    this.updateStatus("开始批量测试...");

    const list = [10010, 10018];
    // 测试角色ID 10001-10030
    for (let i = 0; i <= list.length; i++) {
      const roleId = list[i];

      try {
        // 测试单个角色
        const result = await this.testSingleRole(roleId);
        results.push(result);

        if (result.success) {
          successIds.push(roleId);
        } else {
          failureIds.push(roleId);
        }

        // 等待10秒（最后一个不需要等待）
        if (roleId < 10030) {
          this.updateStatus(`角色 ${roleId} 测试完成，等待10秒...`);
          await this.delay(10);
        }
      } catch (error) {
        log(`[ChatAIBatchTest] 测试角色 ${roleId} 时发生意外错误: ${error}`);
        results.push({
          roleId,
          success: false,
          error: `意外错误: ${error}`,
          duration: 0,
        });
        failureIds.push(roleId);
      }
    }

    const totalDuration = Date.now() - startTime;

    // 生成测试报告
    this.testReport = {
      totalTests: 30,
      successCount: successIds.length,
      failureCount: failureIds.length,
      successIds,
      failureIds,
      results,
      totalDuration,
    };

    // 输出详细报告到控制台
    this.logDetailedReport(this.testReport);

    // 更新UI显示
    this.updateResult(this.testReport);
    this.updateStatus("批量测试完成！");

    if (this.startTestButton) {
      this.startTestButton.interactable = true;
    }

    this.isTestRunning = false;
  }

  /**
   * 输出详细测试报告到控制台
   */
  private logDetailedReport(report: TestReport): void {
    log("========== ChatAI 批量测试报告 ==========");
    log(`测试时间: ${new Date().toLocaleString()}`);
    log(`总测试数: ${report.totalTests}`);
    log(`成功数: ${report.successCount}`);
    log(`失败数: ${report.failureCount}`);
    log(
      `成功率: ${((report.successCount / report.totalTests) * 100).toFixed(2)}%`
    );
    log(`总耗时: ${(report.totalDuration / 1000).toFixed(2)}秒`);
    log(
      `平均耗时: ${(report.totalDuration / report.totalTests / 1000).toFixed(
        2
      )}秒/测试`
    );

    log("\n===== 成功的角色ID =====");
    if (report.successIds.length > 0) {
      log(report.successIds.join(", "));
    } else {
      log("无");
    }

    log("\n===== 失败的角色ID =====");
    if (report.failureIds.length > 0) {
      log(report.failureIds.join(", "));

      log("\n===== 失败详情 =====");
      report.results
        .filter((r) => !r.success)
        .forEach((result) => {
          log(`角色 ${result.roleId}: ${result.error}`);
        });
    } else {
      log("无");
    }

    log("\n===== 详细测试结果 =====");
    report.results.forEach((result) => {
      const status = result.success ? "成功" : "失败";
      const duration = (result.duration / 1000).toFixed(2);
      const extra = result.success
        ? `响应: ${result.response?.substring(0, 30)}...`
        : `错误: ${result.error}`;
      log(`角色 ${result.roleId}: ${status} (${duration}s) - ${extra}`);
    });

    log("========================================");
  }

  /**
   * 获取测试报告（供外部调用）
   */
  public getTestReport(): TestReport {
    return this.testReport;
  }

  /**
   * 重置测试状态
   */
  public resetTest(): void {
    this.isTestRunning = false;
    this.testReport = null;

    if (this.statusLabel) {
      this.statusLabel.string = "点击开始按钮进行批量测试";
    }

    if (this.resultLabel) {
      this.resultLabel.string = "";
    }

    if (this.startTestButton) {
      this.startTestButton.interactable = true;
    }
  }
}