// lib/pyodide/executor.ts 核心逻辑（简化版）

// 单例 Worker，所有组件共享
let worker: Worker | null = null;
let pyodideReady = false;
let pyodideReadyPromise: Promise<void> | null = null;

// 待处理请求映射（请求 ID → Promise）
const pendingRequests = new Map();

function createWorker() {
  const w = new Worker("/pyodide/worker.js", { type: "module" });

  w.onmessage = (e) => {
    const msg = e.data;
    if (msg.type === "result") {
      // 根据请求 ID 找到对应的 Promise 并 resolve
      const pending = pendingRequests.get(msg.id);
      if (pending) {
        clearTimeout(pending.timer);
        pendingRequests.delete(msg.id);
        pending.resolve({
          output: msg.output,
          error: msg.error,
          executionTime: msg.executionTime,
        });
      }
    }
  };
  return w;
}

export async function executePython(code: string, stdin?: string[]) {
  await ensureWorker();
  if (pyodideReadyPromise) await pyodideReadyPromise;

  const id = ++requestId;
  return new Promise((resolve) => {
    // 超时保护：5秒不返回就终止
    const timer = setTimeout(() => {
      pendingRequests.delete(id);
      resolve({ output: "", error: "执行超时（可能含无限循环）" });
    }, 5000);

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

// lib/judge/engine.ts 核心逻辑（简化版）

export async function runJudge(userCode: string, testCases: TestCase[]) {
  const results = [];

  for (const testCase of testCases) {
    // 把用户代码和测试输入组合执行
    const testCode = `
${userCode}

# 测试代码
import sys
${testCase.stdin ? `sys.stdin = ['${testCase.stdin.join("','")}']` : ''}
${testCase.testCode || ""}
`;

    const result = await executePython(testCode, testCase.stdin);

    if (result.error) {
      results.push({ passed: false, error: translatePythonError(result.error) });
    } else if (testCase.expectedOutput !== undefined) {
      // 比对输出（忽略首尾空白）
      const passed = result.output.trim() === testCase.expectedOutput.trim();
      results.push({ passed, expected: testCase.expectedOutput, actual: result.output });
    }
  }

  return {
    passed: results.every(r => r.passed),
    results,
    score: results.filter(r => r.passed).length / results.length,
  };
}

// lib/store/progressStore.ts（简化版）
import { create } from "zustand";
import { persist } from "zustand/middleware";

export const useProgressStore = create(
  persist(
    (set, get) => ({
      completedLessons: [],
      xp: 0,
      streak: 0,
      achievements: [],

      completeLesson: (lessonId: string, xpGain: number) =>
        set((state) => ({
          completedLessons: [...state.completedLessons, lessonId],
          xp: state.xp + xpGain,
        })),

      addXp: (amount: number) => set((state) => ({ xp: state.xp + amount })),
    }),
    { name: "Pyxis-V2.0.2-progress" }  // localStorage key
  )
);

// types/index.ts 课程相关类型
interface Lesson {
  id: string;                    // "s1-m1-l1"
  title: string;
  description: string;
  duration: number;              // 预计分钟数
  objectives: string[];          // 学习目标
  content: LessonContent[];      // 教学内容块
  challenge: Challenge;          // 挑战任务
  knowledgeCards: KnowledgeCard[];
  homework: Homework[];
}

// 内容块是联合类型，支持多种交互形式
type LessonContent =
  | { type: "heading"; level: 1|2|3; text: string }
  | { type: "paragraph"; text: string }
  | { type: "code"; code: string; runnable: boolean }
  | { type: "callout"; variant: string; title: string; text: string }
  | { type: "choice"; question: string; options: string[]; correctIndex: number }
  | { type: "fill-blank"; code: string; blanks: Blank[] }
  | { type: "predict"; code: string; answer: string }
  | { type: "find-bug"; buggyCode: string; fixedCode: string }
  | { type: "visual"; codeLines: string[]; steps: VisualStep[] };