// ===== 单例 Worker 管理 =====
let worker: Worker | null = null;
let pyodideReady = false;
let requestId = 0;

// 待处理请求的 Map：请求 ID -> { resolve, reject, timer }
const pendingRequests = new Map<
  number,
  {
    resolve: (result: ExecutionResult) => void;
    reject: (error: Error) => void;
    timer: ReturnType<typeof setTimeout>;
  }
>();

/*
 * 设计要点：
 * 1. worker 是单例：整个应用共享一个 Worker，避免重复加载
 * 2. requestId 自增：每次执行分配唯一 ID，用于匹配返回结果
 * 3. pendingRequests Map：同时发起多个请求时，通过 ID 区分回调
 * 4. 每个请求有 timer：超时保护，防止死循环永久挂起
 */

// ===== 创建 Worker =====
function createWorker(): Worker {
  // type: "module" 是因为 Pyodide v314 使用 ES 模块
  const w = new Worker("/pyodide/worker.js", { type: "module" });

  w.onmessage = (e: MessageEvent) => {
    const msg = e.data;
    if (msg.type === "result" && msg.id !== undefined) {
      // 找到对应的请求回调
      const pending = pendingRequests.get(msg.id);
      if (pending) {
        clearTimeout(pending.timer);
        pendingRequests.delete(msg.id);
        pending.resolve({
          output: msg.output || "",
          error: msg.error || null,
          executionTime: msg.executionTime || 0,
        });
      }
    }
  };

  w.onerror = () => {
    // Worker 崩溃时，拒绝所有待处理请求
    pendingRequests.forEach((pending) => {
      clearTimeout(pending.timer);
      pending.reject(new Error("Worker 加载失败，请刷新重试。"));
    });
    pendingRequests.clear();
    worker = null;
  };

  return w;
}

/*
 * 通信流程：
 * 主线程                          Worker
 *   │ postMessage({id, code}) ───→│ 接收代码
 *   │                              │ Pyodide 执行
 *   │←── postMessage({id, result}) │ 返回结果
 *   │ 通过 id 找到 resolve 回调     │
 */

// ===== 执行入口 =====
export async function executePython(
  code: string,
  options: ExecuteOptions = {}
): Promise<ExecutionResult> {
  const { timeout = 5000, stdin = [] } = options;

  // 懒初始化：第一次执行时才创建 Worker
  if (!worker) worker = createWorker();

  return new Promise((resolve, reject) => {
    const id = requestId++;

    // 超时保护：5 秒后自动终止
    const timer = setTimeout(() => {
      pendingRequests.delete(id);
      reject(new Error("执行超时（超过 5 秒）。检查是否有死循环。"));
    }, timeout);

    pendingRequests.set(id, { resolve, reject, timer });
    worker!.postMessage({ type: "execute", id, code, stdin });
  });
}

/*
 * 关键设计：
 * 1. Promise 封装：回调风格变成 async/await
 * 2. 超时保护：setTimeout 在指定时间后 reject
 * 3. 懒加载：第一次运行代码时才加载 Pyodide
 */

// worker.js 核心逻辑
let pyodide = null;

async function loadPyodideRuntime() {
  if (pyodide) return pyodide;
  const mod = await import("/pyodide/pyodide.js");
  const py = await mod.loadPyodide({ indexURL: "/pyodide/" });

  // 重定向 stdout：Python 的 print() 调用这个回调
  py.setStdout({ batched: (text) => { currentOutput += text + "\n"; } });
  py.setStderr({ batched: (text) => { currentError += text + "\n"; } });

  pyodide = py;
  return py;
}

self.onmessage = async (e) => {
  const { type, id, code } = e.data;
  if (type !== "execute") return;

  const py = await loadPyodideRuntime();
  currentOutput = ""; currentError = "";
  const startTime = performance.now();
  try {
    await py.runPythonAsync(code);
  } catch (err) {
    currentError = err.message;
  }
  self.postMessage({
    type: "result", id,
    output: currentOutput,
    error: currentError || null,
    executionTime: performance.now() - startTime,
  });
};

# 三种判题模式
print("""
模式 1：标准输出比对
  用户 print() 的输出 == 期望输出
模式 2：函数返回值断言
  执行用户定义的函数，断言返回值
模式 3：异常捕获测试
  验证代码是否正确抛出/处理异常
""")

// ===== 输出比对 =====
function compareOutput(actual: string, expected: string): boolean {
  // 逐行比对，忽略首尾空白和行尾空格
  const a = actual.trim().split("\n").map(l => l.trimEnd());
  const e = expected.trim().split("\n").map(l => l.trimEnd());
  if (a.length !== e.length) return false;
  return a.every((line, i) => line === e[i]);
}

/*
 * 为什么要 trim？
 * 1. 用户可能多打一个换行
 * 2. Windows 和 Unix 换行符不同
 * 3. 行尾空格不可见但会导致比较失败
 * 但不能过度宽松：只 trim 行尾，不 trim 行首（缩进可能是答案的一部分）
 */