// ==UserScript==
// @name         太钢职工教育助手
// @namespace    https://mooc.tisco.com.cn/helper
// @version      1.0.1
// @description  太钢职工教育培训网络平台 AI 自动答题脚本 · DeepSeek 驱动 · 单选/多选/判断自动作答
// @author       叶屿
// @license      GPL-3.0
// @antifeature  payment AI 解析功能需要验证码（免费看广告获取）或激活码（付费），用户需自备 DeepSeek API Key
// @match        *://mooc.tisco.com.cn/*
// @match        *://lms.ouchn.cn/*
// @match        *://*.lms.ouchn.cn/*
// @match        *://*.ouchn.cn/*
// @grant        GM_xmlhttpRequest
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_deleteValue
// @grant        GM_addStyle
// @connect      api.deepseek.com
// @connect      qsy.iano.cn
// @run-at       document-idle
// ==/UserScript==

(function () {
  'use strict';

  // ============== 配置 ==============
  const Config = {
    version: '1.0.1',
    appName: '太钢职工教育助手',
    platformName: '太钢职工教育培训网络平台',
    // DeepSeek 官方端点
    deepseekBaseUrl: 'https://api.deepseek.com/v1/chat/completions',
    // 模型说明：DeepSeek 官方 API 仅有 deepseek-chat（V3 对话）与 deepseek-reasoner（思考）两个端点
    models: {
      v3:    { name: 'DeepSeek V3（对话）',  modelId: 'deepseek-chat',     maxTokens: 512,  hint: 'V3 对话模型，速度快，可对比正确率' },
      v4:    { name: 'DeepSeek V4（极速）',  modelId: 'deepseek-chat',     maxTokens: 512,  hint: '日常题秒回，单选/填空首选' },
      v4pro: { name: 'DeepSeek V4 Pro（思考）', modelId: 'deepseek-reasoner', maxTokens: 8192, hint: '推理型，多选/计算/分析题更准（思考占 tokens 多，需 8K+）' },
    },
    // 解析节奏（可在设置里改）
    interQuestionMs: 1800,  // 题间间隔
    afterClickMs: 600,      // AI 返回后等待
    aiTimeoutMs: 60000,     // AI 单次调用最长 60s（思考版可能久）
    aiRetryMax: 2,          // 失败重试次数
    aiMinIntervalMs: 500,   // 两次 AI 调用最小间隔
    // 微信
    wechat: 'C919irt',
    // 验证码
    verifyUrl: 'https://qsy.iano.cn/index.php?s=/api/code/verify',
    verifyQrUrl: 'https://qsy.iano.cn/yzm.png',
    // 公告
    announceUrl: 'https://qsy.iano.cn/index.php?s=/admin/unified_manage/scriptannouncementapi',
  };

  // ============== Utils ==============
  const Utils = {
    sleep: (ms) => new Promise(r => setTimeout(r, ms)),

    safeText: (el) => {
      if (!el) return '';
      return (el.innerText || el.textContent || '').replace(/\s+/g, ' ').trim();
    },

    // 触发 React/Vue 框架能感知到的事件
    fireInputEvents(el) {
      try {
        el.dispatchEvent(new Event('input', { bubbles: true }));
        el.dispatchEvent(new Event('change', { bubbles: true }));
        el.dispatchEvent(new Event('blur', { bubbles: true }));
      } catch (_) {}
    },

    // 框架反查 setter（React 等会拦截 .value 赋值）
    nativeSet(el, value) {
      const proto = el.tagName === 'TEXTAREA'
        ? HTMLTextAreaElement.prototype
        : HTMLInputElement.prototype;
      const setter = Object.getOwnPropertyDescriptor(proto, 'value')?.set;
      if (setter) setter.call(el, value);
      else el.value = value;
      this.fireInputEvents(el);
    },

    safeClick(el) {
      if (!el) return false;
      try {
        if (typeof el.click === 'function') el.click();
        el.dispatchEvent(new MouseEvent('mousedown', { bubbles: true }));
        el.dispatchEvent(new MouseEvent('mouseup', { bubbles: true }));
        el.dispatchEvent(new MouseEvent('click', { bubbles: true }));
        return true;
      } catch (_) { return false; }
    },

    // 只触发一次点击（翻页/导航按钮用）。safeClick 会同时 el.click() + dispatch click
    // 等于点两下，对"下一题"按钮会一次跳两题，所以导航必须用这个单击版。
    singleClick(el) {
      if (!el) return false;
      try {
        if (typeof el.click === 'function') { el.click(); return true; }
        el.dispatchEvent(new MouseEvent('click', { bubbles: true }));
        return true;
      } catch (_) { return false; }
    },

    // 把 radio/checkbox 切换到目标状态。多策略 fallback：
    //   1) 点击包装（label / 选项 div）— 最贴近真人操作
    //   2) 点击 input 自己
    //   3) 原生 setter + dispatch change（React 控件兜底）
    // 每步后检查状态是否符合期望，符合就 return true
    async toggleChecked(input, node, want) {
      if (!input) return false;
      if (!!input.checked === want) return true;

      const tryAndVerify = async (clickTarget) => {
        if (!clickTarget) return false;
        this.safeClick(clickTarget);
        await this.sleep(120);
        return !!input.checked === want;
      };

      // 1) 包装（label / div）
      if (node && node !== input && await tryAndVerify(node)) return true;
      // 2) input 本身
      if (await tryAndVerify(input)) return true;
      // 3) 原生 setter + dispatch
      try {
        const setter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'checked')?.set;
        if (setter) {
          setter.call(input, want);
          input.dispatchEvent(new Event('click', { bubbles: true }));
          input.dispatchEvent(new Event('input', { bubbles: true }));
          input.dispatchEvent(new Event('change', { bubbles: true }));
        }
        await this.sleep(120);
        if (!!input.checked === want) return true;
      } catch (_) {}
      return false;
    },

    async copyText(text) {
      try {
        if (navigator.clipboard?.writeText) {
          await navigator.clipboard.writeText(text);
          return true;
        }
      } catch (_) {}
      try {
        const ta = document.createElement('textarea');
        ta.value = text;
        ta.style.cssText = 'position:fixed;opacity:0;pointer-events:none;';
        document.body.appendChild(ta);
        ta.select();
        const ok = document.execCommand('copy');
        document.body.removeChild(ta);
        return ok;
      } catch (_) { return false; }
    },

    // 简单的字符归一化（用于答案 ↔ 选项匹配）
    normalize(s) {
      return String(s || '')
        .replace(/^\s*[A-Ha-h]\s*[.、．:：)）]\s*/, '')  // 剥 "A." / "B、"
        .toLowerCase()
        .replace(/[\s.、，。,;；:：!！?？'"'""\(\)（）\-_]/g, '');
    },

    isOwnPanel(el) {
      return !!el?.closest?.('#ouchn-panel, #ouchn-settings, [data-ouchn-helper]');
    },

    // 判断一个 input 是否"可用于答题"。
    // ⚠️ 很多平台（如太钢）把原生 radio/checkbox 用 CSS 隐藏，只显示样式化的
    // label/选项 div，此时 input.offsetParent 为 null 但题目其实是可见的。
    // 所以这里检查它的"包装元素"是否被渲染出来（有尺寸），而不是看 input 自身。
    isUsableInput(inp) {
      if (!inp || this.isOwnPanel(inp)) return false;
      if (inp.disabled) return false;
      const wrap = inp.closest('label, li, [class*="option"], [class*="Option"], .answer') || inp.parentElement || inp;
      try {
        const rect = wrap.getBoundingClientRect();
        if (rect.width > 0 && rect.height > 0) return true;
      } catch (_) {}
      // 兜底：input 自身可见也算
      return inp.offsetParent !== null;
    },
  };

  // ============== Store（GM 存储）==============
  const Store = {
    get(k, def) { try { const v = GM_getValue(k); return v === undefined ? def : v; } catch (_) { return def; } },
    set(k, v)   { try { GM_setValue(k, v); } catch (_) {} },
    del(k)      { try { GM_deleteValue(k); } catch (_) {} },

    getApiKey() { return this.get('ouchn_dsk_key', ''); },
    setApiKey(v) { this.set('ouchn_dsk_key', v || ''); },

    getModel()  { return this.get('ouchn_model', 'v4'); },
    setModel(v) { this.set('ouchn_model', v); },

    getAutoNext() { return !!this.get('ouchn_autoNext', false); },
    setAutoNext(v) { this.set('ouchn_autoNext', !!v); },

    getMaxPages()  { return this.get('ouchn_maxPages', 200); },

    getInterMs()  { return this.get('ouchn_interMs', Config.interQuestionMs); },
    setInterMs(v) { this.set('ouchn_interMs', Math.max(500, parseInt(v) || Config.interQuestionMs)); },

    // ---- 刷课 ----
    getPlayRate()  { return parseFloat(this.get('ouchn_playRate', 1)) || 1; },
    setPlayRate(v) {
      let r = parseFloat(v) || 1;
      r = Math.max(0.5, Math.min(16, r));   // 0.5x ~ 16x
      this.set('ouchn_playRate', r);
      return r;
    },
    getMuted()  { return this.get('ouchn_muted', true) !== false; },   // 默认静音（绕过浏览器自动播放限制）
    setMuted(v) { this.set('ouchn_muted', !!v); },
    getAutoNextLesson()  { return !!this.get('ouchn_autoNextLesson', true); },  // 播完自动下一节
    setAutoNextLesson(v) { this.set('ouchn_autoNextLesson', !!v); },

    // ---- 验证码 ----
    getVerifyValidUntil() { return parseInt(this.get('ouchn_verifyUntil', 0), 10) || 0; },
    setVerifyValidUntil(ts) { this.set('ouchn_verifyUntil', ts || 0); },
    isVerifyValid() { return this.getVerifyValidUntil() > Math.floor(Date.now() / 1000); },
    getValidUntilStr() {
      const t = this.getVerifyValidUntil();
      return t ? new Date(t * 1000).toLocaleString('zh-CN', { hour12: false }) : '';
    },
  };

  // ============== Verify：4 位验证码 ==============
  const Verify = {
    async verifyCode(code) {
      return new Promise((resolve, reject) => {
        const c = String(code || '').trim();
        if (!c || c.length !== 4) return reject('请输入 4 位验证码');
        if (typeof GM_xmlhttpRequest !== 'function') return reject('GM_xmlhttpRequest 不可用');
        GM_xmlhttpRequest({
          method: 'POST',
          url: Config.verifyUrl,
          headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
          data: 'code=' + encodeURIComponent(c),
          timeout: 15000,
          onload: (resp) => {
            try {
              const d = JSON.parse(resp.responseText);
              if (d.code === 1 && d.data && d.data.valid) {
                const validUntil = parseInt(d.data.valid_until, 10);
                Store.setVerifyValidUntil(validUntil);
                const str = d.data.valid_until_str || new Date(validUntil * 1000).toLocaleString('zh-CN');
                resolve({ validUntil, validUntilStr: str });
              } else {
                reject(d.msg || '验证码无效或已过期');
              }
            } catch (_) {
              reject('验证响应解析失败');
            }
          },
          onerror: () => reject('网络错误'),
          ontimeout: () => reject('请求超时'),
        });
      });
    },
  };

  // ============== Announce：远程公告 ==============
  const Announce = {
    fetch(panel) {
      if (!panel || typeof GM_xmlhttpRequest !== 'function') return;
      try {
        GM_xmlhttpRequest({
          method: 'GET',
          url: Config.announceUrl,
          timeout: 8000,
          onload: (resp) => {
            try {
              const res = JSON.parse(resp.responseText);
              if (res.code !== 1 || !res.data || !res.data.enabled) return;
              this.render(panel, res.data);
            } catch (_) { /* silent */ }
          },
          onerror: () => {},
          ontimeout: () => {},
        });
      } catch (_) {}
    },
    render(panel, data) {
      const root = panel.querySelector('#oc-announce');
      const titleEl = panel.querySelector('#oc-announce-title');
      const contentEl = panel.querySelector('#oc-announce-content');
      const closeEl = panel.querySelector('#oc-announce-close');
      if (!root || !titleEl || !contentEl) return;
      const type = ['info','warning','error','success'].includes(data.type) ? data.type : 'info';
      const icon = { info: '📢', warning: '⚠️', error: '❌', success: '✅' }[type];
      const iconEl = root.querySelector('.oc-announce-icon');
      if (iconEl) iconEl.textContent = icon;
      titleEl.textContent = data.title || '公告';
      // content 允许富文本，但只信任 <br><b><i><u><strong><em> 这些标签
      contentEl.innerHTML = this._sanitize(data.content || '');
      root.classList.remove('info', 'warning', 'error', 'success');
      root.classList.add(type, 'show');
      if (closeEl) closeEl.onclick = () => { root.classList.remove('show'); };
    },
    _sanitize(html) {
      // 简易白名单：只保留 <br/b/i/u/strong/em/span>
      const tmp = document.createElement('div');
      tmp.innerHTML = String(html);
      tmp.querySelectorAll('*').forEach(el => {
        const tag = el.tagName.toLowerCase();
        if (!['br','b','i','u','strong','em','span'].includes(tag)) {
          el.replaceWith(document.createTextNode(el.textContent || ''));
          return;
        }
        // 清掉所有事件属性
        [...el.attributes].forEach(attr => {
          if (/^on/i.test(attr.name) || attr.name === 'style') el.removeAttribute(attr.name);
        });
      });
      return tmp.innerHTML;
    },
  };

  // ============== 状态 ==============
  let isRunning = false;
  let stopRequested = false;
  let isPaused = false;
  let stats = { total: 0, success: 0, failed: 0, skipped: 0 };
  let lastAiCallAt = 0;
  // 暂停时阻塞，直到恢复或停止
  async function waitWhilePaused(logger) {
    let told = false;
    while (isPaused && !stopRequested) {
      if (!told) { logger?.('⏸ 已暂停（点击 ▶️ 继续 恢复 / ⏹ 停止 终止）', 'warn'); told = true; }
      await Utils.sleep(300);
    }
  }

  // ============== AI: DeepSeek ==============
  const AI = {
    // 题型常量
    TYPE_SINGLE: 'single', TYPE_MULTI: 'multi', TYPE_JUDGE: 'judge',
    TYPE_FILL: 'fill', TYPE_ESSAY: 'essay', TYPE_UNKNOWN: 'unknown',

    buildPrompt(question, options, type) {
      const optStr = options?.length
        ? options.map((o, i) => `${String.fromCharCode(65 + i)}. ${o}`).join('\n')
        : '';
      switch (type) {
        case this.TYPE_SINGLE:
          return `你是答题助手。下面是一道单选题，请只输出正确选项的"原文内容"（不要带 A./B./字母编号），如果不确定就选最合理的一项。

【题目】${question}

【选项】
${optStr}

要求：
- 只输出一个选项的原文，不解释
- 不要带字母编号
- 不要带 "答案：" 等前缀`;

        case this.TYPE_MULTI:
          return `你是答题助手。下面是一道多选题。

【题目】${question}

【选项】
${optStr}

输出格式（必须严格遵守，否则视为错答）：
最后一行必须是：答案：X||Y||Z
其中 X/Y/Z 是正确选项的"原文内容"（不要字母 ABCD 编号，不要解释，不要省略号）。
示例：
答案：塑性和韧性||硬度和强度||化学成分`;

        case this.TYPE_JUDGE:
          return `你是答题助手。下面是一道判断题，请只回答"正确"或"错误"。

【题目】${question}

【选项参考】
${optStr || '正确 / 错误'}

要求：只输出 "正确" 或 "错误" 两字，不要其他内容`;

        case this.TYPE_FILL:
          return `你是答题助手。下面是一道填空题，请直接给出答案。

【题目】${question}

要求：
- 若题目含多个空，用 "||" 分隔每空答案
- 不要带空号 / 序号 / 引号 / 答案前缀
- 简洁、准确`;

        case this.TYPE_ESSAY:
          return `你是答题助手。下面是一道简答/论述题，请用简洁专业的中文作答。

【题目】${question}

要求：
- 200-400 字
- 分点作答（用 "1." "2." 标记或自然分段）
- 不要寒暄、不要题目重述`;

        default:
          return `请回答下面的题目：\n${question}\n\n${optStr ? '【可选项】\n' + optStr : ''}`;
      }
    },

    async call(question, options, type, logger) {
      const apiKey = Store.getApiKey();
      if (!apiKey) throw new Error('未配置 DeepSeek API Key，请到 ⚙️ 设置填写');
      // 节流
      const since = Date.now() - lastAiCallAt;
      if (since < Config.aiMinIntervalMs) {
        await Utils.sleep(Config.aiMinIntervalMs - since);
      }
      const modelKey = Store.getModel();
      const modelConf = Config.models[modelKey] || Config.models.v4;
      const prompt = this.buildPrompt(question, options, type);

      const body = {
        model: modelConf.modelId,
        messages: [{ role: 'user', content: prompt }],
        max_tokens: modelConf.maxTokens,
        temperature: 0.1,
        stream: false,
      };

      let lastErr;
      for (let attempt = 1; attempt <= Config.aiRetryMax + 1; attempt++) {
        try {
          lastAiCallAt = Date.now();
          const raw = await this._request(apiKey, body);
          const msg = raw?.choices?.[0]?.message || {};
          let content = msg.content || '';
          const reasoning = msg.reasoning_content || '';
          const finish = raw?.choices?.[0]?.finish_reason;

          // ⚠️ reasoner 截断兜底：思考耗尽 tokens 没产出正式答案
          // → 自动换 deepseek-chat（非思考模型）重新跑一次，确保拿到答案
          if (modelConf.modelId === 'deepseek-reasoner' && finish === 'length' && !content) {
            logger?.(`  ⚠️ V4 Pro 思考超出 ${modelConf.maxTokens} tokens 仍未给出答案，自动降级到 V4 重试...`);
            const fbBody = {
              model: 'deepseek-chat',
              messages: [{ role: 'user', content: prompt }],
              max_tokens: 512,
              temperature: 0.1,
              stream: false,
            };
            await Utils.sleep(Config.aiMinIntervalMs);
            lastAiCallAt = Date.now();
            const fbRaw = await this._request(apiKey, fbBody);
            const fbContent = fbRaw?.choices?.[0]?.message?.content || '';
            if (fbContent) {
              const answers = this._parseAnswer(fbContent, type);
              answers._raw = fbContent;
              answers._fallback = 'v4';
              return answers;
            }
            // 兜底也失败，继续走正常流程（用 reasoning 凑答案）
          }

          // 正常路径：优先用 content（正式答案），content 空时退而求其次用 reasoning
          let used = content || reasoning;
          if (!used) throw new Error('AI 返回内容为空');
          // content 没"答案："行而 reasoning 有，合并以便提取
          if (content && reasoning && !/答案[：:]/i.test(content) && /答案[：:]/i.test(reasoning)) {
            used = reasoning + '\n' + content;
          }
          const answers = this._parseAnswer(used, type);
          answers._raw = used;
          return answers;
        } catch (e) {
          lastErr = e;
          logger?.(`  ⚠️ AI 第 ${attempt} 次失败：${e.message || e}`);
          if (attempt <= Config.aiRetryMax) {
            await Utils.sleep(1000 * attempt);
          }
        }
      }
      throw lastErr || new Error('AI 调用失败');
    },

    _request(apiKey, body) {
      return new Promise((resolve, reject) => {
        if (typeof GM_xmlhttpRequest !== 'function') {
          return reject(new Error('GM_xmlhttpRequest 不可用，请用 Tampermonkey 安装本脚本'));
        }
        GM_xmlhttpRequest({
          method: 'POST',
          url: Config.deepseekBaseUrl,
          timeout: Config.aiTimeoutMs,
          headers: {
            'Content-Type': 'application/json',
            'Authorization': 'Bearer ' + apiKey,
          },
          data: JSON.stringify(body),
          onload: (resp) => {
            if (resp.status >= 200 && resp.status < 300) {
              try { resolve(JSON.parse(resp.responseText)); }
              catch (e) { reject(new Error('解析响应失败：' + e.message)); }
            } else {
              let msg = `HTTP ${resp.status}`;
              try {
                const j = JSON.parse(resp.responseText);
                msg += ' · ' + (j.error?.message || j.message || resp.responseText.slice(0, 200));
              } catch (_) { msg += ' · ' + resp.responseText.slice(0, 200); }
              reject(new Error(msg));
            }
          },
          onerror: () => reject(new Error('网络请求失败')),
          ontimeout: () => reject(new Error('请求超时')),
        });
      });
    },

    _parseAnswer(content, type) {
      let raw = String(content || '').trim();

      // ESSAY 直接整段返回
      if (type === this.TYPE_ESSAY) return [raw];

      // 1) 优先抓"答案：..." 整行（reasoner 模型按 prompt 要求会输出这一行）
      //    支持 全角/半角冒号、答案/正确答案/答 前缀
      let txt = '';
      const ansLineMatch = raw.match(/(?:^|\n)\s*(?:正确答案|答案|答)\s*[：:]\s*([^\n]+)/i);
      if (ansLineMatch) {
        txt = ansLineMatch[1].trim();
      } else {
        // 2) 没明确 "答案：" 行 → 取最后一行非空（reasoner 思考完通常把答案放最后）
        const lines = raw.split('\n').map(s => s.trim()).filter(Boolean);
        txt = lines[lines.length - 1] || raw;
      }

      // 3) 清理常见前缀/包裹
      txt = txt
        .replace(/^[\*\#\-\>\s]+/, '')
        .replace(/^["'「『（(]+/, '')
        .replace(/["'」』）)]+$/, '')
        .replace(/^答案[：:]\s*/i, '')
        .replace(/^正确答案[：:]\s*/i, '')
        .replace(/^答[：:]\s*/i, '')
        .replace(/^选\s*[：:]\s*/i, '')
        .trim();

      // JUDGE 提取"正确/错误"
      if (type === this.TYPE_JUDGE) {
        if (/正确|对|是|true|^t$|✓|right|yes/i.test(txt)) return ['正确'];
        if (/错误|错|否|false|^f$|✗|wrong|no/i.test(txt)) return ['错误'];
        return [txt];
      }

      // 4) 多答案分隔符兼容：|| / | / 、 / ， / , / ；/ ; / 顿号
      const splitRe = /\s*(?:\|\||[、，,；;])\s*/;
      let parts = splitRe.test(txt)
        ? txt.split(splitRe).map(s => s.trim()).filter(Boolean)
        : [txt];

      // 5) 剥离每项前可能的字母编号：如 "A. 塑性和韧性" → "塑性和韧性"
      parts = parts.map(p => p.replace(/^[A-Ha-h]\s*[.\．\、\:\：\)\）]\s*/, '').trim()).filter(Boolean);

      // 单选只取一个
      if (type === this.TYPE_SINGLE) return parts.slice(0, 1);
      return parts;
    },
  };

  // ============== Player：视频刷课 ==============
  const Player = {
    timer: null,
    running: false,
    logger: null,
    lastSrc: '',
    stuckCount: 0,
    quizBusy: false,

    // 收集所有同源 document（含 iframe）里的 video
    _allVideos() {
      const vids = [];
      const scan = (doc) => {
        try {
          doc.querySelectorAll('video').forEach(v => vids.push(v));
          doc.querySelectorAll('iframe').forEach(f => {
            try { if (f.contentDocument) scan(f.contentDocument); } catch (_) {}
          });
        } catch (_) {}
      };
      scan(document);
      return vids;
    },

    // 取当前正在显示的主视频（优先有尺寸、时长 > 0 的）
    currentVideo() {
      const vids = this._allVideos().filter(v => {
        try { const r = v.getBoundingClientRect(); return r.width > 50 && r.height > 50; } catch (_) { return false; }
      });
      if (!vids.length) return null;
      // 优先未播完的
      const playing = vids.find(v => v.currentTime < (v.duration || Infinity) - 1);
      return playing || vids[0];
    },

    applyRate(v, rate) {
      if (!v) return;
      try {
        v.playbackRate = rate;
        // 有些播放器会在 ratechange 时重置，监听并强制回写
        if (!v.__ocRateHook) {
          v.__ocRateHook = true;
          v.addEventListener('ratechange', () => {
            const want = Store.getPlayRate();
            if (Math.abs(v.playbackRate - want) > 0.01) {
              try { v.playbackRate = want; } catch (_) {}
            }
          });
        }
      } catch (_) {}
    },

    async play(v) {
      if (!v) return;
      try {
        if (Store.getMuted()) v.muted = true;
        this.applyRate(v, Store.getPlayRate());
        const p = v.play();
        if (p && p.catch) p.catch(() => {
          // 自动播放被拦截 → 静音后重试一次
          try { v.muted = true; v.play(); } catch (_) {}
        });
      } catch (_) {}
    },

    // 找"下一节"按钮 / 目录里下一个未学章节
    findNextLesson() {
      const nextRe = /^(下一节|下一集|下一课|下一章|下一个|next)\s*[>›→»]?$/i;
      const dangerRe = /(交卷|提交|finish|submit)/i;
      const cands = document.querySelectorAll('button, a, [role="button"], [class*="next"]');
      for (const b of cands) {
        if (Utils.isOwnPanel(b)) continue;
        const t = (Utils.safeText(b) || b.getAttribute('aria-label') || '').trim();
        if (!t || dangerRe.test(t) || !nextRe.test(t)) continue;
        const r = b.getBoundingClientRect();
        if (r.width > 0 && r.height > 0) return b;
      }
      return null;
    },

    start(logger) {
      if (this.running) { logger?.('⚠️ 刷课已在运行'); return; }
      this.running = true;
      this.logger = logger;
      this.stuckCount = 0;
      this.noVidWarned = false;
      logger?.(`🎬 开始自动刷课（倍速 ${Store.getPlayRate()}x${Store.getMuted() ? ' · 静音' : ''}）`);
      const all = this._allVideos();
      const v = this.currentVideo();
      if (v) {
        logger?.(`📺 找到视频（共 ${all.length} 个），开始播放…`, 'ok');
        this.play(v);
      } else if (all.length) {
        logger?.(`⚠️ 页面有 ${all.length} 个 <video>，但都太小/未显示，暂未播放（切到视频页后会自动开始）`, 'warn');
      } else {
        logger?.('⚠️ 当前页面未找到 <video>。请切到视频课页面；若播放器用的是非标准内核/跨域 iframe，可能无法控制', 'warn');
      }
      this.timer = setInterval(() => this.tick(), 3000);
    },

    stop() {
      this.running = false;
      if (this.timer) { clearInterval(this.timer); this.timer = null; }
      this.logger?.('⏹ 已停止刷课');
    },

    setRate(rate) {
      const r = Store.setPlayRate(rate);
      const v = this.currentVideo();
      if (v) this.applyRate(v, r);
      this.logger?.(`⏩ 倍速已设为 ${r}x`);
      return r;
    },

    tick() {
      if (!this.running) return;

      // 视频内弹题：检测到题目就暂停视频、自动作答，再继续
      if (!this.quizBusy && Detector.findQuestions().length) {
        this.quizBusy = true;
        const v0 = this.currentVideo();
        try { v0 && v0.pause(); } catch (_) {}
        this.logger?.('❓ 检测到视频弹题，暂停并自动作答…', 'warn');
        Runner.answerPopQuiz((m, l) => this.logger?.(m, l)).then(() => {
          this.quizBusy = false;
          const v1 = this.currentVideo();
          if (v1 && this.running) this.play(v1);
        }).catch(() => { this.quizBusy = false; });
        return;
      }
      if (this.quizBusy) return;

      const v = this.currentVideo();
      if (!v) {
        // 没视频 → 可能是文档/PPT 页或加载中
        if (!this.noVidWarned) {
          this.noVidWarned = true;
          this.logger?.('⏳ 暂未检测到可控视频，等待页面加载/切换…（文档页请用「文档/PPT翻页」）', 'warn');
        }
        return;
      }
      this.noVidWarned = false;
      // 保证倍速 & 静音状态
      this.applyRate(v, Store.getPlayRate());
      if (Store.getMuted() && !v.muted) v.muted = true;

      const dur = v.duration || 0;
      const cur = v.currentTime || 0;

      // 播完 → 自动下一节
      if (dur > 0 && cur >= dur - 1.2) {
        if (Store.getAutoNextLesson()) {
          const next = this.findNextLesson();
          if (next) {
            this.logger?.('✅ 本节已学完，前往下一节…', 'ok');
            Utils.singleClick(next);
            this.lastSrc = '';
            return;
          }
          this.logger?.('🏁 已是最后一节（未找到"下一节"），刷课结束', 'warn');
          this.stop();
          return;
        }
      }

      // 暂停了 → 续播
      if (v.paused && !v.ended) {
        this.play(v);
      }

      // 卡住检测（src 没变且 currentTime 不动）
      const srcKey = (v.currentSrc || v.src || '') + '@' + Math.floor(cur);
      if (srcKey === this.lastSrc) {
        this.stuckCount++;
        if (this.stuckCount === 4) this.logger?.('⚠️ 进度疑似卡住，尝试续播…', 'warn');
        if (this.stuckCount >= 4) this.play(v);
      } else {
        this.stuckCount = 0;
      }
      this.lastSrc = srcKey;
    },
  };

  // ============== Doc：文档 / PPT 自动翻页 ==============
  const Doc = {
    // 找翻页按钮："下一页"语义；PPT/文档阅读器常见结构
    findNextPageBtn() {
      const nextRe = /^(下一页|下页|next\s*page|next|向下|►|▶|»|›|→)\s*$/i;
      const dangerRe = /(交卷|提交|finish|submit|下一节|下一章)/i;
      const cands = document.querySelectorAll(
        'button, a, [role="button"], [class*="next"], [class*="Next"], [class*="arrow-right"], [class*="right-arrow"]'
      );
      for (const b of cands) {
        if (Utils.isOwnPanel(b)) continue;
        if (b.disabled || b.getAttribute('aria-disabled') === 'true') continue;
        if (/\b(disabled|is-disabled)\b/i.test(b.className || '')) continue;
        const t = (Utils.safeText(b) || b.getAttribute('aria-label') || b.title || '').trim();
        if (dangerRe.test(t)) continue;
        if (!nextRe.test(t) && !/next|right/i.test(b.className || '')) continue;
        const r = b.getBoundingClientRect();
        if (r.width > 0 && r.height > 0) return b;
      }
      return null;
    },

    // 读取页码信息 "3 / 20" → {cur:3,total:20}
    readPageInfo() {
      const re = /(\d+)\s*\/\s*(\d+)/;
      const nodes = document.querySelectorAll('[class*="page"], [class*="Page"], [class*="pagination"], [class*="indicator"]');
      for (const n of nodes) {
        if (Utils.isOwnPanel(n)) continue;
        const m = (Utils.safeText(n) || '').match(re);
        if (m) return { cur: +m[1], total: +m[2] };
      }
      return null;
    },

    running: false,
    timer: null,
    logger: null,
    lastPage: -1,
    stuck: 0,

    start(logger) {
      if (this.running) { logger?.('⚠️ 文档翻页已在运行'); return; }
      this.running = true; this.logger = logger; this.lastPage = -1; this.stuck = 0;
      logger?.('📄 开始文档/PPT 自动翻页');
      this.tick();
      this.timer = setInterval(() => this.tick(), 2500);
    },
    stop() {
      this.running = false;
      if (this.timer) { clearInterval(this.timer); this.timer = null; }
      this.logger?.('⏹ 已停止文档翻页');
    },
    tick() {
      if (!this.running) return;
      const info = this.readPageInfo();
      if (info && info.cur >= info.total) {
        // 到末页 → 尝试进入下一节
        const nextLesson = Player.findNextLesson();
        if (nextLesson) {
          this.logger?.(`✅ 文档已翻完（${info.cur}/${info.total}），前往下一节…`, 'ok');
          Utils.singleClick(nextLesson);
          this.lastPage = -1;
          return;
        }
        this.logger?.(`🏁 文档已翻完（${info.cur}/${info.total}），未找到下一节`, 'warn');
        this.stop();
        return;
      }
      const btn = this.findNextPageBtn();
      if (!btn) { this.logger?.('⚠️ 未找到"下一页"按钮', 'warn'); return; }
      // 防卡：页码没变就计数，连续多次仍点
      if (info && info.cur === this.lastPage) {
        this.stuck++;
      } else { this.stuck = 0; }
      if (info) this.lastPage = info.cur;
      Utils.singleClick(btn);
      if (info) this.logger?.(`📄 翻到第 ${info.cur + 1} 页…`);
    },
  };

  // ============== Detector：找题目 / 选项 / 题型 ==============
  const Detector = {
    // 一个容器是否"看起来像一道完整题目"
    _looksLikeQuestion(el) {
      if (!el || Utils.isOwnPanel(el)) return false;
      const radios = el.querySelectorAll('input[type="radio"]');
      const checks = el.querySelectorAll('input[type="checkbox"]');
      const texts  = el.querySelectorAll('input[type="text"], textarea');
      // 单选/多选/判断至少要 2 个 radio/checkbox；填空/简答至少 1 个 text/textarea
      if (radios.length >= 2) return true;
      if (checks.length >= 2) return true;
      if (texts.length >= 1 && radios.length === 0 && checks.length === 0) return true;
      return false;
    },

    // 同源 iframe 内的 document 集合（按顶层 + 嵌套 iframe 收集）
    _allDocs() {
      const docs = [document];
      const scan = (doc) => {
        try {
          doc.querySelectorAll('iframe').forEach(f => {
            try {
              const d = f.contentDocument;
              if (d && !docs.includes(d)) { docs.push(d); scan(d); }
            } catch (_) { /* 跨域 */ }
          });
        } catch (_) {}
      };
      scan(document);
      return docs;
    },

    // 找出页面上所有题目容器（启发式，覆盖常见 LMS DOM）
    findQuestions() {
      const candidates = new Set();
      const docs = this._allDocs();
      // 题目容器特征：明确语义类名
      const selectors = [
        '.question:not(.questions)',
        '.exam-question', '.quiz-question',
        '[class*="question-item"]', '[class*="QuestionItem"]',
        '[class*="exam-item"]:not([class*="exam-item-list"])',
        '[class*="quiz-item"]:not([class*="quiz-item-list"])',
        '[data-question-id]', '[data-questionid]', '[data-quiz-id]',
        // Moodle 风格
        '.que', '.formulation',
      // 常见学习平台包装
        '[class*="single"][class*="choice"]',
        '[class*="multi"][class*="choice"]',
        '[class*="judge"]', '[class*="fill"]',
      ];
      docs.forEach(doc => {
        selectors.forEach(sel => {
          try {
            doc.querySelectorAll(sel).forEach(el => {
              if (!this._looksLikeQuestion(el)) return;
              const rect = el.getBoundingClientRect();
              if (rect.height > window.innerHeight * 4) return;
              candidates.add(el);
            });
          } catch (_) { /* 非法 CSS */ }
        });
      });

      // ---- 核心兜底：从每个 radio/checkbox 向上爬 DOM，找包含 ≥2 个同类输入的最小父级 ----
      // 这种方法不依赖 input.name 属性，适用于 React/Vue LMS（很多框架 radio 无 name）
      const allInputs = [];
      docs.forEach(doc => {
        try {
          doc.querySelectorAll('input[type="radio"], input[type="checkbox"]').forEach(i => {
            if (Utils.isUsableInput(i)) allInputs.push(i);
          });
        } catch (_) {}
      });
      const seenInputs = new WeakSet();
      for (const inp of allInputs) {
        if (seenInputs.has(inp)) continue;
        // Step 1: 找最小的父级，里面 radio/checkbox ≥ 2
        let p = inp.parentElement;
        let groupP = null;
        const bodyOfInp = inp.ownerDocument?.body;
        while (p && p !== bodyOfInp && !Utils.isOwnPanel(p)) {
          const cnt = p.querySelectorAll('input[type="radio"], input[type="checkbox"]').length;
          if (cnt >= 2) { groupP = p; break; }
          p = p.parentElement;
        }
        if (!groupP) continue;
        const groupInputs = Array.from(groupP.querySelectorAll('input[type="radio"], input[type="checkbox"]'));
        // Step 2: 再向上爬，找到包含题干文字的容器（停止条件：上一层包含了其他题的 radio）
        let container = groupP;
        const optTxt = groupInputs
          .map(i => Utils.safeText(i.closest('label, li, [class*="option"]') || i))
          .join('');
        const optLen = optTxt.length;
        for (let depth = 0; depth < 6; depth++) {
          const next = container.parentElement;
          if (!next || next === bodyOfInp || Utils.isOwnPanel(next)) break;
          // 上一层是否包含了别的题的 radio？是则停止
          const upRadios = next.querySelectorAll('input[type="radio"], input[type="checkbox"]').length;
          if (upRadios > groupInputs.length) break;
          const stemLen = Utils.safeText(next).length;
          container = next;
          // 上层文本明显多于选项总和 → 已经包含题干，可以用这一层
          if (stemLen - optLen > 8) break;
        }
        candidates.add(container);
        groupInputs.forEach(i => seenInputs.add(i));
      }

      // 文本框填空题：向上爬找上下文容器
      docs.forEach(doc => {
        try {
          doc.querySelectorAll('input[type="text"], textarea').forEach(inp => {
            if (!Utils.isUsableInput(inp)) return;
            const bodyOfInp = inp.ownerDocument?.body;
            let wrap = inp.parentElement;
            for (let depth = 0; depth < 6 && wrap && wrap !== bodyOfInp; depth++) {
              if (Utils.isOwnPanel(wrap)) break;
              if (Utils.safeText(wrap).length > 20) break;
              wrap = wrap.parentElement;
            }
            if (wrap && !Utils.isOwnPanel(wrap)) candidates.add(wrap);
          });
        } catch (_) {}
      });

      // 去重嵌套：保留**最外层**容器
      const arr = Array.from(candidates);
      return arr.filter(a => !arr.some(b => b !== a && b.contains(a)));
    },

    // ---- 调试：扫描页面，输出关键统计 ----
    diagnose() {
      const docs = this._allDocs();
      const allRadios = [], allChecks = [], allTexts = [], allTareas = [];
      docs.forEach(doc => {
        try {
          doc.querySelectorAll('input[type="radio"]').forEach(r => allRadios.push(r));
          doc.querySelectorAll('input[type="checkbox"]').forEach(c => allChecks.push(c));
          doc.querySelectorAll('input[type="text"]').forEach(t => allTexts.push(t));
          doc.querySelectorAll('textarea').forEach(t => allTareas.push(t));
        } catch (_) {}
      });
      // 顶层 iframe（含跨域）
      const topIframes = Array.from(document.querySelectorAll('iframe'));
      // 收集 radio 的常见 class 名
      const sampleClasses = new Set();
      const namedCount = allRadios.filter(r => r.name).length;
      const visibleRadios = allRadios.filter(r => Utils.isUsableInput(r)).length;
      allRadios.slice(0, 5).forEach(r => {
        const wrap = r.closest('label, [class]');
        if (wrap?.className) sampleClasses.add(String(wrap.className).slice(0, 80));
      });
      const iframeInfo = topIframes.map(f => ({
        src: (f.src || '').slice(0, 80),
        sameOrigin: (() => { try { return !!f.contentDocument; } catch (_) { return false; } })(),
        rect: f.getBoundingClientRect(),
      })).filter(i => i.rect.width > 100);
      return {
        docsScanned: docs.length,
        radios: allRadios.length, visibleRadios, namedRadios: namedCount,
        checkboxes: allChecks.length, texts: allTexts.length, textareas: allTareas.length,
        iframes: topIframes.length, sameOriginIframes: iframeInfo.filter(i => i.sameOrigin).length,
        sampleWrapperClasses: Array.from(sampleClasses),
        iframeUrls: iframeInfo.map(i => i.src),
        questionsFound: this.findQuestions().length,
        url: location.href.slice(0, 120),
      };
    },

    // 提取题干文本
    extractStem(container) {
      // 1) 优先找有明确语义的标题元素
      const stemSel = [
        '[class*="stem"]', '[class*="Stem"]',
        '[class*="qContent"]', '[class*="question-content"]', '[class*="QuestionContent"]',
        '[class*="title"]:not([class*="option"])', '[class*="Title"]:not([class*="Option"])',
        '.qtext', '.question-text', '.formulation', '.q-title',
        'h3', 'h4',
      ];
      for (const s of stemSel) {
        try {
          const el = container.querySelector(s);
          if (el && !el.querySelector('input[type="radio"], input[type="checkbox"]')) {
            const t = Utils.safeText(el);
            if (t.length > 5) return t;
          }
        } catch (_) {}
      }
      // 2) 克隆容器，剥掉选项/输入区/题型标签后取剩余文本
      const clone = container.cloneNode(true);
      clone.querySelectorAll(
        'input, textarea, select, button, ' +
        '[class*="option"], [class*="Option"], ' +
        '[class*="answer-input"], [class*="Answer"], ' +
        '[class*="choice"], [class*="Choice"], ' +
        '.answers, label'
      ).forEach(n => n.remove());
      let t = Utils.safeText(clone);
      // 剥掉常见的"单选题 (2分)" / "多选题 (2分)" / "判断题" 等元数据
      t = t.replace(/^(单选题|多选题|判断题|填空题|简答题|论述题)\s*[\(（]?\s*\d*\s*分?\s*[\)）]?\s*/g, '').trim();
      // 剥前导题号 "1." / "1、" / "第1题"
      t = t.replace(/^\s*第?\s*\d+\s*[.、．:：题]\s*/, '').trim();
      if (t.length >= 5) return t.slice(0, 800);
      // 3) 兜底：取 container.innerText 但 排除选项文本
      const optsText = Array.from(container.querySelectorAll(
        'label, [class*="option"], [class*="Option"], [class*="choice"]'
      )).map(n => Utils.safeText(n)).join(' ');
      let fullTxt = Utils.safeText(container);
      if (optsText) {
        // 逐个剥掉每个选项文本
        Array.from(container.querySelectorAll('label, [class*="option"]')).forEach(n => {
          const ot = Utils.safeText(n);
          if (ot) fullTxt = fullTxt.replace(ot, ' ');
        });
      }
      fullTxt = fullTxt.replace(/\s+/g, ' ')
        .replace(/^(单选题|多选题|判断题|填空题|简答题|论述题)\s*[\(（]?\s*\d*\s*分?\s*[\)）]?\s*/g, '')
        .replace(/^\s*第?\s*\d+\s*[.、．:：题]\s*/, '')
        .trim();
      return fullTxt.slice(0, 800) || '（题干为空，请人工核对）';
    },

    // 给单个 radio/checkbox 找它对应的选项文字 + 文字所在节点。
    // 太钢等平台 radio 圆圈与文字是分离元素，需多策略兜底。
    _optionTextFor(inp, container) {
      const strip = (t) => (t || '').replace(/^\s*[A-Ha-h]\s*[.、．:：)）]\s*/, '').trim();
      // 1) label[for=id]
      try {
        if (inp.id) {
          const l = inp.ownerDocument.querySelector(`label[for="${CSS.escape(inp.id)}"]`);
          const t = strip(Utils.safeText(l));
          if (t) return { text: t, node: l };
        }
      } catch (_) {}
      // 2) 向上找"仍只含这一个输入框"的最大祖先；中途遇到带文字的就用
      let node = inp;
      let p = inp.parentElement;
      for (let d = 0; d < 6 && p && p !== container; d++) {
        const cnt = p.querySelectorAll('input[type="radio"], input[type="checkbox"]').length;
        if (cnt !== 1) break;          // 祖先含别的选项了，停在上一层 node
        node = p;
        const t = strip(Utils.safeText(p));
        if (t) return { text: t, node: p };
        p = p.parentElement;
      }
      // 3) node 本身无文字 → 看它的相邻兄弟（文字常是 radio 包装的下一个兄弟）
      for (const sib of [node.nextElementSibling, node.previousElementSibling, inp.nextElementSibling, inp.previousElementSibling]) {
        const t = strip(Utils.safeText(sib));
        if (t) return { text: t, node };
      }
      // 4) 兜底：父级整段文字（可能含别的选项，匹配时靠 includes 也能用）
      const t = strip(Utils.safeText(node.parentElement || node));
      return { text: t, node };
    },

    // 提取选项 [{ text, node, input }]
    extractOptions(container) {
      const out = [];
      // 优先按 radio/checkbox 反查
      const inputs = container.querySelectorAll('input[type="radio"], input[type="checkbox"]');
      inputs.forEach(inp => {
        if (Utils.isOwnPanel(inp)) return;
        const { text, node } = this._optionTextFor(inp, container);
        // node 用于点击：优先用带文字的包装，没有就退回 input 自身
        const clickNode = node || inp.closest('label, li, [class*="option"]') || inp.parentElement || inp;
        out.push({ text: text || '', node: clickNode, input: inp });
      });
      if (out.length && out.some(o => o.text)) return out;
      if (out.length) return out;  // 即便都没文字也返回，避免误判为"无选项"
      // 文本框 / textarea
      const textInputs = container.querySelectorAll('input[type="text"], textarea');
      textInputs.forEach(inp => {
        if (Utils.isOwnPanel(inp)) return;
        out.push({ text: '__FILL__', node: inp, input: inp, isFill: true });
      });
      return out;
    },

    // 推断题型
    detectType(container, opts) {
      const txt = Utils.safeText(container);
      // 判断题（包含"对/错"或"正确/错误"且只有 2 个选项）
      if (opts.length === 2) {
        const optTxt = opts.map(o => o.text).join('|');
        if (/^(对|错|正确|错误|是|否|T|F|True|False)$/i.test(opts[0].text) ||
            /对错|正确.*错误|true.*false|判断/i.test(txt + optTxt)) {
          return AI.TYPE_JUDGE;
        }
      }
      if (/判断题|true.*or.*false/i.test(txt)) return AI.TYPE_JUDGE;
      // 多选
      if (opts.some(o => o.input?.type === 'checkbox')) return AI.TYPE_MULTI;
      if (/多选题|多项选择|all\s+that\s+apply/i.test(txt)) return AI.TYPE_MULTI;
      // 单选
      if (opts.some(o => o.input?.type === 'radio')) return AI.TYPE_SINGLE;
      if (/单选题|单项选择/i.test(txt)) return AI.TYPE_SINGLE;
      // 填空 / 简答
      if (opts.some(o => o.isFill)) {
        const ta = opts.find(o => o.input?.tagName === 'TEXTAREA');
        if (ta || /简答|论述|分析|阐述/i.test(txt)) return AI.TYPE_ESSAY;
        return AI.TYPE_FILL;
      }
      return AI.TYPE_UNKNOWN;
    },

    // 判断当前题目是否已经作答
    isAnswered(container, opts) {
      // radio/checkbox: 任一已选
      if (opts.some(o => o.input?.checked)) return true;
      // text/textarea: 已填值
      if (opts.some(o => o.isFill && o.input?.value?.trim())) return true;
      return false;
    },

    // 找"下一题/下一页"按钮。⚠️ 这是考试页，绝不返回交卷/提交类按钮。
    // 返回 { btn, isLast }：isLast=true 表示找不到下一页（已到最后），调用方应停下让用户手动交卷。
    findNextButton() {
      // 只接受明确的"下一"语义；继续/next 也算，但要求是纯按钮文字
      const nextRe = /^(下一题|下一页|下一步|下一道|next|继续作答)\s*[>›→»]?$/i;
      // 任何疑似交卷/提交/结束的，一律拒绝点击
      const dangerRe = /(交卷|提交|结束|完成考试|finish|submit|确认)/i;
      const candidates = document.querySelectorAll(
        'button, a, [role="button"], input[type="submit"], input[type="button"], [class*="next"]'
      );
      for (const btn of candidates) {
        if (Utils.isOwnPanel(btn)) continue;
        // 自定义按钮的禁用态不一定是原生 disabled 属性，多查几种
        if (btn.disabled) continue;
        if (btn.getAttribute('aria-disabled') === 'true') continue;
        if (/\b(disabled|is-disabled|btn-disabled|ant-btn-disabled)\b/i.test(btn.className || '')) continue;
        const t = (Utils.safeText(btn) || btn.value || btn.getAttribute('aria-label') || '').trim();
        if (!t) continue;
        if (dangerRe.test(t)) continue;           // 安全：跳过交卷/提交
        if (!nextRe.test(t)) continue;
        const rect = btn.getBoundingClientRect();
        if (rect.width > 0 && rect.height > 0) return { btn, isLast: false };
      }
      return { btn: null, isLast: true };
    },
  };

  // ============== Solver：填答案 ==============
  const Solver = {
    // 把 AI 答案匹配到选项索引集合（仅对 single/multi/judge）
    _matchAnswersToIndices(opts, answers, type) {
      const targets = [];
      if (type === AI.TYPE_JUDGE) {
        const ans = String(answers[0] || '');
        const isTrue = /正确|对|是|true|t|✓|right|yes/i.test(ans);
        for (let i = 0; i < opts.length; i++) {
          const t = opts[i].text;
          if (isTrue && /^(正确|对|是|true|T|✓|right|yes)$/i.test(t)) { targets.push(i); break; }
          if (!isTrue && /^(错误|错|否|false|F|✗|wrong|no)$/i.test(t)) { targets.push(i); break; }
        }
        return targets;
      }
      // SINGLE / MULTI
      const used = new Set();
      for (const ans of answers) {
        const ansN = Utils.normalize(ans);
        if (!ansN) continue;
        let best = -1, bestScore = 0;
        for (let i = 0; i < opts.length; i++) {
          if (used.has(i)) continue;
          const optN = Utils.normalize(opts[i].text);
          if (!optN) continue;
          let s = 0;
          if (optN === ansN) s = 100;
          else if (optN.includes(ansN) || ansN.includes(optN)) {
            const minL = Math.min(optN.length, ansN.length);
            const maxL = Math.max(optN.length, ansN.length);
            s = (minL / maxL) * 80;
          } else {
            const m = String(ans).match(/^\s*([A-Ha-h])\b/);
            if (m && i === (m[1].toUpperCase().charCodeAt(0) - 65)) s = 60;
          }
          if (s > bestScore) { bestScore = s; best = i; }
        }
        if (best >= 0 && bestScore >= 50) { targets.push(best); used.add(best); }
      }

      // —— Fallback：上面没匹配到任何选项，扫描原始 AI 文本回捞 ——
      // 适用于 reasoner 思考被截断 / AI 输出格式跑偏的情况
      if (!targets.length && answers._raw) {
        const rawN = Utils.normalize(answers._raw);
        if (rawN) {
          // 优先策略 A：从原文里找 "正确答案是 ABC" / "选 ABCD" / "答案：A、B、C" 这种字母枚举
          const letterEnum = answers._raw.match(/(?:正确答案|答案|选|应选|选项)(?:是|为|应该是|应为|包括)?\s*[：:]?\s*([A-Ha-h](?:[\s,，、和与及]*[A-Ha-h]){0,7})/);
          if (letterEnum) {
            const letters = letterEnum[1].match(/[A-Ha-h]/g) || [];
            letters.forEach(L => {
              const idx = L.toUpperCase().charCodeAt(0) - 65;
              if (idx >= 0 && idx < opts.length && !targets.includes(idx)) targets.push(idx);
            });
          }
          // 策略 B：扫描每个选项文本是否作为子串出现在 AI 原文中
          // ⚠️ 仅在原文较短（< 200 字）时启用，避免 reasoner 思考文本中提到所有选项造成误选
          if (!targets.length && rawN.length < 200) {
            for (let i = 0; i < opts.length; i++) {
              const optN = Utils.normalize(opts[i].text);
              if (!optN || optN.length < 3) continue;
              if (rawN.includes(optN) && !targets.includes(i)) targets.push(i);
            }
          }
        }
      }

      if (type === AI.TYPE_SINGLE) return targets.slice(0, 1);
      return targets;
    },

    formatSuggestion(opts, answers, type) {
      if (!answers?.length) return '无答案';
      if (type === AI.TYPE_FILL || type === AI.TYPE_ESSAY) return answers.join(' || ');

      const targets = this._matchAnswersToIndices(opts, answers, type);
      if (!targets.length) return answers.join(' / ');
      return targets.map(i => {
        const letter = String.fromCharCode(65 + i);
        return `${letter}. ${opts[i]?.text || ''}`.trim();
      }).join(' / ');
    },

    renderSuggestion(container, suggestion, rawAnswer) {
      if (!container) return;
      try {
        let box = container.querySelector(':scope > [data-oc-suggestion]');
        if (!box) {
          box = document.createElement('div');
          box.setAttribute('data-oc-suggestion', '1');
          box.style.cssText = [
            'margin:10px 0',
            'padding:10px 12px',
            'border:1px solid rgba(59,130,246,.35)',
            'border-radius:8px',
            'background:rgba(59,130,246,.08)',
            'color:#1e293b',
            'font-size:14px',
            'line-height:1.6',
            'white-space:pre-wrap'
          ].join(';');
          container.appendChild(box);
        }
        box.textContent = `AI 建议（请人工核对后作答）：${suggestion}${rawAnswer ? `\n原始输出：${rawAnswer}` : ''}`;
      } catch (_) {}
    },

    // 根据 AI 答案应用到 DOM（保留旧逻辑备用；默认学习辅助模式不会调用）
    async applyAnswer(opts, answers, type) {
      if (!answers?.length) return { success: false, msg: '无答案' };

      // 填空 / 简答
      if (type === AI.TYPE_FILL || type === AI.TYPE_ESSAY) {
        const fills = opts.filter(o => o.isFill);
        if (!fills.length) return { success: false, msg: '无填空框' };
        if (type === AI.TYPE_ESSAY) {
          Utils.nativeSet(fills[0].input, answers[0]);
          return { success: true, msg: `已填入 ${answers[0].length} 字` };
        }
        let count = 0;
        for (let i = 0; i < fills.length; i++) {
          const a = answers[i] || answers[answers.length - 1] || '';
          if (a) { Utils.nativeSet(fills[i].input, a); count++; }
        }
        return { success: count > 0, msg: `已填 ${count}/${fills.length} 空` };
      }

      // radio/checkbox 类：先匹配出目标索引集合
      const targets = this._matchAnswersToIndices(opts, answers, type);
      if (!targets.length) return { success: false, msg: 'AI 答案未匹配任何选项' };
      const wantSet = new Set(targets);

      // 状态同步：逐个 option 把 checked 校正到目标态
      let toCheck = 0, toUncheck = 0, kept = 0, failed = 0;
      // 先取消错选（很重要！多选/单选状态同步前先清不需要的，避免单选互斥冲突）
      for (let i = 0; i < opts.length; i++) {
        const opt = opts[i];
        if (!opt.input || opt.isFill) continue;
        const want = wantSet.has(i);
        const have = !!opt.input.checked;
        if (!want && have) {
          const ok = await Utils.toggleChecked(opt.input, opt.node, false);
          if (ok) toUncheck++; else failed++;
        }
      }
      // 再勾选目标
      for (let i = 0; i < opts.length; i++) {
        const opt = opts[i];
        if (!opt.input || opt.isFill) continue;
        const want = wantSet.has(i);
        const have = !!opt.input.checked;
        if (want && have) { kept++; continue; }
        if (want && !have) {
          const ok = await Utils.toggleChecked(opt.input, opt.node, true);
          if (ok) toCheck++; else failed++;
        }
      }
      const total = wantSet.size;
      const ok = toCheck + kept;
      const parts = [];
      if (toCheck) parts.push(`新选 ${toCheck}`);
      if (kept) parts.push(`保持 ${kept}`);
      if (toUncheck) parts.push(`取消 ${toUncheck}`);
      if (failed) parts.push(`失败 ${failed}`);
      return {
        success: ok > 0 && failed === 0,
        msg: `${ok}/${total} 项已选中${parts.length ? '（' + parts.join('，') + '）' : ''}`,
      };
    },
  };

  // ============== Runner：AI 解析提示主循环 ==============
  const Runner = {
    pause() { isPaused = true; },
    resume() { isPaused = false; },
    isPaused() { return isPaused; },

    async runOne(container, idx, total, logger) {
      await waitWhilePaused(logger);
      if (stopRequested) return { ok: false, msg: '已停止' };
      const stem = Detector.extractStem(container);
      const opts = Detector.extractOptions(container);
      const type = Detector.detectType(container, opts);
      const typeLabel = { single: '单选', multi: '多选', judge: '判断', fill: '填空', essay: '简答', unknown: '未知' }[type];

      logger(`📝 [${idx + 1}/${total}] ${typeLabel}题（${opts.length} 项）`);
      logger(`   题干：${stem.slice(0, 80)}${stem.length > 80 ? '…' : ''}`);
      // 显示提取到的选项文本，便于核对匹配
      if (opts.length && !opts.some(o => o.isFill)) {
        const optPreview = opts.map((o, i) => `${String.fromCharCode(65 + i)}.${(o.text || '∅').slice(0, 14)}`).join('  ');
        logger(`   选项：${optPreview}`);
      }
      // 防呆：单选/多选/判断 至少要有 2 个选项
      if ((type === AI.TYPE_SINGLE || type === AI.TYPE_MULTI || type === AI.TYPE_JUDGE) && opts.length < 2) {
        logger(`   ⚠️ ${typeLabel}题但只有 ${opts.length} 个选项，怀疑识别错误，跳过`);
        stats.skipped++;
        return { ok: false, msg: '选项不足' };
      }

      if (type === AI.TYPE_UNKNOWN || !opts.length) {
        logger(`   ⚠️ 无法识别题型，跳过`);
        stats.skipped++;
        return { ok: false, msg: '题型未识别' };
      }

      // 显示当前已选状态（便于核对）
      const checkedNow = opts.filter(o => o.input?.checked).map(o => o.text.slice(0, 12));
      if (checkedNow.length) {
        logger(`   📌 当前已选：${checkedNow.join(' / ')}`);
      }

      try {
        container.scrollIntoView({ behavior: 'smooth', block: 'center' });
        await Utils.sleep(200);
      } catch (_) {}

      try {
        const answers = await AI.call(stem, opts.map(o => o.text), type, logger);
        const fbTag = answers._fallback ? `[降级→${answers._fallback}] ` : '';
        const suggestion = Solver.formatSuggestion(opts, answers, type);
        Solver.renderSuggestion(container, suggestion, answers._raw);
        logger(`   🤖 AI 建议：${fbTag}${suggestion.slice(0, 120)}`);

        // 自动作答：单选 / 多选 / 判断
        if (type === AI.TYPE_SINGLE || type === AI.TYPE_MULTI || type === AI.TYPE_JUDGE) {
          const res = await Solver.applyAnswer(opts, answers, type);
          if (res.success) {
            logger(`   ✅ 已作答：${res.msg}`, 'ok');
          } else {
            logger(`   ⚠️ 作答未完成：${res.msg}（已复制建议，可人工核对）`, 'warn');
            await Utils.copyText(suggestion);
          }
        } else {
          // 填空 / 简答 / 未知：仍走人工核对
          await Utils.copyText(suggestion);
          logger('   📋 已复制建议，请人工核对后作答');
        }

        await Utils.sleep(Config.afterClickMs);
        stats.success++;
        return { ok: true };
      } catch (e) {
        logger(`   ❌ AI 调用失败：${e.message || e}`);
        stats.failed++;
        return { ok: false, msg: String(e) };
      }
    },

    async runAll(logger) {
      if (isRunning) { logger('⚠️ 已经在运行中'); return; }
      isRunning = true; stopRequested = false; isPaused = false;
      stats = { total: 0, success: 0, failed: 0, skipped: 0 };
      const autoNext = Store.getAutoNext();
      logger(autoNext
        ? '🚀 开始 AI 自动答题（单选/多选/判断自动勾选 · 自动翻页）'
        : '🚀 开始 AI 自动答题（单选/多选/判断自动勾选）');

      try {
        let page = 1;
        const maxPages = Store.getMaxPages();
        const seen = new WeakSet();   // 记录已作答过的题目容器，跨页去重 + 判定"无新题"
        while (!stopRequested && page <= maxPages) {
          const all = Detector.findQuestions();
          const questions = all.filter(q => !seen.has(q));
          if (!all.length) {
            logger(`⚠️ 第 ${page} 页未找到题目`);
            break;
          }

          if (questions.length) {
            logger(`📚 第 ${page} 页：${questions.length} 道新题`);
            stats.total += questions.length;
            for (let i = 0; i < questions.length; i++) {
              if (stopRequested) break;
              seen.add(questions[i]);
              await this.runOne(questions[i], i, questions.length, logger);
              await Utils.sleep(Store.getInterMs());
            }
          } else {
            // 翻页后没有任何新题 → 说明已答完全部题目，停止（防止对着末题死循环翻页）
            logger('🏁 没有新题了，已答完全部题目，请人工核对后手动交卷', 'warn');
            break;
          }
          if (stopRequested) break;

          // 不自动翻页：作答完当前页就停
          if (!autoNext) {
            logger('⏸ 已作答当前页，未自动翻页/提交；如需连续答题请开启「自动翻页」', 'warn');
            break;
          }

          // 自动翻页：找"下一题/下一页"，找不到说明到末页 → 停下让用户手动交卷
          const { btn, isLast } = Detector.findNextButton();
          if (isLast || !btn) {
            logger('🏁 已到最后一页（未找到"下一页"），请人工核对后手动交卷', 'warn');
            break;
          }
          logger(`➡️ 翻到下一页…`);
          Utils.singleClick(btn);
          await Utils.sleep(Math.max(800, Store.getInterMs()));
          // 等待新内容渲染（最多等 ~4s）
          let appeared = false;
          for (let w = 0; w < 8; w++) {
            if (Detector.findQuestions().filter(q => !seen.has(q)).length) { appeared = true; break; }
            await Utils.sleep(500);
          }
          // 点了下一页但没出现新题 → 已到末尾（按钮变灰/无效），停止避免空转
          if (!appeared) {
            logger('🏁 已到最后一题，停止翻页，请人工核对后手动交卷', 'warn');
            break;
          }
          page++;
        }
        if (page > maxPages) logger(`⚠️ 已达最大翻页数 ${maxPages}，停止`, 'warn');
      } catch (e) {
        logger(`❌ 主循环异常：${e.message || e}`);
      } finally {
        isRunning = false;
        logger(`🎉 完成：成功 ${stats.success} · 失败 ${stats.failed} · 跳过 ${stats.skipped} · 共 ${stats.total}`);
      }
    },

    async runCurrentPage(logger) {
      if (isRunning) { logger('⚠️ 已经在运行中'); return; }
      isRunning = true; stopRequested = false; isPaused = false;
      stats = { total: 0, success: 0, failed: 0, skipped: 0 };
      logger('🎯 解析并作答当前页（单选/多选/判断自动勾选）');

      try {
        const questions = Detector.findQuestions();
        if (!questions.length) { logger('⚠️ 当前页未找到题目'); return; }
        stats.total = questions.length;
        for (let i = 0; i < questions.length; i++) {
          if (stopRequested) break;
          await this.runOne(questions[i], i, questions.length, logger);
          await Utils.sleep(Store.getInterMs());
        }
      } finally {
        isRunning = false;
        logger(`🎉 完成：成功 ${stats.success} · 失败 ${stats.failed} · 跳过 ${stats.skipped} · 共 ${stats.total}`);
      }
    },

    // 视频弹题：作答当前检测到的题目（供刷课调用，不抢占 runAll 的 isRunning 锁逻辑）
    async answerPopQuiz(logger) {
      const questions = Detector.findQuestions();
      if (!questions.length) return;
      for (let i = 0; i < questions.length; i++) {
        await this.runOne(questions[i], i, questions.length, logger);
        await Utils.sleep(600);
      }
      // 尝试点弹题里的"确定/提交答案"（仅弹窗内，绝不点整卷交卷）
      const okRe = /^(确定|确认|提交答案|继续学习|继续|知道了|关闭|ok)$/i;
      const dangerRe = /(交卷|完成考试|finish)/i;
      for (const b of document.querySelectorAll('button, a, [role="button"]')) {
        if (Utils.isOwnPanel(b)) continue;
        const t = (Utils.safeText(b) || '').trim();
        if (!t || dangerRe.test(t) || !okRe.test(t)) continue;
        const r = b.getBoundingClientRect();
        if (r.width > 0 && r.height > 0) { Utils.singleClick(b); logger('   ✅ 已确认弹题'); break; }
      }
    },

    stop() { stopRequested = true; isPaused = false; },
  };

  // ============== UI ==============
  const UI = {
    panelEl: null, ballEl: null, logEl: null,

    init() {
      this.injectStyles();
      this.createBall();
    },

    injectStyles() {
      if (document.getElementById('ouchn-styles')) return;
      const style = document.createElement('style');
      style.id = 'ouchn-styles';
      style.textContent = `
        #ouchn-ball,#ouchn-panel,#ouchn-settings{
          font-family:-apple-system,BlinkMacSystemFont,'Segoe UI','Microsoft YaHei',sans-serif;
        }
        #ouchn-ball{
          position:fixed;right:20px;bottom:80px;width:48px;height:48px;border-radius:50%;
          background:linear-gradient(135deg,#3b82f6,#8b5cf6);color:#fff;font-size:22px;
          display:flex;align-items:center;justify-content:center;cursor:pointer;
          box-shadow:0 8px 20px rgba(59,130,246,.4);z-index:99998;
          transition:transform .15s;user-select:none;
        }
        #ouchn-ball:hover{transform:scale(1.08);}
        #ouchn-ball.running{animation:ouchn-pulse 1.2s ease-in-out infinite;}
        @keyframes ouchn-pulse{0%,100%{box-shadow:0 8px 20px rgba(59,130,246,.4)}50%{box-shadow:0 8px 30px rgba(139,92,246,.7)}}
        @keyframes ouchn-slidein{from{transform:translateY(20px) scale(.96);opacity:0}to{transform:translateY(0) scale(1);opacity:1}}

        #ouchn-panel{
          position:fixed;right:24px;bottom:140px;width:380px;max-height:80vh;display:flex;flex-direction:column;
          background:#0f172a;color:#e2e8f0;border-radius:16px;z-index:99999;
          box-shadow:0 24px 60px rgba(0,0,0,.4),0 0 0 1px rgba(255,255,255,.06);
          animation:ouchn-slidein .25s cubic-bezier(.34,1.56,.64,1);overflow:hidden;
        }
        .oc-header{
          padding:14px 16px;display:flex;align-items:center;justify-content:space-between;
          background:linear-gradient(135deg,rgba(59,130,246,.15),rgba(139,92,246,.15));
          border-bottom:1px solid rgba(255,255,255,.06);cursor:move;user-select:none;
        }
        .oc-title{font-size:14px;font-weight:600;display:flex;align-items:center;gap:8px;color:#f1f5f9;}
        .oc-dot{width:8px;height:8px;border-radius:50%;background:#10b981;box-shadow:0 0 8px #10b981;}
        .oc-dot.running{background:#06b6d4;animation:ouchn-pulse 1.2s ease-in-out infinite;}
        .oc-iconbtn{
          background:rgba(255,255,255,.08);color:#e2e8f0;border:none;width:28px;height:28px;
          border-radius:7px;cursor:pointer;font-size:13px;display:inline-flex;align-items:center;
          justify-content:center;transition:background .15s;
        }
        .oc-iconbtn:hover{background:rgba(255,255,255,.16);}

        /* 微信反馈条 */
        .oc-wechat-tip{
          padding:7px 14px;font-size:11px;line-height:1.5;color:#fbbf24;
          background:linear-gradient(90deg,rgba(245,158,11,.12),rgba(245,158,11,.04));
          border-bottom:1px solid rgba(245,158,11,.18);
          display:flex;align-items:center;gap:6px;flex-wrap:wrap;
        }
        .oc-wechat-copy{
          display:inline-flex;align-items:center;gap:4px;padding:1px 8px;
          background:rgba(255,255,255,.08);border:1px solid rgba(245,158,11,.3);
          border-radius:5px;cursor:pointer;font-weight:600;color:#fcd34d;
          transition:all .15s;user-select:none;
        }
        .oc-wechat-copy:hover{background:rgba(245,158,11,.18);border-color:#f59e0b;color:#fff;}
        .oc-wechat-copy.copied{background:rgba(16,185,129,.18);border-color:#10b981;color:#34d399;}

        /* 公告条（远程拉取，默认隐藏） */
        .oc-announce{
          display:none;padding:8px 14px;font-size:11px;line-height:1.55;
          border-bottom:1px solid rgba(59,130,246,.22);
          align-items:flex-start;gap:6px;position:relative;
        }
        .oc-announce.show{display:flex;animation:ocAnnounceIn .35s ease;}
        @keyframes ocAnnounceIn{from{opacity:0;transform:translateY(-4px);}to{opacity:1;transform:translateY(0);}}
        .oc-announce.info   {color:#93c5fd;background:linear-gradient(90deg,rgba(59,130,246,.16),rgba(59,130,246,.04));border-color:rgba(59,130,246,.25);}
        .oc-announce.warning{color:#fcd34d;background:linear-gradient(90deg,rgba(245,158,11,.16),rgba(245,158,11,.04));border-color:rgba(245,158,11,.3);}
        .oc-announce.error  {color:#fca5a5;background:linear-gradient(90deg,rgba(239,68,68,.16),rgba(239,68,68,.04));border-color:rgba(239,68,68,.3);}
        .oc-announce.success{color:#86efac;background:linear-gradient(90deg,rgba(34,197,94,.16),rgba(34,197,94,.04));border-color:rgba(34,197,94,.3);}
        .oc-announce-icon{flex-shrink:0;font-size:13px;line-height:1.3;}
        .oc-announce-body{flex:1;min-width:0;}
        .oc-announce-title{font-weight:600;margin-bottom:2px;font-size:11.5px;}
        .oc-announce-content{font-size:11px;color:rgba(255,255,255,.85);line-height:1.55;word-break:break-word;}
        .oc-announce-content b{color:#fde68a;font-weight:600;}
        .oc-announce-close{
          position:absolute;top:4px;right:8px;cursor:pointer;color:rgba(255,255,255,.5);
          font-size:14px;line-height:1;padding:2px;user-select:none;
        }
        .oc-announce-close:hover{color:#fff;}

        .oc-body{padding:14px;overflow-y:auto;flex:1;display:flex;flex-direction:column;gap:12px;}
        .oc-body::-webkit-scrollbar{width:6px}
        .oc-body::-webkit-scrollbar-thumb{background:rgba(255,255,255,.15);border-radius:3px}

        .oc-section{
          background:rgba(255,255,255,.04);border:1px solid rgba(255,255,255,.06);
          border-radius:10px;padding:12px;
        }
        .oc-section-title{font-size:11px;color:#94a3b8;font-weight:600;text-transform:uppercase;letter-spacing:.5px;margin-bottom:8px;}
        .oc-row{display:flex;align-items:center;gap:8px;margin-bottom:8px;}
        .oc-row:last-child{margin-bottom:0;}
        .oc-label{font-size:12px;color:#cbd5e1;flex:1;font-weight:500;}
        .oc-input,.oc-select{
          width:100%;padding:7px 10px;background:#1e293b;color:#f1f5f9;border:1px solid rgba(255,255,255,.1);
          border-radius:7px;font-size:12px;box-sizing:border-box;font-family:inherit;
          transition:border-color .15s;
        }
        .oc-input:focus,.oc-select:focus{outline:none;border-color:#3b82f6;box-shadow:0 0 0 3px rgba(59,130,246,.2);}
        .oc-select{cursor:pointer;}
        .oc-btn{
          padding:9px 14px;background:linear-gradient(135deg,#3b82f6,#8b5cf6);color:#fff;border:none;
          border-radius:7px;font-size:13px;font-weight:600;cursor:pointer;
          font-family:inherit;display:inline-flex;align-items:center;justify-content:center;gap:6px;
          transition:transform .12s,box-shadow .15s;
        }
        .oc-btn:hover{transform:translateY(-1px);box-shadow:0 6px 16px rgba(59,130,246,.35);}
        .oc-btn:active{transform:translateY(0);}
        .oc-btn-ghost{background:rgba(255,255,255,.08);color:#cbd5e1;}
        .oc-btn-ghost:hover{background:rgba(255,255,255,.16);box-shadow:none;}
        .oc-btn-danger{background:linear-gradient(135deg,#ef4444,#dc2626);}
        .oc-btn-success{background:linear-gradient(135deg,#10b981,#059669);}
        .oc-btn-sm{padding:5px 9px;font-size:11px;}
        .oc-btn:disabled{opacity:.5;cursor:not-allowed;}

        .oc-switch{position:relative;display:inline-block;width:36px;height:20px;flex-shrink:0;}
        .oc-switch input{opacity:0;width:0;height:0;}
        .oc-switch-slider{position:absolute;cursor:pointer;inset:0;background:#334155;border-radius:20px;transition:.2s;}
        .oc-switch-slider:before{
          content:'';position:absolute;height:14px;width:14px;left:3px;bottom:3px;background:#fff;
          border-radius:50%;transition:.2s;
        }
        .oc-switch input:checked + .oc-switch-slider{background:linear-gradient(135deg,#3b82f6,#8b5cf6);}
        .oc-switch input:checked + .oc-switch-slider:before{transform:translateX(16px);}

        .oc-key-row{position:relative;}
        .oc-key-toggle{
          position:absolute;right:8px;top:50%;transform:translateY(-50%);
          background:none;border:none;color:#94a3b8;cursor:pointer;font-size:14px;padding:0 4px;
        }
        .oc-key-toggle:hover{color:#3b82f6;}

        .oc-model-hint{font-size:10px;color:#64748b;margin-top:4px;line-height:1.4;}

        #ouchn-log{
          height:160px;overflow-y:auto;background:#020617;border:1px solid rgba(255,255,255,.06);
          border-radius:8px;padding:8px 10px;font-family:'JetBrains Mono','Cascadia Code',Consolas,monospace;
          font-size:11px;color:#94a3b8;line-height:1.5;
        }
        #ouchn-log::-webkit-scrollbar{width:5px}
        #ouchn-log::-webkit-scrollbar-thumb{background:rgba(255,255,255,.15);border-radius:3px}
        #ouchn-log > div{padding:1px 0;word-break:break-all;}
        #ouchn-log .log-ok{color:#10b981;}
        #ouchn-log .log-warn{color:#f59e0b;}
        #ouchn-log .log-err{color:#ef4444;}
        #ouchn-log .log-ai{color:#a78bfa;}

        .oc-footer{
          padding:8px 14px;font-size:10px;color:#64748b;display:flex;align-items:center;justify-content:space-between;
          background:rgba(0,0,0,.2);border-top:1px solid rgba(255,255,255,.04);
        }
        .oc-stat{display:flex;gap:10px;font-size:11px;padding:6px 10px;background:rgba(0,0,0,.2);border-radius:6px;}
        .oc-stat span{display:flex;align-items:center;gap:3px;}
        .oc-stat .ok{color:#10b981;}
        .oc-stat .fail{color:#ef4444;}
        .oc-stat .skip{color:#f59e0b;}

        /* 验证码区块 */
        .oc-verify{
          background:linear-gradient(135deg,rgba(16,185,129,.08),rgba(59,130,246,.08));
          border:1px solid rgba(16,185,129,.25);
        }
        .oc-verify.locked{
          background:linear-gradient(135deg,rgba(245,158,11,.08),rgba(239,68,68,.05));
          border-color:rgba(245,158,11,.3);
        }
        .oc-verify-grid{display:flex;gap:10px;align-items:flex-start;}
        .oc-verify-qr-wrap{position:relative;flex-shrink:0;}
        .oc-verify-qr{
          width:110px;height:110px;border-radius:6px;background:#fff;display:block;
          object-fit:contain;cursor:zoom-in;border:1px solid rgba(255,255,255,.12);padding:4px;
          image-rendering:crisp-edges;transition:box-shadow .15s;
        }
        .oc-verify-qr:hover{box-shadow:0 0 0 2px rgba(59,130,246,.4);}
        /* hover 放大预览：浮在二维码上方 */
        .oc-verify-qr-zoom{
          position:absolute;top:50%;left:118px;transform:translateY(-50%) scale(.92);
          width:220px;height:220px;border-radius:8px;background:#fff;padding:8px;
          box-shadow:0 12px 32px rgba(0,0,0,.6),0 0 0 1px rgba(255,255,255,.15);
          opacity:0;pointer-events:none;transition:opacity .18s, transform .18s;z-index:10;
          object-fit:contain;image-rendering:crisp-edges;
        }
        .oc-verify-qr-wrap:hover .oc-verify-qr-zoom{
          opacity:1;transform:translateY(-50%) scale(1);
        }
        .oc-verify-qr-tip{
          font-size:9px;color:#94a3b8;text-align:center;margin-top:3px;line-height:1.2;
        }
        .oc-verify-right{flex:1;display:flex;flex-direction:column;gap:6px;min-width:0;}
        .oc-verify-hint{font-size:10px;color:#94a3b8;line-height:1.5;}
        .oc-verify-input-group{display:flex;gap:6px;}
        .oc-verify-input{
          flex:1 1 0;min-width:0;padding:7px 10px;background:#1e293b;color:#f1f5f9;
          border:1px solid rgba(255,255,255,.1);border-radius:7px;
          font-size:14px;font-weight:600;letter-spacing:4px;text-align:center;
          font-family:inherit;
        }
        .oc-verify-input:focus{outline:none;border-color:#10b981;box-shadow:0 0 0 3px rgba(16,185,129,.2);}
        .oc-verify-input:disabled{opacity:.6;cursor:not-allowed;}
        .oc-verify-status{font-size:11px;line-height:1.4;}
        .oc-verify-status.ok{color:#34d399;}
        .oc-verify-status.err{color:#f87171;}
        .oc-verify-status.warn{color:#fbbf24;}

        .oc-btn-warn{background:linear-gradient(135deg,#f59e0b,#d97706);}
        .oc-btn-info{background:linear-gradient(135deg,#0ea5e9,#0284c7);}
      `;
      document.head.appendChild(style);
    },

    createBall() {
      const ball = document.createElement('div');
      ball.id = 'ouchn-ball';
      ball.setAttribute('data-ouchn-helper', '1');
      ball.title = Config.appName;
      ball.textContent = '🎓';
      ball.onclick = () => {
        if (this.panelEl) {
          const hidden = this.panelEl.style.display === 'none';
          this.panelEl.style.display = hidden ? 'flex' : 'none';
        } else {
          this.createPanel();
        }
      };
      document.body.appendChild(ball);
      this.ballEl = ball;
    },

    createPanel() {
      const panel = document.createElement('div');
      panel.id = 'ouchn-panel';
      panel.setAttribute('data-ouchn-helper', '1');
      const curModel = Store.getModel();
      const apiKey = Store.getApiKey();
      const autoNext = Store.getAutoNext();
      const interMs = Store.getInterMs();
      const playRate = Store.getPlayRate();
      const muted = Store.getMuted();
      const autoNextLesson = Store.getAutoNextLesson();
      panel.innerHTML = `
        <div class="oc-header">
          <div class="oc-title">
            <span class="oc-dot"></span>
            <span>🎓 ${Config.appName}</span>
            <span style="font-size:10px;color:#64748b;font-weight:400;">v${Config.version}</span>
          </div>
          <div style="display:flex;gap:4px;">
            <button class="oc-iconbtn" id="oc-min" title="最小化">─</button>
            <button class="oc-iconbtn" id="oc-close" title="关闭">✕</button>
          </div>
        </div>

        <div class="oc-wechat-tip">
          ⚠️ BUG 反馈 / 购码请加微信
          <span class="oc-wechat-copy" id="oc-wechat" title="点击复制">${Config.wechat} 📋</span>
        </div>

        <div class="oc-announce" id="oc-announce">
          <span class="oc-announce-icon">📢</span>
          <div class="oc-announce-body">
            <div class="oc-announce-title" id="oc-announce-title">公告</div>
            <div class="oc-announce-content" id="oc-announce-content"></div>
          </div>
          <span class="oc-announce-close" id="oc-announce-close" title="关闭">×</span>
        </div>

        <div class="oc-body">
          <!-- 验证码 -->
          <div class="oc-section oc-verify ${Store.isVerifyValid() ? '' : 'locked'}" id="oc-verify-section">
            <div class="oc-section-title" id="oc-verify-title">
              ${Store.isVerifyValid() ? '✅ 已验证' : '🔐 验证码激活'}
            </div>
            <div class="oc-verify-grid">
              <div class="oc-verify-qr-wrap">
                <img class="oc-verify-qr" id="oc-verify-qr" src="${Config.verifyQrUrl}" alt="扫码获取验证码"
                     title="鼠标悬停查看大图；点击新窗口放大"/>
                <img class="oc-verify-qr-zoom" src="${Config.verifyQrUrl}" alt="扫码大图"/>
                <div class="oc-verify-qr-tip">悬停放大 / 点击新窗口</div>
              </div>
              <div class="oc-verify-right">
                <div class="oc-verify-hint" id="oc-verify-hint">
                  扫码看广告 → 获取 4 位验证码 → 输入下方激活，验证后免费使用 24 小时
                </div>
                <div class="oc-verify-input-group">
                  <input id="oc-verify-code" class="oc-verify-input" type="text" maxlength="4"
                         placeholder="****" autocomplete="off"
                         ${Store.isVerifyValid() ? 'disabled' : ''}/>
                  <button id="oc-verify-btn" class="oc-btn oc-btn-success oc-btn-sm"
                          style="flex:0 0 auto;min-width:64px;padding-left:14px;padding-right:14px;white-space:nowrap;${Store.isVerifyValid() ? 'opacity:.5;cursor:not-allowed;' : ''}"
                          ${Store.isVerifyValid() ? 'disabled' : ''}>验证</button>
                </div>
                <div class="oc-verify-status" id="oc-verify-status">
                  ${Store.isVerifyValid()
                    ? `<span class="ok">✅ 有效期至 ${Store.getValidUntilStr()}</span>`
                    : '<span class="warn">⏳ 未验证，启动 AI 解析前需先激活</span>'}
                </div>
              </div>
            </div>
          </div>

          <!-- AI 模型 -->
          <div class="oc-section">
            <div class="oc-section-title">🤖 AI 模型</div>
            <div class="oc-row" style="flex-direction:column;align-items:stretch;gap:6px;">
              <span class="oc-label" style="flex:none;">选择模型</span>
              <select id="oc-model" class="oc-select">
                ${Object.entries(Config.models).map(([k, v]) =>
                  `<option value="${k}" ${k === curModel ? 'selected' : ''}>${v.name}</option>`
                ).join('')}
              </select>
              <div class="oc-model-hint" id="oc-model-hint">${Config.models[curModel].hint}</div>
            </div>
            <div class="oc-row" style="flex-direction:column;align-items:stretch;gap:4px;margin-top:8px;">
              <span class="oc-label" style="flex:none;">DeepSeek API Key</span>
              <div class="oc-key-row">
                <input id="oc-key" class="oc-input" type="password" placeholder="sk-..."
                  value="${(apiKey || '').replace(/"/g, '&quot;')}"/>
                <button class="oc-key-toggle" id="oc-key-toggle" title="显示/隐藏">👁</button>
              </div>
              <a href="https://platform.deepseek.com/" target="_blank" style="font-size:10px;color:#3b82f6;text-decoration:none;">→ 前往 DeepSeek 申请 Key</a>
            </div>
          </div>

          <!-- 答题设置 -->
          <div class="oc-section">
            <div class="oc-section-title">⚙️ 答题设置</div>
            <div class="oc-row">
              <span class="oc-label">自动翻页（连续答题）</span>
              <label class="oc-switch">
                <input type="checkbox" id="oc-autoNext" ${autoNext ? 'checked' : ''}/>
                <span class="oc-switch-slider"></span>
              </label>
            </div>
            <div class="oc-model-hint">开启后会自动点「下一题/下一页」连续作答；遇到「交卷/提交」一律不点，停在末页等你手动交卷。长条单页则一次顺序答完。填空/简答仅复制建议需人工填写。</div>
            <div class="oc-row" style="flex-direction:column;align-items:stretch;gap:4px;">
              <span class="oc-label" style="flex:none;">解析间隔（毫秒）</span>
              <input id="oc-interMs" class="oc-input" type="number" min="500" step="100" value="${interMs}"/>
            </div>
          </div>

          <!-- 刷课设置 -->
          <div class="oc-section">
            <div class="oc-section-title">🎬 刷课设置（视频 / 文档 / PPT）</div>
            <div class="oc-row" style="flex-direction:column;align-items:stretch;gap:4px;">
              <span class="oc-label" style="flex:none;">播放倍速</span>
              <select id="oc-rate" class="oc-select">
                ${[0.5,1,1.25,1.5,2,3,4,6,8,16].map(r =>
                  `<option value="${r}" ${r === playRate ? 'selected' : ''}>${r}x${r > 2 ? '（部分平台限制）' : ''}</option>`
                ).join('')}
              </select>
              <div class="oc-model-hint">部分平台会锁倍速，超过其上限可能被强制改回。</div>
            </div>
            <div class="oc-row">
              <span class="oc-label">静音播放（建议开，避免被浏览器拦截）</span>
              <label class="oc-switch">
                <input type="checkbox" id="oc-muted" ${muted ? 'checked' : ''}/>
                <span class="oc-switch-slider"></span>
              </label>
            </div>
            <div class="oc-row">
              <span class="oc-label">学完自动下一节</span>
              <label class="oc-switch">
                <input type="checkbox" id="oc-autoLesson" ${autoNextLesson ? 'checked' : ''}/>
                <span class="oc-switch-slider"></span>
              </label>
            </div>
            <div style="display:flex;gap:6px;margin-top:4px;">
              <button id="oc-video-start" class="oc-btn oc-btn-success oc-btn-sm" style="flex:1 1 0;min-width:0;white-space:nowrap;">▶️ 开始刷课</button>
              <button id="oc-video-stop" class="oc-btn oc-btn-danger oc-btn-sm" style="flex:1 1 0;min-width:0;white-space:nowrap;">⏹ 停止刷课</button>
            </div>
            <div style="display:flex;gap:6px;margin-top:6px;">
              <button id="oc-doc-start" class="oc-btn oc-btn-info oc-btn-sm" style="flex:1 1 0;min-width:0;white-space:nowrap;">📄 文档/PPT翻页</button>
              <button id="oc-doc-stop" class="oc-btn oc-btn-ghost oc-btn-sm" style="flex:1 1 0;min-width:0;white-space:nowrap;">⏹ 停止翻页</button>
            </div>
          </div>

          <!-- 控制按钮 -->
          <div class="oc-section-title" style="margin-top:2px;">📝 答题</div>
          <div style="display:flex;gap:6px;flex-wrap:wrap;">
            <button id="oc-start" class="oc-btn" style="flex:1 1 100%;white-space:nowrap;">🚀 AI 自动答题</button>
            <button id="oc-onepage" class="oc-btn oc-btn-ghost" style="flex:1 1 100%;white-space:nowrap;">🎯 重新作答当前页</button>
            <button id="oc-pause" class="oc-btn oc-btn-warn" style="flex:1 1 0;min-width:0;display:none;white-space:nowrap;">⏸ 暂停</button>
            <button id="oc-resume" class="oc-btn oc-btn-info" style="flex:1 1 0;min-width:0;display:none;white-space:nowrap;">▶️ 继续</button>
            <button id="oc-stop" class="oc-btn oc-btn-danger" style="flex:1 1 0;min-width:0;display:none;white-space:nowrap;">⏹ 停止</button>
          </div>
          <div style="display:flex;gap:6px;">
            <button id="oc-diag" class="oc-btn oc-btn-ghost oc-btn-sm" style="flex:1 1 0;min-width:0;white-space:nowrap;">🔍 调试扫描</button>
            <button id="oc-highlight" class="oc-btn oc-btn-ghost oc-btn-sm" style="flex:1 1 0;min-width:0;white-space:nowrap;">👁 高亮题目</button>
          </div>

          <!-- 统计 -->
          <div class="oc-stat" id="oc-stat" style="display:none;">
            <span>📊 总 <b id="oc-stat-total">0</b></span>
            <span class="ok">✅ <b id="oc-stat-ok">0</b></span>
            <span class="fail">❌ <b id="oc-stat-fail">0</b></span>
            <span class="skip">⏭ <b id="oc-stat-skip">0</b></span>
          </div>

          <!-- 日志 -->
          <div>
            <div class="oc-section-title" style="margin-bottom:6px;display:flex;justify-content:space-between;align-items:center;">
              <span>📜 运行日志</span>
              <button class="oc-btn oc-btn-ghost oc-btn-sm" id="oc-clear">清空</button>
            </div>
            <div id="ouchn-log"></div>
          </div>
        </div>

        <div class="oc-footer">
          <span>叶屿 · GPL3</span>
          <span>太钢培训 · DeepSeek 驱动</span>
        </div>
      `;
      document.body.appendChild(panel);
      this.panelEl = panel;
      this.logEl = panel.querySelector('#ouchn-log');

      // 拖动
      (() => {
        const header = panel.querySelector('.oc-header');
        let dragging = false, ox = 0, oy = 0;
        header.addEventListener('mousedown', (e) => {
          if (e.target.closest('.oc-iconbtn')) return;
          dragging = true;
          ox = e.clientX - panel.getBoundingClientRect().left;
          oy = e.clientY - panel.getBoundingClientRect().top;
          e.preventDefault();
        });
        document.addEventListener('mousemove', (e) => {
          if (!dragging) return;
          let x = Math.max(0, Math.min(window.innerWidth - panel.offsetWidth, e.clientX - ox));
          let y = Math.max(0, Math.min(window.innerHeight - 40, e.clientY - oy));
          panel.style.left = x + 'px'; panel.style.top = y + 'px';
          panel.style.right = 'auto'; panel.style.bottom = 'auto';
        });
        document.addEventListener('mouseup', () => { dragging = false; });
      })();

      this.bindEvents(panel);
      Announce.fetch(panel);
      this.addLog(`✅ ${Config.appName}已就绪`);
      if (!apiKey) this.addLog('⚠️ 请先在上方填入 DeepSeek API Key', 'warn');
      if (Store.isVerifyValid()) {
        this.addLog(`🔓 验证有效期至 ${Store.getValidUntilStr()}`);
      } else {
        this.addLog('🔒 未验证，扫码获取 4 位验证码后激活', 'warn');
      }
    },

    bindEvents(panel) {
      panel.querySelector('#oc-close').onclick = () => { panel.style.display = 'none'; };
      panel.querySelector('#oc-min').onclick = () => { panel.style.display = 'none'; };

      // 微信复制
      const wxEl = panel.querySelector('#oc-wechat');
      wxEl.onclick = async () => {
        const ok = await Utils.copyText(Config.wechat);
        wxEl.classList.add('copied');
        wxEl.textContent = ok ? `✅ 已复制 ${Config.wechat}` : '❌ 复制失败';
        setTimeout(() => { wxEl.classList.remove('copied'); wxEl.textContent = `${Config.wechat} 📋`; }, 1800);
      };

      // 模型切换
      const modelEl = panel.querySelector('#oc-model');
      const hintEl = panel.querySelector('#oc-model-hint');
      modelEl.onchange = () => {
        Store.setModel(modelEl.value);
        hintEl.textContent = Config.models[modelEl.value].hint;
        this.addLog(`✅ 模型：${Config.models[modelEl.value].name}`);
      };

      // Key 输入
      const keyEl = panel.querySelector('#oc-key');
      keyEl.onblur = () => {
        const v = keyEl.value.trim();
        Store.setApiKey(v);
        if (v) this.addLog('✅ API Key 已保存');
      };
      panel.querySelector('#oc-key-toggle').onclick = () => {
        keyEl.type = keyEl.type === 'password' ? 'text' : 'password';
      };

      // 自动翻页
      const autoEl = panel.querySelector('#oc-autoNext');
      autoEl.onchange = () => {
        Store.setAutoNext(autoEl.checked);
        this.addLog(autoEl.checked
          ? '✅ 已开启自动翻页（遇到交卷/提交不会自动点）'
          : '⏸ 已关闭自动翻页，仅作答当前页', autoEl.checked ? 'ok' : 'warn');
      };

      // 题间间隔
      const interEl = panel.querySelector('#oc-interMs');
      interEl.onblur = () => {
        Store.setInterMs(interEl.value);
        interEl.value = Store.getInterMs();
        this.addLog(`✅ 解析间隔：${interEl.value} ms`);
      };

      // ---- 刷课设置 ----
      const rateEl = panel.querySelector('#oc-rate');
      rateEl.onchange = () => { Player.setRate(rateEl.value); this.addLog(`⏩ 倍速：${Store.getPlayRate()}x`); };
      const mutedEl = panel.querySelector('#oc-muted');
      mutedEl.onchange = () => {
        Store.setMuted(mutedEl.checked);
        const v = Player.currentVideo();
        if (v) v.muted = mutedEl.checked;
        this.addLog(mutedEl.checked ? '🔇 已设为静音播放' : '🔊 已取消静音（可能被浏览器拦截自动播放）', 'warn');
      };
      const autoLessonEl = panel.querySelector('#oc-autoLesson');
      autoLessonEl.onchange = () => {
        Store.setAutoNextLesson(autoLessonEl.checked);
        this.addLog(autoLessonEl.checked ? '✅ 学完自动下一节' : '⏸ 关闭自动下一节');
      };
      panel.querySelector('#oc-video-start').onclick = () => Player.start((m, l) => this.addLog(m, l));
      panel.querySelector('#oc-video-stop').onclick  = () => Player.stop();
      panel.querySelector('#oc-doc-start').onclick   = () => Doc.start((m, l) => this.addLog(m, l));
      panel.querySelector('#oc-doc-stop').onclick    = () => Doc.stop();

      // 开始 / 暂停 / 继续 / 停止 / 当前页
      const startBtn   = panel.querySelector('#oc-start');
      const onePageBtn = panel.querySelector('#oc-onepage');
      const pauseBtn   = panel.querySelector('#oc-pause');
      const resumeBtn  = panel.querySelector('#oc-resume');
      const stopBtn    = panel.querySelector('#oc-stop');
      const statEl     = panel.querySelector('#oc-stat');

      // running=false 时只显示 启动 按钮组；running=true 时显示 暂停/继续/停止
      const showRunning = (running, paused = false) => {
        startBtn.style.display   = running ? 'none' : 'inline-flex';
        onePageBtn.style.display = running ? 'none' : 'inline-flex';
        pauseBtn.style.display   = running && !paused ? 'inline-flex' : 'none';
        resumeBtn.style.display  = running && paused  ? 'inline-flex' : 'none';
        stopBtn.style.display    = running ? 'inline-flex' : 'none';
        statEl.style.display = (running || stats.total > 0) ? 'flex' : 'none';
        const dot = this.panelEl.querySelector('.oc-dot');
        dot.classList.toggle('running', running);
        dot.style.background = paused ? '#f59e0b' : '';
        dot.style.boxShadow = paused ? '0 0 8px #f59e0b' : '';
        this.ballEl?.classList.toggle('running', running);
      };

      const updateStat = () => {
        panel.querySelector('#oc-stat-total').textContent = stats.total;
        panel.querySelector('#oc-stat-ok').textContent = stats.success;
        panel.querySelector('#oc-stat-fail').textContent = stats.failed;
        panel.querySelector('#oc-stat-skip').textContent = stats.skipped;
      };

      const logger = (msg, level) => {
        this.addLog(msg, level);
        updateStat();
        statEl.style.display = 'flex';
      };

      // 启动前的前置校验：API Key + 验证码
      const preflight = () => {
        if (!Store.getApiKey()) { this.addLog('❌ 请先填写 DeepSeek API Key', 'err'); return false; }
        if (!Store.isVerifyValid()) {
          this.addLog('❌ 请先在顶部"验证码激活"区扫码并输入 4 位验证码', 'err');
          // 闪烁提示
          const sec = panel.querySelector('#oc-verify-section');
          if (sec) {
            sec.scrollIntoView({ behavior: 'smooth', block: 'center' });
            sec.style.transition = 'box-shadow .3s';
            sec.style.boxShadow = '0 0 0 3px rgba(245,158,11,.5)';
            setTimeout(() => { sec.style.boxShadow = ''; }, 1500);
          }
          return false;
        }
        return true;
      };

      startBtn.onclick = async () => {
        if (!preflight()) return;
        showRunning(true, false);
        try { await Runner.runAll(logger); }
        finally { showRunning(false); updateStat(); }
      };
      onePageBtn.onclick = async () => {
        if (!preflight()) return;
        showRunning(true, false);
        try { await Runner.runCurrentPage(logger); }
        finally { showRunning(false); updateStat(); }
      };
      pauseBtn.onclick = () => {
        Runner.pause();
        showRunning(true, true);
        this.addLog('⏸ 已暂停（点击 ▶️ 继续 恢复）', 'warn');
      };
      resumeBtn.onclick = () => {
        Runner.resume();
        showRunning(true, false);
        this.addLog('▶️ 已继续答题');
      };
      stopBtn.onclick = () => {
        Runner.stop();
        this.addLog('⏹ 已请求停止，等待当前题完成...', 'warn');
      };
      panel.querySelector('#oc-clear').onclick = () => { this.logEl.innerHTML = ''; };

      // ---- 验证码 ----
      const verifySection = panel.querySelector('#oc-verify-section');
      const verifyTitle   = panel.querySelector('#oc-verify-title');
      const verifyCodeEl  = panel.querySelector('#oc-verify-code');
      const verifyBtn     = panel.querySelector('#oc-verify-btn');
      const verifyStatus  = panel.querySelector('#oc-verify-status');
      const verifyQr      = panel.querySelector('#oc-verify-qr');

      const setVerifySuccess = (untilStr) => {
        verifySection.classList.remove('locked');
        verifyTitle.textContent = '✅ 已验证';
        verifyCodeEl.disabled = true;
        verifyBtn.disabled = true;
        verifyBtn.style.opacity = '.5';
        verifyBtn.style.cursor = 'not-allowed';
        verifyStatus.innerHTML = `<span class="ok">✅ 有效期至 ${untilStr}</span>`;
      };

      const doVerify = async () => {
        const code = (verifyCodeEl.value || '').trim();
        if (code.length !== 4) {
          verifyStatus.innerHTML = '<span class="err">❌ 请输入 4 位验证码</span>';
          return;
        }
        verifyBtn.disabled = true;
        const originalText = verifyBtn.textContent;
        verifyBtn.textContent = '验证中...';
        verifyStatus.innerHTML = '<span class="warn">⏳ 验证中...</span>';
        try {
          const r = await Verify.verifyCode(code);
          this.addLog(`✅ 验证成功，有效期至 ${r.validUntilStr}`);
          setVerifySuccess(r.validUntilStr);
          verifyCodeEl.value = '';
        } catch (err) {
          verifyStatus.innerHTML = `<span class="err">❌ ${err}</span>`;
          this.addLog(`❌ 验证失败：${err}`, 'err');
          verifyBtn.disabled = false;
          verifyBtn.textContent = originalText;
        }
      };

      verifyBtn.onclick = doVerify;
      verifyCodeEl.onkeydown = (e) => { if (e.key === 'Enter') doVerify(); };
      verifyCodeEl.oninput = () => {
        // 限制只能输 4 位数字/字母
        verifyCodeEl.value = (verifyCodeEl.value || '').replace(/[^0-9A-Za-z]/g, '').slice(0, 4);
      };
      // 点击二维码放大查看
      verifyQr.onclick = () => {
        const w = window.open(Config.verifyQrUrl, '_blank', 'width=400,height=400');
        if (!w) this.addLog('💡 浏览器拦截了弹窗，请允许后再试', 'warn');
      };

      // 调试扫描
      panel.querySelector('#oc-diag').onclick = () => {
        const info = Detector.diagnose();
        this.addLog(`🔍 ===== 页面诊断 =====`);
        this.addLog(`   URL: ${info.url}`);
        this.addLog(`   扫描了 ${info.docsScanned} 个 document（顶层 + 同源 iframe）`);
        this.addLog(`   radio: ${info.radios}（可见 ${info.visibleRadios}，有 name ${info.namedRadios}）`);
        this.addLog(`   checkbox: ${info.checkboxes} · text: ${info.texts} · textarea: ${info.textareas}`);
        this.addLog(`   iframe: ${info.iframes}（同源 ${info.sameOriginIframes}）`);
        if (info.iframeUrls.length) this.addLog(`   iframe URLs: ${info.iframeUrls.join(' | ')}`, 'warn');
        if (info.sampleWrapperClasses.length) {
          this.addLog(`   选项 class 样本：`);
          info.sampleWrapperClasses.forEach(c => this.addLog(`     · ${c}`));
        }
        this.addLog(`   📊 当前检测到 ${info.questionsFound} 道题`, info.questionsFound > 0 ? 'ok' : 'err');
        console.log('[太钢平台助手诊断]', info);
        if (info.radios === 0 && info.iframes > 0) {
          this.addLog(`   ⚠️ 题目可能在 iframe 内，需要扩大 @match 范围`, 'warn');
        }
      };

      // 高亮检测到的题目
      panel.querySelector('#oc-highlight').onclick = () => {
        // 清除旧的高亮
        document.querySelectorAll('[data-oc-highlight]').forEach(el => {
          el.style.outline = '';
          el.removeAttribute('data-oc-highlight');
        });
        const qs = Detector.findQuestions();
        this.addLog(`👁 高亮 ${qs.length} 道题（红框 = 题目容器）`);
        qs.forEach((q, i) => {
          q.style.outline = '3px solid #ef4444';
          q.style.outlineOffset = '2px';
          q.setAttribute('data-oc-highlight', String(i + 1));
        });
        if (qs[0]) qs[0].scrollIntoView({ behavior: 'smooth', block: 'center' });
        setTimeout(() => {
          document.querySelectorAll('[data-oc-highlight]').forEach(el => {
            el.style.outline = '';
            el.removeAttribute('data-oc-highlight');
          });
        }, 5000);
      };
    },

    addLog(msg, level) {
      if (!this.logEl) {
        console.log('[太钢平台助手]', msg);
        return;
      }
      const div = document.createElement('div');
      const time = new Date().toLocaleTimeString('zh-CN', { hour12: false });
      let cls = '';
      if (level === 'ok' || /✅|🎉/.test(msg)) cls = 'log-ok';
      else if (level === 'warn' || /⚠️|⏭|⏸/.test(msg)) cls = 'log-warn';
      else if (level === 'err' || /❌/.test(msg)) cls = 'log-err';
      else if (/🤖|AI/.test(msg)) cls = 'log-ai';
      div.className = cls;
      div.textContent = `[${time}] ${msg}`;
      this.logEl.appendChild(div);
      this.logEl.scrollTop = this.logEl.scrollHeight;
      // 限制条数
      while (this.logEl.children.length > 500) this.logEl.removeChild(this.logEl.firstChild);
    },
  };

  // ============== 启动 ==============
  function boot() {
    if (window.__OUCHN_HELPER_LOADED__) return;
    window.__OUCHN_HELPER_LOADED__ = true;
    // 只在顶层窗口显示面板（避免 iframe 内重复出现）
    if (window.top !== window.self) {
      console.log(`[${Config.appName}] 在 iframe 内加载，跳过 UI`);
      return;
    }
    UI.init();
    console.log(`[${Config.appName}] v${Config.version} 已加载`);
  }

  if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', boot);
  } else {
    boot();
  }
})();