// ==UserScript==
// @name         超星小助手
// @namespace    https://ayu.local/cx-h5p
// @version      5.14.2
// @description  超星/学习通学习辅助 | 自动播放视频、任务点自动切换、AI 搜题答题、本地题库、视频工具（倍速/截图/下载/画中画/全屏）。永久免费·无使用限制。
// @license      MIT
// @author       阿宇
// @match        *://*.chaoxing.com/*
// @match        *://chaoxing.com/*
// @match        *://*.xuexitong.com/*
// @match        *://xuexitong.com/*
// @connect      bing.com
// @connect      baidu.com
// @connect      www.bing.com
// @connect      www.baidu.com
// @connect      api.deepseek.com
// @grant        unsafeWindow
// @grant        GM_addStyle
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_deleteValue
// @grant        GM_listValues
// @grant        GM_addValueChangeListener
// @grant        GM_removeValueChangeListener
// @grant        GM_registerMenuCommand
// @grant        GM_unregisterMenuCommand
// @grant        GM_getTab
// @grant        GM_saveTab
// @grant        GM_getTabs
// @grant        GM_openInTab
// @grant        GM_setClipboard
// @grant        GM_xmlhttpRequest
// @run-at       document-start
// ==/UserScript==

/*
 * 版权与来源说明
 * - 本脚本全部代码均为自有实现，未包含第三方脚本代码。
 * - 视频工具（倍速/截图/下载/画中画/全屏）、题库匹配、章节测验答题、任务点识别、搜题、面板等逻辑均为自有实现。
 * - 以 MIT 许可证发布。免费使用，允许修改与再分发，需保留本版权说明。
 * - 免责声明：本脚本仅供个人学习交流使用，使用风险自负，请遵守所在平台的用户协议。
 */
(function () {

  // ========== 视频工具（自研：截图 / 下载 / 画中画 / 全屏） ==========
  // 倍速逻辑在下方「倍速与强制守护」。本模块不依赖任何第三方脚本。

  // 选出当前最值得操作的视频：优先正在播放、其次画面面积最大
  function pickActiveVideo() {
    const list = [];
    for (const v of getAllVideos()) {
      let r;
      try { r = v.getBoundingClientRect(); } catch (e) { continue; }
      if (!r || r.width < 40 || r.height < 40) continue;
      const src = v.currentSrc || v.src || '';
      if (!src && !v.videoWidth) continue;
      list.push({ v, area: r.width * r.height, playing: !v.paused && !v.ended });
    }
    if (!list.length) return null;
    list.sort((a, b) => (b.playing - a.playing) || (b.area - a.area));
    return list[0].v;
  }

  function videoFileName(v, ext) {
    let name = '';
    try {
      const src = v.currentSrc || v.src || '';
      if (src && !/^(blob|data):/i.test(src)) {
        const u = new URL(src, location.href);
        name = decodeURIComponent((u.pathname.split('/').pop() || '')).replace(/\.[^.]+$/, '');
      }
    } catch (e) {}
    if (!name) {
      name = String(document.title || 'video').replace(/[-_|].*$/, '').trim().slice(0, 40) || 'video';
    }
    name = name.replace(/[\\/:*?"<>|\s]+/g, '_');
    return `${name}_${Date.now()}.${ext}`;
  }

  function saveBlob(blob, filename) {
    let url = '';
    try {
      url = URL.createObjectURL(blob);
      const a = document.createElement('a');
      a.href = url;
      a.download = filename;
      a.style.display = 'none';
      document.body.appendChild(a);
      a.click();
      return true;
    } catch (e) {
      return false;
    } finally {
      if (url) setTimeout(() => {
        try { URL.revokeObjectURL(url); } catch (e) {}
      }, 5000);
    }
  }

  // 截图：canvas 取当前帧存 PNG
  function shotVideo(v) {
    v = v || pickActiveVideo();
    if (!v) { setStatus('截图：未找到可截取的视频', 'warn'); return; }
    const w = v.videoWidth, h = v.videoHeight;
    if (!w || !h) { setStatus('截图：画面还没加载完成', 'warn'); return; }
    try {
      const c = document.createElement('canvas');
      c.width = w;
      c.height = h;
      c.getContext('2d').drawImage(v, 0, 0, w, h);
      const finish = (blob) => {
        if (!blob) { setStatus('截图：生成图片失败', 'err'); return; }
        const ok = saveBlob(blob, videoFileName(v, 'png'));
        setStatus(ok ? '截图已保存' : '截图保存失败', ok ? 'ok' : 'err');
      };
      if (typeof c.toBlob === 'function') {
        c.toBlob(finish, 'image/png');
      } else {
        const b64 = c.toDataURL('image/png').split(',')[1];
        const bin = atob(b64);
        const buf = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; i++) buf[i] = bin.charCodeAt(i);
        finish(new Blob([buf], { type: 'image/png' }));
      }
    } catch (e) {
      setStatus('截图失败：该视频源不允许截取画面', 'err');
    }
  }

  // 下载：直链视频直接取 Blob 保存；m3u8 分片流提示不支持
  function downloadVideo(v) {
    v = v || pickActiveVideo();
    if (!v) { setStatus('下载：未找到视频', 'warn'); return; }
    const src = v.currentSrc || v.src || '';
    if (!src) { setStatus('下载：没拿到视频地址', 'warn'); return; }
    if (/\.m3u8(\?|#|$)/i.test(src) || /mpegurl/i.test(v.type || '')) {
      setStatus('下载：该视频是 m3u8 分片流，暂不支持直接下载', 'warn');
      return;
    }
    const name = videoFileName(v, 'mp4');
    const done = (blob) => {
      if (!blob || !blob.size) { setStatus('下载：获取视频失败（可能是防盗链）', 'err'); return; }
      setStatus(saveBlob(blob, name) ? `下载中：${(blob.size / 1048576).toFixed(1)}MB 已保存` : '下载保存失败', 'ok');
    };
    const fail = () => setStatus('下载：获取视频失败（可能是防盗链）', 'err');

    try {
      if (typeof GM_xmlhttpRequest === 'function' && /^https?:/i.test(src)) {
        setStatus('下载：正在获取视频…', 'warn');
        GM_xmlhttpRequest({
          method: 'GET',
          url: src,
          responseType: 'blob',
          timeout: 120000,
          onprogress: (e) => {
            if (e && e.lengthComputable && e.total) {
              setStatus(`下载：${Math.round(e.loaded / e.total * 100)}%`, 'warn');
            }
          },
          onload: (r) => {
            if (r.status >= 200 && r.status < 400 && r.response) done(r.response);
            else fail();
          },
          onerror: fail,
          ontimeout: fail
        });
        return;
      }
      setStatus('下载：正在获取视频…', 'warn');
      fetch(src, { credentials: 'include' })
        .then(r => r.ok ? r.blob() : Promise.reject(new Error('http ' + r.status)))
        .then(done)
        .catch(fail);
    } catch (e) {
      fail();
    }
  }

  // 画中画：进入 / 退出
  function togglePiP(v) {
    v = v || pickActiveVideo();
    if (!v) { setStatus('画中画：未找到视频', 'warn'); return; }
    if (!document.pictureInPictureEnabled || typeof v.requestPictureInPicture !== 'function') {
      setStatus('画中画：当前浏览器不支持', 'err');
      return;
    }
    if (document.pictureInPictureElement) {
      document.exitPictureInPicture()
        .then(() => setStatus('已退出画中画', 'ok'))
        .catch(() => setStatus('退出画中画失败', 'err'));
      return;
    }
    v.requestPictureInPicture()
      .then(() => setStatus('已进入画中画', 'ok'))
      .catch((e) => setStatus('画中画不可用：' + ((e && e.message) || '需要先点一下视频'), 'err'));
  }

  // 全屏：优先全屏播放器容器，其次 video 本身
  function toggleFullscreen(v) {
    v = v || pickActiveVideo();
    if (!v) { setStatus('全屏：未找到视频', 'warn'); return; }
    let el = v;
    try {
      el = v.closest('[class*="video"],[class*="player"],.vjs-player,.xgplayer,.prism-player') ||
        v.parentElement || v;
    } catch (e) {}
    try {
      if (document.fullscreenElement || document.webkitFullscreenElement) {
        (document.exitFullscreen || document.webkitExitFullscreen || function () {}).call(document);
        setStatus('已退出全屏', 'ok');
        return;
      }
      const req = el.requestFullscreen || el.webkitRequestFullscreen || el.mozRequestFullScreen || el.msRequestFullscreen;
      if (!req) { setStatus('全屏：当前浏览器不支持', 'err'); return; }
      const r = req.call(el);
      if (r && r.then) r.then(() => setStatus('已进入全屏', 'ok')).catch(() => setStatus('全屏失败（可能需要先点一下页面）', 'err'));
      else setStatus('已进入全屏', 'ok');
    } catch (e) {
      setStatus('全屏失败：' + ((e && e.message) || '浏览器限制'), 'err');
    }
  }

  // 快捷键：Alt+S / Alt+D / Alt+P / Alt+F
  try {
    document.addEventListener('keydown', (e) => {
      if (!e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) return;
      const t = e.target;
      if (t && (/^(input|textarea|select)$/i.test(t.tagName) || t.isContentEditable)) return;
      const key = String(e.key || '').toLowerCase();
      const fn = { s: shotVideo, d: downloadVideo, p: togglePiP, f: toggleFullscreen }[key];
      if (!fn) return;
      e.preventDefault();
      e.stopPropagation();
      fn();
    }, true);
  } catch (e) {}

  // ========== 倍速与强制守护（自研，不依赖第三方脚本） ==========
  let currentRate = 1;
  let forceAutoRate = false;

  // 开机第一时间抓取"原生" playbackRate 存取器（防止被页面脚本改写后拿不到）
  let NATIVE_RATE_GET = null, NATIVE_RATE_SET = null;
  try {
    const nd = Object.getOwnPropertyDescriptor(HTMLMediaElement.prototype, 'playbackRate');
    if (nd && nd.get && nd.set) { NATIVE_RATE_GET = nd.get; NATIVE_RATE_SET = nd.set; }
  } catch (e) {}

  // 递归获取所有 video（含同源 iframe）
  function getAllVideos() {
    const vids = [];
    function collect(doc, depth) {
      if (depth > 6) return;
      try {
        doc.querySelectorAll('video').forEach(v => vids.push(v));
        doc.querySelectorAll('iframe').forEach(f => {
          try { if (f.contentDocument) collect(f.contentDocument, depth + 1); } catch (e) {}
        });
      } catch (e) {}
    }
    collect(document, 0);
    return vids;
  }

  // 强制设置单个 video 的倍速（原生 setter + 实例锁定，平台改不回去）
  function forceVideoRate(v, rate) {
    try {
      // 1. 用原生 setter 直接改（绕过页面自定义的 setter）
      if (NATIVE_RATE_SET) {
        try { NATIVE_RATE_SET.call(v, rate); } catch (e) {}
      } else {
        v.playbackRate = rate;
      }
      try { if (v.defaultPlaybackRate !== rate) v.defaultPlaybackRate = rate; } catch (e) {}
      // 2. 在实例上锁定 playbackRate：平台再赋值也保持目标倍速
      if (v.__cxLockRate !== rate) {
        v.__cxLockRate = rate;
        try {
          Object.defineProperty(v, 'playbackRate', {
            configurable: true,
            enumerable: true,
            get() {
              try { return NATIVE_RATE_GET ? NATIVE_RATE_GET.call(v) : rate; } catch (e) { return rate; }
            },
            set() { /* 忽略平台的修改，倍速保持锁定 */ }
          });
        } catch (e) {}
      }
      // 3. 最后兜底：万一仍被改回去，再设一次
      if (Math.abs(v.playbackRate - rate) > 0.01 && NATIVE_RATE_SET) {
        try { NATIVE_RATE_SET.call(v, rate); } catch (e) {}
      }
    } catch (e) {}
  }

  // 解除锁定（停止挂机时调用，恢复正常可控）
  function unlockVideos() {
    for (const v of getAllVideos()) {
      try { delete v.playbackRate; } catch (e) {}
      try { delete v.__cxLockRate; } catch (e) {}
    }
  }

  // 只处理当前窗口的 video（跨域 iframe 里由各自脚本实例处理）
  function applyRateLocal(rate) {
    try { document.querySelectorAll('video').forEach(v => forceVideoRate(v, rate)); } catch (e) {}
  }

  // 向所有子 frame 广播倍速（跨域 iframe 也能收到）
  function broadcastRate(rate) {
    const send = (win) => {
      try { win.postMessage({ __cxRate: rate }, '*'); } catch (e) {}
      let frames, len = 0;
      try { frames = win.frames; len = frames.length; } catch (e) { return; }
      for (let i = 0; i < len; i++) {
        try { send(frames[i]); } catch (e) {}
      }
    };
    try { send(window); } catch (e) {}
  }

  // 每个窗口（含跨域 iframe）都监听倍速广播并本地强制
  let frameRate = 0; // 由上级窗口广播过来的目标倍速（仅 iframe 使用）
  try {
    window.addEventListener('message', (e) => {
      if (e.source === window) return; // 忽略自己发出的广播
      const d = e.data;
      if (!d || typeof d !== 'object' || typeof d.__cxRate !== 'number') return;
      if (d.__cxRate < 0) { frameRate = 0; return; } // 停止挂机，解除强制
      frameRate = d.__cxRate;
      applyRateLocal(d.__cxRate);
    });
  } catch (e) {}

  // 平台若在本窗口把倍速改回去，立即再强制一次（ratechange 实时纠偏）
  try {
    document.addEventListener('ratechange', (e) => {
      const v = e.target;
      if (!v || v.tagName !== 'VIDEO') return;
      const target = forceAutoRate ? currentRate : frameRate;
      if (!target) return;
      if (Math.abs(v.playbackRate - target) > 0.01) {
        setTimeout(() => forceVideoRate(v, target), 50);
      }
    }, true);
  } catch (e) {}

  function setRate(rate) {
    currentRate = rate;
    // 本窗口 + 同源 iframe 的 video
    applyRateLocal(rate);
    for (const v of getAllVideos()) forceVideoRate(v, rate);
    // 通知所有 iframe（含跨域）各自强制
    broadcastRate(rate);
  }

  // 独立的高频倍速守护（不依赖 tick；电脑端播放器会频繁把倍速改回 1x）
  let rateTimer = null;
  function startRateKeeper() {
    if (rateTimer) return;
    rateTimer = setInterval(() => {
      if (!forceAutoRate) return;
      applyRateLocal(currentRate);
      for (const v of getAllVideos()) forceVideoRate(v, currentRate);
      broadcastRate(currentRate);
    }, 500);
  }
  function stopRateKeeper() {
    if (rateTimer) { clearInterval(rateTimer); rateTimer = null; }
  }

  // 定时确保倍速不被重置（顶层 + 跨域 iframe 广播）
  function ensureRate() {
    if (!forceAutoRate) return;
    setRate(currentRate);
  }

  function initPanel() {
    // 只在顶层窗口创建面板，避免 iframe 重复创建
    if (window.top !== window.self) return;
    if (window.__cxPanel) return;
    window.__cxPanel = true;

    const host = document.createElement('div');
    host.style.cssText = 'position:fixed;top:16px;right:16px;z-index:2147483647;';
    document.documentElement.appendChild(host);

    const shadow = host.attachShadow({ mode: 'open' });
    window.__shadow = shadow; // 暴露给题库弹窗等功能使用
    const style = document.createElement('style');
    style.textContent = `
      .box{width:200px;font:13px/1.5 system-ui,"Microsoft YaHei",sans-serif;
           color:#e8eaed;background:#1f2430;border:1px solid #39415a;
           border-radius:10px;box-shadow:0 6px 24px rgba(0,0,0,.35);overflow:hidden}
      .hd{display:flex;align-items:center;justify-content:space-between;
          padding:10px 12px;background:#2a3247;cursor:move;user-select:none;
          -webkit-user-select:none;touch-action:none}
      .hd b{font-size:13px;font-weight:600}
      .hd .fold{cursor:pointer;opacity:.7;padding:0 6px;font-size:16px}
      .bd{padding:10px 12px}
      .row{display:flex;align-items:center;justify-content:space-between;margin-bottom:10px}
      .btn{flex:1;padding:9px 0;border:0;border-radius:6px;cursor:pointer;
           font-size:13px;font-weight:600;color:#fff;background:#3d6bf5}
      .btn.off{background:#59627a}
      select{padding:6px 8px;border-radius:6px;border:1px solid #39415a;
             background:#1a1e28;color:#e8eaed;font-size:13px;cursor:pointer}
      .tip{color:#9aa3b8;font-size:12px}
      .ok{color:#4ade80}
      .warn{color:#fbbf24}
      .tools{display:grid;grid-template-columns:1fr 1fr;gap:6px;margin-bottom:10px}
      .tbtn{padding:7px 0;border:0;border-radius:6px;cursor:pointer;
            font-size:12px;color:#e8eaed;background:#2a3247;border:1px solid #39415a}
      .tbtn:active{background:#3d6bf5}
      .linkbtn{display:block;text-align:center;padding:8px 0;border-radius:6px;
               font-size:13px;color:#93c5fd;background:#1a1e28;border:1px solid #39415a;
               text-decoration:none}
      .linkbtn:active{background:#3d6bf5;color:#fff}
      .mbtn{flex:1;padding:6px 0;border:1px solid #39415a;border-radius:6px;
            font-size:12px;color:#9aa3b8;background:#1a1e28;cursor:pointer}
      .mbtn.on{color:#fff;background:#3d6bf5;border-color:#3d6bf5}
      .gbtn{padding:4px 10px;border:0;border-radius:6px;font-size:12px;
            color:#fff;background:#3d6bf5;cursor:pointer;white-space:nowrap}
      .gbtn:active{background:#2d5be5}
      .sec{margin-bottom:8px;border:1px solid #39415a;border-radius:8px;background:#1a1e28;overflow:hidden}
      .sec summary{display:flex;align-items:center;padding:7px 10px;cursor:pointer;
                   font-size:12px;color:#cbd5e1;list-style:none;user-select:none;-webkit-user-select:none}
      .sec summary::-webkit-details-marker{display:none}
      .sec summary>span:first-child{flex:1}
      .sec summary::after{content:'▾';color:#7c869e;font-size:10px;margin-left:8px}
      .sec[open] summary::after{content:'▴'}
      .secbody{padding:8px 10px 0;border-top:1px solid #2a3247}
      .badge{font-size:11px;color:#93c5fd;background:#232a3a;border-radius:10px;padding:1px 8px}
      .orow{display:flex;align-items:center;margin-bottom:8px}
      .orow input{margin-right:6px}
      #dsRow{display:flex;gap:6px;align-items:center}
      .banklink{color:#93c5fd;text-decoration:none;cursor:pointer}
      .banklink:active{color:#bfdbfe}
      .bankmask{position:fixed;inset:0;background:rgba(0,0,0,.6);z-index:2147483646;
                 display:flex;align-items:center;justify-content:center;padding:20px}
      .bankbox{background:#1e2330;border-radius:12px;padding:16px;width:100%;max-width:420px;
               max-height:80vh;display:flex;flex-direction:column}
      .bankhd{display:flex;justify-content:space-between;align-items:center;margin-bottom:12px}
      .bankhd b{color:#fff;font-size:15px}
      .bankclose{color:#9aa3b8;font-size:20px;cursor:pointer;background:none;border:0;padding:0 6px}
      .banktools{display:flex;gap:6px;margin-left:auto;margin-right:8px}
      .banktools button{padding:3px 8px;background:none;border:1px solid #3b4a6b;color:#93c5fd;
                        border-radius:5px;font-size:12px;cursor:pointer}
      .banklist{overflow-y:auto;flex:1}
      .bankitem{padding:10px 0;border-bottom:1px solid #2a3247;font-size:13px;color:#e8eaed}
      .bankitem .bq{color:#cbd5e1;margin-bottom:4px;word-break:break-all}
      .bankitem .ba{color:#4ade80;font-weight:bold}
      .bankempty{color:#9aa3b8;text-align:center;padding:30px 0}
      .bankclear{margin-top:10px;padding:8px;border:1px solid #ef4444;border-radius:6px;
                  background:none;color:#ef4444;font-size:12px;cursor:pointer}
      .bankclear:active{background:#ef4444;color:#fff}
      .ctxm{position:fixed;left:0;top:0;z-index:2147483647;display:none;min-width:158px;
            background:#1f2430;border:1px solid #39415a;border-radius:8px;padding:4px;
            box-shadow:0 8px 28px rgba(0,0,0,.5);color:#e8eaed;font-size:13px}
      .ctxm.show{display:block}
      .ctxm .ti{font-size:11px;opacity:.5;padding:2px 10px 4px}
      .ctxm .it{padding:8px 10px;border-radius:6px;cursor:pointer;white-space:nowrap}
      .ctxm .it:hover{background:#2b3346}
      .ctxm .sep{height:1px;background:#39415a;margin:4px 2px}
    `;
    shadow.appendChild(style);

    const box = document.createElement('div');
    box.className = 'box';
    box.innerHTML = `
      <div class="hd"><b>超星小助手</b><span style="font-size:11px;opacity:.6;margin-left:4px">v5.14.2</span><span class="fold">—</span></div>
      <div class="bd">
        <div class="row"><button class="btn off" data-act="hang">▶ 开始挂机</button></div>
        <div class="row"><span>倍速</span><select class="rate"></select></div>
        <div class="tip">任务点：<span class="tasktype">识别中…</span></div>
        <div class="tip">状态：<span class="stat">待启动</span></div>
        <div class="tip">进度：<span class="prog">-</span></div>
        <details class="sec" open>
          <summary><span>答题设置</span><span class="badge qmode">跳过答题</span></summary>
          <div class="secbody">
            <label class="tip orow"><input type="checkbox" class="skip" checked> 跳过答题</label>
            <label class="tip orow"><input type="checkbox" class="ai"> AI搜题答题</label>
            <div class="row" style="display:none" id="aiModeRow">
              <button class="mbtn on" data-mode="key">DeepSeek Key</button>
              <button class="mbtn" data-mode="search">搜索引擎</button>
            </div>
            <div class="row" style="display:none" id="dsRow">
              <input type="password" class="dskey" placeholder="粘贴 DeepSeek API Key" style="flex:1;font-size:12px;padding:4px 6px;border:1px solid #ddd;border-radius:4px;min-width:0">
              <button class="gbtn" data-act="getkey">获取Key</button>
            </div>
            <div class="tip orow" style="display:none;font-size:10px;opacity:.5;line-height:1.4" id="dsTip">注册→创建API Key→复制粘贴（送500万token）</div>
            <div class="tools">
              <button class="tbtn" data-act="savecfg">保存设置</button>
              <button class="tbtn" data-act="testai">测试 AI</button>
            </div>
          </div>
        </details>
        <details class="sec">
          <summary><span>题库</span><span class="badge"><span class="banksize">0</span> 题</span></summary>
          <div class="secbody">
            <div class="tip orow"><a class="banklink" href="javascript:;">查看全部已保存题目</a></div>
            <div class="tools">
              <button class="tbtn" data-act="importbank">导入题库</button>
              <button class="tbtn" data-act="exportbank">导出题库</button>
            </div>
          </div>
        </details>
        <details class="sec">
          <summary><span>其他功能</span><span class="badge">工具</span></summary>
          <div class="secbody">
            <label class="tip orow"><input type="checkbox" class="mute" checked> 静音挂机</label>
            <label class="tip orow"><input type="checkbox" class="keepalive" checked> 后台保活</label>
            <label class="tip orow"><input type="checkbox" class="doc" checked> 自动完成文档</label>
            <label class="tip orow"><input type="checkbox" class="face" checked> 人脸识别提醒</label>
            <label class="tip orow"><input type="checkbox" class="fontdec"> 字体解密</label>
            <label class="tip orow"><input type="checkbox" class="ctxmenu" checked> 鼠标右键快捷菜单</label>
            <div class="tools">
              <button class="tbtn" data-act="shot">截图</button>
              <button class="tbtn" data-act="dl">下载</button>
              <button class="tbtn" data-act="pip">画中画</button>
              <button class="tbtn" data-act="fs">全屏</button>
            </div>
            <div class="tip" style="opacity:.55;font-size:11px">快捷键：Alt+S / Alt+D / Alt+P / Alt+F</div>
          </div>
        </details>
        <input type="file" class="bankfile" accept=".json,application/json" style="display:none">
        <div class="tip" style="margin-top:4px;color:#52c41a">✓ 永久免费 · 无使用限制</div>
        <div class="tip" style="margin-top:2px;opacity:.5;font-size:11px">仅供学习交流 · 使用风险自负</div>
      </div>
    `;
    shadow.appendChild(box);

    const $fold = box.querySelector('.fold');
    const $body = box.querySelector('.bd');
    const $hang = box.querySelector('[data-act=hang]');
    const $rate = box.querySelector('.rate');
    const $mute = box.querySelector('.mute');
    const $skip = box.querySelector('.skip');
    const $stat = box.querySelector('.stat');
    const $tasktype = box.querySelector('.tasktype');
    const $prog = box.querySelector('.prog');
    const $banksize = box.querySelector('.banksize');
    const $banklink = box.querySelector('.banklink');
    const $ai = box.querySelector('.ai');
    const $aiModeRow = box.querySelector('#aiModeRow');
    const $dsRow = box.querySelector('#dsRow');
    const $dsTip = box.querySelector('#dsTip');
    const $dskey = box.querySelector('.dskey');
    const $getkeyBtn = box.querySelector('[data-act=getkey]');
    const $modeBtns = box.querySelectorAll('.mbtn');

    // 初始化题库题数显示
    try { $banksize.textContent = getBankSize(); } catch (e) {}

    // 倍速选项（新存储键，默认 1x，忽略旧版本保存的值）
    let savedRate = 1;
    try { savedRate = parseInt(GM_getValue('cx_rate2', '1')) || 1; } catch (e) {}
    for (let r = 1; r <= 16; r++) {
      const o = document.createElement('option');
      o.value = String(r);
      o.textContent = r + 'x';
      if (r === savedRate) o.selected = true;
      $rate.appendChild(o);
    }
    currentRate = savedRate;

    $fold.addEventListener('click', () => {
      const hidden = $body.style.display === 'none';
      $body.style.display = hidden ? '' : 'none';
      $fold.textContent = hidden ? '—' : '+';
    });

    $rate.addEventListener('change', () => {
      currentRate = parseFloat($rate.value) || 1;
      try { GM_setValue('cx_rate2', String(currentRate)); } catch (e) {}
      forceAutoRate = true; // 选了倍速就持续保持
      setRate(currentRate); // 选倍速后立即生效，不管是否挂机
      startRateKeeper();    // 开启高频守护，电脑端也不被改回 1x
    });

    $hang.addEventListener('click', () => {
      if (running) stopHang();
      else startHang();
    });

    // 加载已保存的搜题模式（key 或 search）
    let aiMode = 'key';
    try { aiMode = GM_getValue('ai_mode', 'key') || 'key'; } catch (e) {}

    // 切换模式按钮高亮
    function setAiMode(mode) {
      aiMode = mode;
      try { GM_setValue('ai_mode', mode); } catch (e) {}
      $modeBtns.forEach(b => {
        b.classList.toggle('on', b.dataset.mode === mode);
      });
      // 选 Key 才显示输入框和提示
      const showDs = mode === 'key';
      $dsRow.style.display = showDs ? '' : 'none';
      $dsTip.style.display = showDs ? '' : 'none';
    }

    // AI 开关：打开时显示模式选择行；两个答题模式互斥，开 AI 就关掉"跳过答题"
    $ai.addEventListener('change', () => {
      if ($ai.checked) {
        $skip.checked = false;
        try { GM_setValue('cx_quiz_mode', 'ai'); } catch (e) {}
      } else {
        try { GM_setValue('cx_quiz_mode', ''); } catch (e) {}
      }
      $aiModeRow.style.display = $ai.checked ? '' : 'none';
      if ($ai.checked) setAiMode(aiMode);
      else { $dsRow.style.display = 'none'; $dsTip.style.display = 'none'; }
      try { savePrefs(); } catch (e) {}
      try { updateQmodeBadge(); } catch (e) {}
    });

    // "跳过答题"：勾上就取消 AI搜题答题（互斥）
    $skip.addEventListener('change', () => {
      if ($skip.checked) {
        $ai.checked = false;
        $aiModeRow.style.display = 'none';
        $dsRow.style.display = 'none';
        $dsTip.style.display = 'none';
        try { GM_setValue('cx_quiz_mode', 'skip'); } catch (e) {}
      } else {
        try { GM_setValue('cx_quiz_mode', ''); } catch (e) {}
      }
      try { savePrefs(); } catch (e) {}
      try { updateQmodeBadge(); } catch (e) {}
    });

    // 模式按钮点击
    $modeBtns.forEach(b => {
      b.addEventListener('click', () => setAiMode(b.dataset.mode));
    });

    // 初始化模式显示
    setAiMode(aiMode);

    // ========== 复选框状态持久化（刷新不丢） ==========
    const PREFS_KEY = 'cx_prefs';
    const $checkboxes = box.querySelectorAll('input[type="checkbox"]');
    // 加载已保存的勾选状态
    try {
      const prefs = JSON.parse(GM_getValue(PREFS_KEY, '{}') || '{}');
      $checkboxes.forEach(cb => {
        const cls = cb.className;
        if (prefs.hasOwnProperty(cls)) cb.checked = prefs[cls];
      });
    } catch (e) {}
    // 勾选变化时自动保存
    function savePrefs() {
      try {
        const prefs = {};
        $checkboxes.forEach(cb => { prefs[cb.className] = cb.checked; });
        GM_setValue(PREFS_KEY, JSON.stringify(prefs));
      } catch (e) {}
    }
    $checkboxes.forEach(cb => cb.addEventListener('change', savePrefs));

    // 折叠区徽标：随时显示当前答题模式
    const $qmodeBadge = box.querySelector('.qmode');
    function updateQmodeBadge() {
      if (!$qmodeBadge) return;
      $qmodeBadge.textContent = $ai.checked ? 'AI搜题' : ($skip.checked ? '跳过答题' : '未开启');
    }
    updateQmodeBadge();

    // 旧版本可能两个答题模式都勾着：只保留一个（按上次选择的模式，没记录则优先 AI搜题答题）
    if ($skip.checked && $ai.checked) {
      let savedMode = '';
      try { savedMode = GM_getValue('cx_quiz_mode', '') || ''; } catch (e) {}
      if (savedMode === 'skip') $ai.checked = false; else $skip.checked = false;
      savePrefs();
    }
    // AI 开关恢复时同步显示模式行
    $aiModeRow.style.display = $ai.checked ? '' : 'none';
    if ($ai.checked) setAiMode(aiMode); else { $dsRow.style.display = 'none'; $dsTip.style.display = 'none'; }
    updateQmodeBadge();

    // 加载已保存的 DeepSeek Key（刷新不丢）
    try {
      const savedKey = GM_getValue('ds_api_key', '');
      if (savedKey) $dskey.value = savedKey;
    } catch (e) {}
    // 多重事件兜底保存：input / change / blur / paste，确保手机端粘贴也能记住
    function saveDsKey() {
      try { GM_setValue('ds_api_key', $dskey.value.trim()); } catch (e) {}
    }
    $dskey.addEventListener('input', saveDsKey);
    $dskey.addEventListener('change', saveDsKey);
    $dskey.addEventListener('blur', saveDsKey);
    $dskey.addEventListener('paste', () => setTimeout(saveDsKey, 100));

    // 获取Key按钮：一键直接跳转到 API Keys 创建页
    // 用动态 <a> 标签点击，浏览器原生行为，不会被拦截
    $getkeyBtn.addEventListener('click', () => {
      const url = 'https://platform.deepseek.com/api_keys';
      try {
        const a = document.createElement('a');
        a.href = url;
        a.target = '_blank';
        a.rel = 'noopener';
        a.style.display = 'none';
        document.body.appendChild(a);
        a.click();
        document.body.removeChild(a);
      } catch (e) {
        location.href = url;
      }
    });

    // 点击题库链接：显示全部已保存题目
    $banklink.addEventListener('click', () => showBankDetail());

    // ========== 保存设置 / 测试 AI / 题库导入导出 ==========
    const $bankfile = box.querySelector('.bankfile');
    const $savecfgBtn = box.querySelector('[data-act=savecfg]');
    const $testaiBtn = box.querySelector('[data-act=testai]');
    const $importbankBtn = box.querySelector('[data-act=importbank]');
    const $exportbankBtn = box.querySelector('[data-act=exportbank]');

    // 保存设置：把当前所有勾选、倍速、搜题模式、Key 一次性落盘
    $savecfgBtn.addEventListener('click', () => {
      try {
        savePrefs();
        saveDsKey();
        GM_setValue('cx_rate2', String(currentRate));
        GM_setValue('ai_mode', aiMode);
        GM_setValue('cx_quiz_mode', $ai.checked ? 'ai' : ($skip.checked ? 'skip' : ''));
      } catch (e) {}
      setStatus('设置已保存（刷新不会丢）', 'ok');
    });

    // 测试 AI：Key 模式测 DeepSeek，搜索引擎模式测 Bing 连通性
    $testaiBtn.addEventListener('click', async () => {
      if (aiMode === 'key') {
        const key = ($dskey.value || '').trim();
        if (!key) { setStatus('请先填写 DeepSeek Key', 'err'); return; }
        setStatus('测试 DeepSeek 中…');
        try {
          GM_xmlhttpRequest({
            method: 'POST',
            url: 'https://api.deepseek.com/v1/chat/completions',
            headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + key },
            data: JSON.stringify({
              model: 'deepseek-chat',
              messages: [{ role: 'user', content: '回复：OK' }],
              temperature: 0,
              max_tokens: 5
            }),
            timeout: 20000,
            onload: (resp) => {
              try {
                const data = JSON.parse(resp.responseText || '{}');
                const c = data.choices && data.choices[0] && data.choices[0].message
                  ? data.choices[0].message.content : '';
                if (resp.status === 200 && c) setStatus('AI 可用：' + String(c).trim().slice(0, 20), 'ok');
                else if (resp.status === 401) setStatus('AI 测试失败：Key 无效（401）', 'err');
                else if (resp.status === 402 || resp.status === 403) setStatus('AI 测试失败：余额不足或无权限', 'err');
                else setStatus('AI 测试失败：HTTP ' + resp.status, 'err');
              } catch (e) { setStatus('AI 测试失败：返回无法解析', 'err'); }
            },
            onerror: () => setStatus('AI 测试失败：网络错误', 'err'),
            ontimeout: () => setStatus('AI 测试失败：请求超时', 'err')
          });
        } catch (e) {
          setStatus('AI 测试失败：请求发不出去', 'err');
        }
      } else {
        setStatus('测试搜索引擎中…');
        try {
          const txt = await fetchSearchText('https://www.bing.com/search?q=' + encodeURIComponent('学习通'));
          if (txt && txt.length > 300) setStatus('搜索引擎可用（Bing）', 'ok');
          else setStatus('Bing 请求失败或被拦截，可换 Key 模式', 'err');
        } catch (e) {
          setStatus('搜索引擎测试失败', 'err');
        }
      }
    });

    // 导入题库
    $importbankBtn.addEventListener('click', () => $bankfile.click());
    $bankfile.addEventListener('change', (e) => {
      const file = e.target.files && e.target.files[0];
      if (!file) return;
      const reader = new FileReader();
      reader.onload = () => {
        const n = importBankJson(String(reader.result || ''));
        try { $banksize.textContent = getBankSize(); } catch (e2) {}
        if (n > 0) setStatus(`题库导入 ${n} 题，共 ${getBankSize()} 题`, 'ok');
        else setStatus('题库导入失败：不是合法 JSON', 'err');
      };
      reader.readAsText(file, 'utf-8');
      e.target.value = '';
    });

    // 导出题库
    $exportbankBtn.addEventListener('click', () => {
      if (getBankSize() === 0) { setStatus('题库为空，无可导出内容'); return; }
      exportBankJson();
    });

    // ========== 视频工具按钮（截图 / 下载 / 画中画 / 全屏） ==========
    const $shotBtn = box.querySelector('[data-act=shot]');
    const $dlBtn = box.querySelector('[data-act=dl]');
    const $pipBtn = box.querySelector('[data-act=pip]');
    const $fsBtn = box.querySelector('[data-act=fs]');
    if ($shotBtn) $shotBtn.addEventListener('click', () => shotVideo());
    if ($dlBtn) $dlBtn.addEventListener('click', () => downloadVideo());
    if ($pipBtn) $pipBtn.addEventListener('click', () => togglePiP());
    if ($fsBtn) $fsBtn.addEventListener('click', () => toggleFullscreen());

    // ========== 鼠标右键快捷菜单（在鼠标位置弹出学习通入口） ==========
    const $ctxmenu = box.querySelector('.ctxmenu');
    const $ctx = document.createElement('div');
    $ctx.className = 'ctxm';
    shadow.appendChild($ctx);
    let ctxOpen = false;

    const CX_LINKS = [
      { t: '📖 超星首页', u: 'https://www.chaoxing.com/' },
      { t: '📚 我的课程', u: 'https://i.chaoxing.com/' },
      { t: '🎬 开始学习', u: 'https://mooc1.chaoxing.com/' },
      { t: '🔑 获取 DeepSeek Key', u: 'https://platform.deepseek.com/api_keys' }
    ];

    function openUrl(url) {
      try {
        const a = document.createElement('a');
        a.href = url; a.target = '_blank'; a.rel = 'noopener';
        a.style.display = 'none';
        document.body.appendChild(a); a.click(); document.body.removeChild(a);
      } catch (e) { location.href = url; }
    }

    function hideCtx() { $ctx.classList.remove('show'); ctxOpen = false; }

    function showCtx(x, y) {
      $ctx.innerHTML = '<div class="ti">超星快捷入口</div>' +
        CX_LINKS.map((l, i) => `<div class="it" data-i="${i}">${l.t}</div>`).join('') +
        '<div class="sep"></div><div class="it" data-i="-1">✕ 关闭菜单</div>';
      $ctx.classList.add('show');
      const r = $ctx.getBoundingClientRect();
      const px = Math.max(8, Math.min(x, window.innerWidth - r.width - 8));
      const py = Math.max(8, Math.min(y, window.innerHeight - r.height - 8));
      $ctx.style.left = px + 'px';
      $ctx.style.top = py + 'px';
      ctxOpen = true;
    }

    $ctx.addEventListener('click', (e) => {
      const it = e.target.closest('.it');
      if (!it) return;
      const i = parseInt(it.dataset.i, 10);
      hideCtx();
      if (i >= 0 && CX_LINKS[i]) openUrl(CX_LINKS[i].u);
    });

    document.addEventListener('contextmenu', (e) => {
      if (!$ctxmenu.checked) return;
      const t = e.target;
      const tag = (t && t.tagName || '').toLowerCase();
      // 输入框、可编辑区、已选中文字时不劫持，保留原生菜单
      if (tag === 'input' || tag === 'textarea' || (t && t.isContentEditable)) return;
      if (window.getSelection && String(window.getSelection()).length > 0) return;
      e.preventDefault();
      showCtx(e.clientX, e.clientY);
    }, true);

    document.addEventListener('mousedown', (e) => {
      if (!ctxOpen) return;
      const path = e.composedPath ? e.composedPath() : [];
      if (path.includes($ctx)) return;
      hideCtx();
    }, true);

    window.addEventListener('scroll', hideCtx, true);
    document.addEventListener('keydown', (e) => { if (e.key === 'Escape') hideCtx(); });

    // 拖动
    let sx=0, sy=0, ox=0, oy=0, on=false;
    host.style.touchAction = 'none';
    host.addEventListener('pointerdown', (e) => {
      const path = e.composedPath ? e.composedPath() : [];
      for (const el of path) {
        if (el === host) break;
        if (el.nodeType !== 1) continue;
        if (el.matches && el.matches('button,select,input,label,summary,a')) return;
      }
      on = true; sx = e.clientX; sy = e.clientY;
      const r = host.getBoundingClientRect();
      ox = r.left; oy = r.top;
      host.style.right = 'auto'; host.style.left = ox + 'px';
    });
    document.addEventListener('pointermove', (e) => {
      if (!on) return;
      let nx = ox + (e.clientX - sx);
      let ny = oy + (e.clientY - sy);
      nx = Math.max(0, Math.min(window.innerWidth - host.offsetWidth, nx));
      ny = Math.max(0, Math.min(window.innerHeight - host.offsetHeight, ny));
      host.style.left = nx + 'px';
      host.style.top = ny + 'px';
    });
    document.addEventListener('pointerup', () => { on = false; });
    document.addEventListener('pointercancel', () => { on = false; });

    // 页面初始渲染完成后应用一次倍速
    setTimeout(() => { setRate(currentRate); }, 0);

    window.__ui = { $stat, $prog, $hang, $banksize, $tasktype };

    // 页面跳转（切任务点/换章节）后自动恢复挂机，5 分钟内有效
    try {
      const saved = JSON.parse(GM_getValue('cx_running', '') || '{}');
      if (isChaoxing && saved && saved.on && Date.now() - (saved.t || 0) < 5 * 60 * 1000) {
        setTimeout(() => { if (!running) startHang(); }, 1200);
      }
    } catch (e) {}
  }

  function setStatus(text, cls) {
    if (!window.__ui) return;
    window.__ui.$stat.textContent = text;
    window.__ui.$stat.className = 'stat' + (cls ? ' ' + cls : '');
  }
  function setProg(text) {
    if (!window.__ui) return;
    window.__ui.$prog.textContent = text;
  }
  function setTaskType(text) {
    if (!window.__ui || !window.__ui.$tasktype) return;
    if (window.__ui.$tasktype.textContent === text) return;
    window.__ui.$tasktype.textContent = text;
  }

  // ========== 学习通自动刷课逻辑 ==========
  const isChaoxing = /chaoxing\.com|xuexitong\.com|xueyinonline\.com|mooc[1-9]?\.chaoxing\.com/i.test(location.href);

  let running = false;
  let tickTimer = null;
  let quizCooldown = 0;
  let lastNextClickTime = 0; // 上次点"下一节"的时间戳
  const NEXT_CLICK_INTERVAL = 8000; // 两次点击之间最小间隔（毫秒），AI 答题不受此限制
  let scrollCount = 0;
  let fallbackCooldown = 0; // 兜底跳转（滚动/目录）的冷却，避免每秒重复执行

  function startHang() {
    if (running) return;
    running = true;
    forceAutoRate = true;
    try { GM_setValue('cx_running', JSON.stringify({ on: true, t: Date.now() })); } catch (e) {}
    if (window.__ui) {
      window.__ui.$hang.textContent = '■ 停止挂机';
      window.__ui.$hang.classList.remove('off');
    }
    setRate(currentRate);
    startRateKeeper();
    setStatus('启动中…');
    docScrollState = null;
    fontDecryptAttempted = false;
    if (tickTimer) clearInterval(tickTimer);
    tickTimer = setInterval(tick, 1000);
    // 后台保活：静音音频循环 + 切回标签页立即恢复播放
    initBackgroundKeepAlive();
    if (isChaoxing) tick();
  }

  // ========== 后台保活 ==========
  let keepAliveAudio = null;
  function initBackgroundKeepAlive() {
    if (keepAliveAudio) return;
    try {
      // 用一个静音音频循环播放，防止浏览器把标签页过度节流
      keepAliveAudio = document.createElement('audio');
      keepAliveAudio.loop = true;
      keepAliveAudio.muted = true;
      keepAliveAudio.volume = 0;
      // base64 编码的极短静音 wav
      keepAliveAudio.src = 'data:audio/wav;base64,UklGRigAAABXQVZFZm10IBIAAAABAAEARKwAAIhYAQACABAAAABkYXRhAgAAAAEA';
      keepAliveAudio.play().catch(() => {});
    } catch (e) {}

    // 切回标签页时立即恢复播放
    document.addEventListener('visibilitychange', () => {
      if (!document.hidden) {
        const videos = collectVideos();
        videos.forEach(item => {
          try {
            if (item.v.paused) item.v.play().catch(() => {});
          } catch (e) {}
        });
      }
    });

    // 每 2 秒尝试恢复后台暂停的视频（即使标签页不可见）
    setInterval(() => {
      if (document.querySelector('.keepalive')?.checked === false) return;
      const videos = collectVideos();
      videos.forEach(item => {
        try {
          if (item.v.paused && !item.v.ended) {
            item.v.muted = true;
            item.v.play().catch(() => {});
          }
        } catch (e) {}
      });
    }, 2000);
  }

  function stopHang() {
    running = false;
    forceAutoRate = false;
    try { GM_setValue('cx_running', ''); } catch (e) {}
    if (tickTimer) { clearInterval(tickTimer); tickTimer = null; }
    stopRateKeeper();
    // 通知所有 iframe 解除倍速强制
    broadcastRate(-1);
    unlockVideos();
    if (window.__ui) {
      window.__ui.$hang.textContent = '▶ 开始挂机';
      window.__ui.$hang.classList.add('off');
    }
    setStatus('已停止');
  }

  function collectVideos() {
    const vids = [];
    function collect(doc, depth) {
      if (depth > 5) return;
      try {
        doc.querySelectorAll('video').forEach(v => {
          // 跳过隐藏/未激活的视频（避免处理其它任务点的残留播放器）
          try {
            const r = v.getBoundingClientRect();
            if (r.width < 10 || r.height < 10) return;
          } catch (e) {}
          vids.push({ v, doc });
        });
        doc.querySelectorAll('iframe').forEach(f => {
          try { if (f.contentDocument) collect(f.contentDocument, depth + 1); } catch (e) {}
        });
      } catch (e) {}
    }
    collect(document, 0);
    return vids;
  }

  // 递归收集所有 document（包括 iframe），供跨框架检测使用
  function getAllDocs() {
    const docs = [];
    function collect(d, depth) {
      if (depth > 5 || !d) return;
      if (docs.indexOf(d) === -1) docs.push(d);
      try {
        d.querySelectorAll('iframe').forEach(f => {
          try { if (f.contentDocument) collect(f.contentDocument, depth + 1); } catch (e) {}
        });
      } catch (e) {}
    }
    try { collect(document, 0); } catch (e) {}
    return docs;
  }

  // 找到当前视频所属的任务点容器（.ans-attach-ct / .ans-job-ct）
  function getTaskContainerFor(v, doc) {
    try {
      for (const d of getAllDocs()) {
        let iframes;
        try { iframes = d.querySelectorAll('iframe'); } catch (e) { continue; }
        for (const f of iframes) {
          let cd = null;
          try { cd = f.contentDocument || (f.contentWindow && f.contentWindow.document); } catch (e) {}
          if (cd && cd === doc) {
            const box = f.closest('.ans-attach-ct, .ans-job-ct, .ans-attach');
            if (box) return box;
          }
        }
      }
    } catch (e) {}
    try {
      const box = v && v.closest && v.closest('.ans-attach-ct, .ans-job-ct, .ans-attach');
      if (box) return box;
    } catch (e) {}
    return null;
  }

  function isTaskCompleted(doc, v) {
    try {
      // 1) 只看"当前这个视频"的任务点容器，避免章节里其它任务已完成导致误判
      const box = getTaskContainerFor(v, doc);
      if (box) {
        // 容器自身或上两级祖先带完成标记
        let n = box;
        for (let i = 0; i < 3 && n; i++, n = n.parentElement) {
          const cls = (n.className || '').toString();
          if (/ans-job-finished/.test(cls)) return true;
          if (/已完成/.test((n.getAttribute && n.getAttribute('aria-label')) || '')) return true;
        }
        try {
          const icon = box.querySelector('.ans-job-icon[aria-label*="已完成"], .ans-job-icon[title*="已完成"]');
          if (icon) return true;
        } catch (e) {}
        const t = (box.textContent || '').replace(/\s+/g, '');
        if (/任务点已完成/.test(t)) return true;
        return false; // 容器明确存在且未完成
      }
      // 2) 定位不到容器时，只在视频所在文档内判断，不做全页搜索
      if (doc && doc.body) {
        const t = (doc.body.innerText || '').replace(/\s+/g, '');
        if (/任务点已完成/.test(t)) return true;
      }
    } catch (e) {}
    return false;
  }

  function isQuizPage() {
    // 跨 iframe 判断：有题目特征（题型/单选圈）才算答题页
    const docs = getAllDocs();
    for (const d of docs) {
      if (!d.body) continue;
      // 学习通标准测验结构（最可靠）
      try {
        if (d.querySelector('input[id^="answertype"]') || d.querySelector('.TiMu, .singleQuesId, .Zy_TItle, #form1 #RightCon')) return true;
      } catch (e) {}
      const text = d.body.innerText || '';
      if (/(单选题|多选题|判断题)/.test(text) && /(测验|答题|题目|下列)/.test(text)) return true;
      if (/测验/.test(text) &&
          d.querySelector('input[type="radio"], input[type="checkbox"], .singleQuesId, .mulQuesId, .judgeQuesId')) {
        return true;
      }
    }
    return false;
  }

  // 判断任务点标签/目录项是否处于"当前选中"状态（只认完整类名词，避免 icon/button 被误判）
  function isActiveTaskEl(el, ignoreCursor) {
    try {
      let n = el;
      for (let i = 0; i < 4 && n && n.getAttribute; i++, n = n.parentElement) {
        const cls = (n.className || '').toString();
        if (/posCatalog_select/i.test(cls)) return true;
        if (/(^|\s)_select(\s|$)/.test(cls)) return true;
        const tokens = cls.split(/\s+/);
        for (const t of tokens) {
          if (/^(active|current|selected|cur|curr|checked|focus|on)$/i.test(t)) return true;
        }
        const style = n.getAttribute('style') || '';
        if (!ignoreCursor && /cursor:\s*default/i.test(style)) return true;
        if (n.getAttribute('aria-selected') === 'true') return true;
      }
    } catch (e) {}
    return false;
  }

  // 是否位于右侧目录树（章节列表）里 —— 目录里的"07 直播/08 阅读"是章节名，不是任务点
  function inCatalogTree(el) {
    try {
      let n = el;
      for (let i = 0; i < 6 && n && n.getAttribute; i++, n = n.parentElement) {
        const cls = (n.className || '').toString();
        const id = (n.id || '').toString();
        if (/posCatalog_level|chapterCatalog|catalogTree|catalogBox/i.test(cls)) return true;
        if (/catalog/i.test(id)) return true;
      }
      const r = el.getBoundingClientRect ? el.getBoundingClientRect() : null;
      // 右侧目录区（视口右侧 38%）
      if (r && r.width > 0 && r.left > (window.innerWidth || 1000) * 0.62) return true;
    } catch (e) {}
    return false;
  }

  function isLiveStream() {
    // 检测直播任务：只认内容区的直播任务点，绝不把右侧目录里的"07 直播"章节名当成直播
    try {
      const docs = getAllDocs();
      for (const d of docs) {
        // 1. 直播播放器 / 直播专属按钮 → 当前确实在直播任务里
        try {
          if (d.querySelector('iframe[src*="live"], iframe[src*="zhibo"], [id*="livePlayer"], [class*="livePlayer"], [class*="live-player"], [class*="live_room"], .liveBox')) return true;
        } catch (e) {}
        let btns = [];
        try { btns = d.querySelectorAll('button, a, span, div'); } catch (e) {}
        for (const b of btns) {
          const t = (b.textContent || '').trim();
          if (t !== '进入直播' && t !== '观看直播' && t !== '进入直播间') continue;
          const r = b.getBoundingClientRect();
          if (r.width > 0 && r.height > 0 && !inCatalogTree(b)) return true;
        }
        // 2. 当前激活的任务点标签是"直播"（单个序号，排除右侧目录树）
        let labels = [];
        try { labels = d.querySelectorAll('.ans-attach-ct, .ans-job-ct, .ans-attach, .posCatalog_select'); } catch (e) {}
        for (const el of labels) {
          let t = '';
          try { t = (el.textContent || '').replace(/\s+/g, ''); } catch (e) {}
          if (!t || t.length > 8) continue;
          if (!/^\d?直播(视频|回放|任务)?$/.test(t)) continue;
          if (inCatalogTree(el)) continue;
          const r = el.getBoundingClientRect();
          if (r.width <= 0 || r.height <= 0) continue;
          if (isActiveTaskEl(el, true)) return true;
        }
      }
    } catch (e) {}
    return false;
  }

  // ========== 视频弹题自动作答 ==========
  let quizState = { answered: false, secondTry: false, aiTried: false };

  function isVideoQuiz() {
    // 检测视频弹题：选项+提交 或 题型标题+提交
    const docs = getAllDocs();
    let hasVideo = false;
    for (const d of docs) {
      try { if (d.body && /<video/i.test(d.body.innerHTML)) { hasVideo = true; break; } } catch (e) {}
    }
    if (!hasVideo) return false;
    const options = getQuizOptions();
    const submit = getSubmitButton();
    if (options.length > 0 && submit) return true;
    // 兜底：有"判断题/单选题/多选题"标题 + 提交按钮
    for (const d of docs) {
      try {
        if (d.body && /(判断题|单选题|多选题|填空题)/.test(d.body.innerText || '') && submit) return true;
      } catch (e) {}
    }
    return false;
  }

  function getQuizOptions() {
    // 获取弹题选项：优先通过单选圈定位，再通过容器选择器，最后文本兜底
    const docs = getAllDocs();

    for (const doc of docs) {
      const options = [];

      // 方法1：通过单选圈元素找父容器（最可靠，不依赖文本结构）
      let radioEls = [];
      try {
        radioEls = doc.querySelectorAll(
          'input[type="radio"], [class*="radio"], [class*="Radio"], ' +
          '[class*="circle"], [class*="dot"], [class*="point"], [class*="ball"], [class*="round"]'
        );
      } catch (e) {}
      for (const radio of radioEls) {
        let parent = radio.parentElement;
        let depth = 0;
        while (parent && parent !== doc.body && depth < 5) {
          const pt = (parent.textContent || '').trim();
          // 选项容器文字较短，且包含选项标识
          if (pt.length < 40 && (/[A-D][、.．\s]/.test(pt) || /^(对|错)/.test(pt) || /^[A-D]\s*$/.test(pt))) {
            if (options.indexOf(parent) === -1) options.push(parent);
            break;
          }
          parent = parent.parentElement;
          depth++;
        }
      }
      if (options.length >= 2) return options;

      // 方法1.5：学习通标准选项容器（.stem_answer 里的每个 div 就是一个选项）
      const stdSelectors = ['.stem_answer > div', '.stem_answer div[class*="option"]', '.answer_p'];
      for (const sel of stdSelectors) {
        let els;
        try { els = doc.querySelectorAll(sel); } catch (e) { continue; }
        if (els.length >= 2 && els.length <= 12) return Array.from(els);
      }

      // 方法2：弹题容器选择器（找到至少2个才算有效选项组）
      const selectors = [
        '.ans-cc li', '.ans-cc .option', '.quiz .option',
        '[class*="option"]', '[class*="answer-item"]',
        'li[data-value]', '.question li',
        '.ans-options li', '[class*="ans-option"]', '[class*="answerOption"]'
      ];
      for (const sel of selectors) {
        let els;
        try { els = doc.querySelectorAll(sel); } catch (e) { continue; }
        if (els.length >= 2) return Array.from(els);
      }

      // 方法3：找到题型标题，在其附近容器里找选项
      try {
        const titleEls = doc.querySelectorAll('div, span, p');
        for (const te of titleEls) {
          const tt = (te.textContent || '').trim();
          if (/^(判断题|单选题|多选题|填空题)$/.test(tt)) {
            // 向上找弹题容器
            let container = te.parentElement;
            for (let i = 0; i < 6 && container; i++) {
              const lis = container.querySelectorAll('li, [class*="option"], [class*="answer"]');
              if (lis.length >= 2) return Array.from(lis);
              container = container.parentElement;
            }
          }
        }
      } catch (e) {}

      // 方法4：文本兜底
      let all;
      try { all = doc.querySelectorAll('div, span, li, label, a'); } catch (e) { continue; }
      const textOpts = [];
      for (const el of all) {
        const t = (el.textContent || '').trim();
        if ((/^[A-D][、.．\s]?/.test(t) || /^(对|错|正确|错误)/.test(t)) && t.length < 30) {
          const r = el.getBoundingClientRect();
          if (r.width > 0 && r.height > 0) textOpts.push(el);
        }
      }
      if (textOpts.length >= 2) return textOpts;
    }
    return [];
  }

  // 在选项容器内找到左侧的"白色单选圈"（实际点击目标）
  function getRadioEl(optionEl) {
    if (!optionEl) return null;
    // 1) 原生 radio input
    const radio = optionEl.querySelector('input[type="radio"]');
    if (radio) return radio;
    // 2) 带 radio/circle/dot/icon/check 类名的子元素
    const candidates = optionEl.querySelectorAll('span, div, i, label, em');
    for (const c of candidates) {
      const cls = (c.className || '').toString();
      if (/radio|circle|dot|icon|check|point|ball|round/.test(cls)) {
        const r = c.getBoundingClientRect();
        if (r.width > 0 && r.height > 0) return c;
      }
    }
    // 3) 容器的第一个子元素（圈通常在最左边，尺寸较小）
    const first = optionEl.firstElementChild;
    if (first) {
      const r = first.getBoundingClientRect();
      if (r.width > 0 && r.height > 0 && r.width < 50 && r.height < 50) return first;
    }
    // 4) 兜底：返回容器本身
    return optionEl;
  }

  // 判断某个选项是否已被选中（出现蓝点）
  function isOptionSelected(optionEl) {
    if (!optionEl) return false;
    // 原生 radio.checked
    const radio = optionEl.querySelector('input[type="radio"]');
    if (radio && radio.checked) return true;
    // aria-checked
    if (optionEl.getAttribute('aria-checked') === 'true') return true;
    if (optionEl.querySelector('[aria-checked="true"]')) return true;
    // class 标记 active/selected/checked/on
    const cls = (optionEl.className || '').toString();
    if (/\b(active|selected|checked|on)\b/.test(cls)) return true;
    if (optionEl.querySelector('[class*="active"], [class*="selected"], [class*="checked"], [class*="on"]')) return true;
    return false;
  }

  function getSubmitButton() {
    const docs = getAllDocs();
    // 学习通标准提交/保存按钮（最可靠）
    for (const doc of docs) {
      try {
        const b = doc.querySelector('.btnSubmit, .btnSave, .ZY_sub .btnSubmit, .ZY_sub .btnSave, input[value="提交"], input[value="保存"]');
        if (b) {
          const r = b.getBoundingClientRect();
          if (r.width > 0 && r.height > 0) return b;
        }
      } catch (e) {}
    }
    for (const doc of docs) {
      let btns;
      try { btns = doc.querySelectorAll('button, a, span, div'); } catch (e) { continue; }
      for (const b of btns) {
        const t = (b.textContent || '').trim();
        if (t === '提交' || t === '确定' || t === '下一题' ||
            /^(提交|确定|下一题)($|\s)/.test(t)) {
          const r = b.getBoundingClientRect();
          if (r.width > 0 && r.height > 0) return b;
        }
      }
    }
    return null;
  }

  function getContinueButton() {
    // 查找"继续学习"或类似按钮（遍历所有 iframe）
    const docs = getAllDocs();
    for (const doc of docs) {
      let btns;
      try { btns = doc.querySelectorAll('button, a, span, div'); } catch (e) { continue; }
      for (const b of btns) {
        const t = (b.textContent || '').trim();
        if (t === '继续学习' || t === '继续' || t === '继续观看' || t === '下一题' || t === '知道了' || t === '关闭') {
          const r = b.getBoundingClientRect();
          if (r.width > 0 && r.height > 0) return b;
        }
      }
    }
    return null;
  }

  function isQuizCorrect() {
    // 检测答题是否正确（遍历所有 iframe）
    const docs = getAllDocs();
    let text = '', html = '';
    for (const d of docs) {
      try {
        if (d.body) {
          text += d.body.innerText || '';
          html += d.body.innerHTML || '';
        }
      } catch (e) {}
    }
    // 正确的标志
    if (/回答正确|答对了|已答对|正确|✓|✔/.test(text)) return true;
    // 错误的标志
    if (/回答错误|答错了|错误|✗|✘/.test(text)) return false;
    // 检查选项的样式
    for (const d of docs) {
      try {
        const correctEl = d.querySelector('.correct, .right, .true, [class*="correct"], [class*="right"]');
        if (correctEl) return true;
        const wrongEl = d.querySelector('.wrong, .error, .false, [class*="wrong"], [class*="error"]');
        if (wrongEl) return false;
      } catch (e) {}
    }
    return null; // 未知
  }

  // 关闭弹题弹窗：尝试多种方式
  async function closeQuizPopup() {
    const docs = getAllDocs();

    // 1) "继续学习"/"继续"/"知道了"/"关闭"/"下一题" 按钮
    const continueBtn = getContinueButton();
    if (continueBtn) {
      try { continueBtn.click(); await new Promise(r => setTimeout(r, 600)); } catch (e) {}
    }
    // 2) 再次点击"提交"（答对后提交按钮可能变成确认/继续按钮）
    const submit = getSubmitButton();
    if (submit) {
      try { submit.click(); await new Promise(r => setTimeout(r, 600)); } catch (e) {}
    }
    // 3) 找关闭图标 × 或带"关闭"文字的元素
    for (const doc of docs) {
      try {
        const closes = doc.querySelectorAll('[class*="close"], [class*="Close"], [aria-label*="关闭"], [title*="关闭"]');
        for (const c of closes) {
          const r = c.getBoundingClientRect();
          if (r.width > 0 && r.height > 0) {
            c.click();
            await new Promise(r2 => setTimeout(r2, 400));
            break;
          }
        }
      } catch (e) {}
    }
    // 4) 点击弹窗外的遮罩层
    for (const doc of docs) {
      try {
        const masks = doc.querySelectorAll('[class*="mask"], [class*="overlay"], [class*="backdrop"], [class*="Modal"], [class*="modal"]');
        for (const m of masks) {
          const r = m.getBoundingClientRect();
          if (r.width > 0 && r.height > 0) {
            m.click();
            await new Promise(r2 => setTimeout(r2, 400));
            break;
          }
        }
      } catch (e) {}
    }
    // 5) 按 Esc 键
    try {
      document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
      await new Promise(r => setTimeout(r, 300));
    } catch (e) {}
  }

  // ========== AI 搜题 ==========
  function getQuizQuestion() {
    // 提取题目文字：在选项上方找题目文本
    const docs = getAllDocs();
    const stemSelectors = ['.subject_describe', '.Zy_TItle', '.mark_name', '.TiMu .subject_describe', '.stem_txt'];
    for (const doc of docs) {
      for (const sel of stemSelectors) {
        let els;
        try { els = doc.querySelectorAll(sel); } catch (e) { continue; }
        for (const q of els) {
          const t = (q.textContent || '').trim();
          if (t.length > 5 && t.length < 500) return t.replace(/\s+/g, ' ').slice(0, 200);
        }
      }
    }
    for (const doc of docs) {
      try {
        // 常见题目容器
        const qs = doc.querySelectorAll('.question, [class*="question"], [class*="title"], .ans-cc-content > div, .quiz-content');
        for (const q of qs) {
          const t = (q.textContent || '').trim();
          if (t.length > 5 && t.length < 500 && !/^[A-D][、.．]/.test(t)) {
            return t.replace(/\s+/g, ' ').slice(0, 200);
          }
        }
        // 兜底：在判断题/单选题等标题后面找文本
        const all = doc.querySelectorAll('div, p, span');
        for (const el of all) {
          const t = (el.textContent || '').trim();
          if (t.length > 10 && t.length < 300 &&
              !/^(判断题|单选题|多选题|共\d题)/.test(t) &&
              !/^[A-D][、.．]/.test(t) &&
              !/^(对|错)$/.test(t)) {
            // 确保不包含选项文字
            const hasOption = /A[、.．].*B[、.．]/.test(t);
            if (!hasOption) return t.replace(/\s+/g, ' ').slice(0, 200);
          }
        }
      } catch (e) {}
    }
    return '';
  }

  // 抓取搜索页并转为纯文本，失败返回空串
  function fetchSearchText(url) {
    return new Promise((resolve) => {
      try {
        GM_xmlhttpRequest({
          method: 'GET',
          url: url,
          timeout: 12000,
          headers: {
            'Accept': 'text/html,application/xhtml+xml',
            'Accept-Language': 'zh-CN,zh;q=0.9',
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36'
          },
          onload: (resp) => {
            const html = resp.responseText || '';
            const text = html.replace(/<script[\s\S]*?<\/script>/gi, ' ')
                             .replace(/<style[\s\S]*?<\/style>/gi, ' ')
                             .replace(/<[^>]+>/g, ' ')
                             .replace(/\s+/g, ' ');
            resolve(text);
          },
          onerror: () => resolve(''),
          ontimeout: () => resolve('')
        });
      } catch (e) { resolve(''); }
    });
  }

  // 统计关键词在文本中出现的次数
  function countKeyword(text, kw) {
    if (!kw) return 0;
    try {
      const regex = new RegExp(kw.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi');
      return (text.match(regex) || []).length;
    } catch (e) { return 0; }
  }

  // 调用 DeepSeek API 直接答题，返回选项索引；失败返回 -1
  // 调用 DeepSeek 答题
  // isMulti=true 时返回多个答案索引数组；false 时返回单个索引（数组形式 [idx]）
  function askDeepSeek(question, optionTexts, isMulti) {
    return new Promise((resolve) => {
      let key = '';
      try { key = GM_getValue('ds_api_key', ''); } catch (e) {}
      if (!key) return resolve(isMulti ? [] : -1);

      const letters = ['A', 'B', 'C', 'D', 'E', 'F'];
      const optStr = optionTexts.map((opt, i) => {
        const letter = letters[i] || String(i + 1);
        const clean = opt.replace(/^[A-F][、.．\s]*/, '').trim();
        return `${letter}. ${clean}`;
      }).join('\n');

      const multiHint = isMulti
        ? '这是多选题，可能有多个正确答案。只返回所有正确答案的字母（如 AC、ABD），不要解释。'
        : '只返回正确答案的字母（如 A、B、C、D），不要解释，不要加句号。';

      const prompt = `你是一个答题助手。请阅读以下题目和选项，选出正确答案。
${multiHint}

题目：${question}

选项：
${optStr}`;

      try {
        GM_xmlhttpRequest({
          method: 'POST',
          url: 'https://api.deepseek.com/v1/chat/completions',
          headers: {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${key}`
          },
          data: JSON.stringify({
            model: 'deepseek-chat',
            messages: [{ role: 'user', content: prompt }],
            temperature: 0,
            max_tokens: 20
          }),
          timeout: 20000,
          onload: (resp) => {
            try {
              const data = JSON.parse(resp.responseText || '{}');
              const content = data.choices?.[0]?.message?.content || '';
              if (isMulti) {
                // 多选题：提取所有字母
                const matches = content.match(/[A-F]/g) || [];
                const indices = [...new Set(matches)].map(c => c.charCodeAt(0) - 65)
                  .filter(i => i >= 0 && i < optionTexts.length);
                return resolve(indices);
              } else {
                const m = content.match(/[A-F]/);
                if (m) {
                  const idx = m[0].charCodeAt(0) - 65;
                  if (idx >= 0 && idx < optionTexts.length) return resolve(idx);
                }
                return resolve(-1);
              }
            } catch (e) {}
            resolve(isMulti ? [] : -1);
          },
          onerror: () => resolve(isMulti ? [] : -1),
          ontimeout: () => resolve(isMulti ? [] : -1)
        });
      } catch (e) { resolve(isMulti ? [] : -1); }
    });
  }

  // ========== 本地题库（持久化保存，刷新/关浏览器/重启都不丢） ==========
  // 结构：{ [归一化题干]: { a: '答案（字母/文本）', q: '原始题干' } }
  // 答案存字母而不存选项序号，选项顺序变了也能对上；查找支持模糊匹配
  const BANK_KEY = 'cx_question_bank';
  const BANK_THRESHOLD = 0.72;
  let bankCache = null;

  // 题干规范化：去掉题号、括注、空白与标点，只保留文字和数字，便于跨页面比对
  function normalizeQuestion(q) {
    let s = String(q === null || q === undefined ? '' : q);
    s = s.replace(/【[^】]*】/g, '');
    s = s.replace(/^[\s\d]*[、.．)）:：]\s*/, '');
    s = s.replace(/[\s\u3000]+/g, '');
    s = s.replace(/[，,。.、；;：:！!？?"'“”‘’（）()【】\[\]《》<>~～·\-—_|｜\\\/]/g, '');
    return s.toLowerCase();
  }

  // 取字符串的 n 元片段集合
  function shinglesOf(s, n) {
    const set = new Set();
    if (!s) return set;
    if (s.length <= n) { set.add(s); return set; }
    for (let i = 0; i + n <= s.length; i++) set.add(s.slice(i, i + n));
    return set;
  }

  // Jaccard 相似度（3 元片段），用于题干模糊匹配
  function similarityOf(a, b) {
    if (!a || !b) return 0;
    if (a === b) return 1;
    const A = shinglesOf(a, 3);
    const B = shinglesOf(b, 3);
    if (!A.size || !B.size) return 0;
    let both = 0;
    A.forEach(g => { if (B.has(g)) both++; });
    return both / (A.size + B.size - both);
  }

  // 读取题库（带缓存，首次读取时把老数据迁移成新格式）
  function getQuestionBank() {
    if (bankCache) return bankCache;
    let obj = {};
    try {
      const raw = GM_getValue(BANK_KEY, '{}');
      const parsed = JSON.parse(raw || '{}');
      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) obj = parsed;
    } catch (e) {}
    let changed = false;
    const migrated = {};
    for (const k in obj) {
      const nk = normalizeQuestion(k);
      if (!nk) continue;
      if (nk !== k) changed = true;
      if (migrated[nk] === undefined) migrated[nk] = obj[k];
    }
    bankCache = migrated;
    if (changed) saveQuestionBank(migrated);
    return bankCache;
  }

  // 保存题库
  function saveQuestionBank(bank) {
    bankCache = bank || {};
    try { GM_setValue(BANK_KEY, JSON.stringify(bankCache)); } catch (e) {}
  }

  // 选项字母：优先取「A. xxx」前缀，没有前缀按顺序 A/B/C
  function optionLetterAt(optionTexts, i) {
    const t = String((optionTexts || [])[i] || '').trim();
    const m = t.match(/^\s*([A-F])[\s、.．:：)）]/i);
    return m ? m[1].toUpperCase() : String.fromCharCode(65 + i);
  }

  // 去掉选项前的字母前缀，只留正文
  function stripOptionLetter(t) {
    return String(t === null || t === undefined ? '' : t).replace(/^\s*[A-F][\s、.．:：)）]*/i, '').trim();
  }

  // 题库里的答案（字母 / 判断词 / 文字）→ 当前页面的选项下标数组
  function answerTextToIndexes(answer, optionTexts) {
    const opts = optionTexts || [];
    if (!opts.length) return [];
    const ans = String(answer === null || answer === undefined ? '' : answer).trim();
    if (!ans) return [];

    const YES = /^(正确|对|√|是|true|yes|t|y)$/i;
    const NO = /^(错误|错|×|否|false|no|f|n)$/i;
    if (YES.test(ans) || NO.test(ans)) {
      const wantYes = YES.test(ans);
      for (let i = 0; i < opts.length; i++) {
        const t = String(opts[i]);
        if (wantYes ? /正确|对|√|是/.test(t) : /错误|错|×|否/.test(t)) return [i];
      }
      if (wantYes) return [0];
      return opts.length > 1 ? [1] : [];
    }

    if (/^[A-Fa-f\s,，、]+$/.test(ans)) {
      const idxs = [];
      const letters = ans.match(/[A-Fa-f]/g) || [];
      for (const raw of letters) {
        const L = raw.toUpperCase();
        let pos = -1;
        for (let i = 0; i < opts.length; i++) {
          if (optionLetterAt(opts, i) === L) { pos = i; break; }
        }
        if (pos < 0) pos = L.charCodeAt(0) - 65;
        if (pos >= 0 && pos < opts.length && idxs.indexOf(pos) < 0) idxs.push(pos);
      }
      return idxs.sort((x, y) => x - y);
    }

    const want = normalizeQuestion(ans);
    const hits = [];
    for (let i = 0; i < opts.length; i++) {
      const cur = normalizeQuestion(stripOptionLetter(opts[i]));
      if (!cur || !want) continue;
      if (cur === want || cur.indexOf(want) >= 0 || want.indexOf(cur) >= 0) hits.push(i);
    }
    return hits;
  }

  // 查题库：先精确命中；未命中则按相似度找最接近的一条
  function findBankRecord(question) {
    const key = normalizeQuestion(question);
    if (!key) return null;
    const bank = getQuestionBank();
    if (Object.prototype.hasOwnProperty.call(bank, key)) return { key, val: bank[key], score: 1 };

    let pickKey = '';
    let pickScore = 0;
    const keys = Object.keys(bank);
    for (let i = 0; i < keys.length; i++) {
      const cand = keys[i];
      if (cand.length < 6) continue;
      let sc = similarityOf(cand, key);
      if (key.indexOf(cand) >= 0 || cand.indexOf(key) >= 0) {
        // 包含关系：短题干至少要占长题干的 60%，避免短句误命中长题
        const r = Math.min(cand.length, key.length) / Math.max(cand.length, key.length);
        sc = Math.max(sc, r < 0.6 ? 0.3 * r : 0.85 + 0.15 * r);
      }
      if (sc > pickScore) { pickScore = sc; pickKey = cand; }
    }
    if (!pickKey || pickScore < BANK_THRESHOLD) return null;
    return { key: pickKey, val: bank[pickKey], score: pickScore };
  }

  // 单个选项正文的相似度
  function optionMatchScore(a, b) {
    if (!a || !b) return 0;
    if (a === b) return 1;
    if (a.indexOf(b) >= 0 || b.indexOf(a) >= 0) {
      return Math.min(a.length, b.length) / Math.max(a.length, b.length);
    }
    return similarityOf(a, b);
  }

  // 按选项正文还原答案下标：全部对上才返回，否则空数组
  function matchIndexesByText(storedTexts, optionTexts) {
    const options = (optionTexts || []).map(t => normalizeQuestion(stripOptionLetter(t)));
    const picked = new Set();
    const result = [];
    for (let s = 0; s < storedTexts.length; s++) {
      const want = normalizeQuestion(storedTexts[s]);
      if (!want) return [];
      let idx = -1;
      let best = 0.6;
      for (let i = 0; i < options.length; i++) {
        if (picked.has(i)) continue;
        const sc = optionMatchScore(options[i], want);
        if (sc > best) { best = sc; idx = i; }
      }
      if (idx < 0) return [];
      picked.add(idx);
      result.push(idx);
    }
    return result.sort((x, y) => x - y);
  }

  // 查题库：返回 { idxs: [选项下标…], score, legacy, answerText }
  function findInBank(question, optionTexts) {
    const rec = findBankRecord(question);
    if (!rec) return { idxs: [], score: 0 };
    const val = rec.val;
    // 优先按选项正文定位：选项顺序或字母被重排也能答对
    if (val && typeof val === 'object' && !Array.isArray(val) && Array.isArray(val.t) && val.t.length) {
      const byText = matchIndexesByText(val.t, optionTexts);
      if (byText.length === val.t.length) return { idxs: byText.sort((a, b) => a - b), score: rec.score, byText: true };
    }
    let a = val;
    if (val && typeof val === 'object' && !Array.isArray(val) && 'a' in val) a = val.a;
    // 兼容老版本存的选项序号
    if (typeof a === 'number') return { idxs: a >= 0 ? [a] : [], score: rec.score, legacy: true };
    if (Array.isArray(a)) return { idxs: a.filter(n => typeof n === 'number' && n >= 0), score: rec.score, legacy: true };
    return { idxs: answerTextToIndexes(a, optionTexts), score: rec.score, answerText: String(a) };
  }

  // 加入题库：answer 为选项下标（数字或数组），统一转成字母 + 选项正文保存
  function addToBank(question, answer, optionTexts) {
    const key = normalizeQuestion(question);
    if (!key || !optionTexts || !optionTexts.length) return;
    const list = Array.isArray(answer) ? answer : [answer];
    const idxs = [];
    for (const v of list) {
      if (typeof v !== 'number' || v < 0 || v >= optionTexts.length) continue;
      if (idxs.indexOf(v) < 0) idxs.push(v);
    }
    if (!idxs.length) return;
    idxs.sort((x, y) => x - y);

    const letters = idxs.map(i => optionLetterAt(optionTexts, i)).join('');
    if (!letters) return;
    const texts = idxs.map(i => stripOptionLetter(optionTexts[i]));

    const bank = getQuestionBank();
    const prev = bank[key];
    const prevOk = prev && typeof prev === 'object' && !Array.isArray(prev);
    if (prevOk && prev.a === letters && JSON.stringify(prev.t || []) === JSON.stringify(texts)) return;

    bank[key] = { a: letters, t: texts, q: String(question).slice(0, 120) };
    saveQuestionBank(bank);
    try {
      if (window.__ui && window.__ui.$banksize) {
        window.__ui.$banksize.textContent = Object.keys(bank).length;
      }
    } catch (e) {}
  }

  // 题库题目总数
  function getBankSize() {
    return Object.keys(getQuestionBank()).length;
  }

  // 导入题库：支持 {题干: 答案}、{题干: {a, q}}、[{q, a}]
  function importBankJson(text) {
    let data;
    try { data = JSON.parse(String(text || '')); } catch (e) { return 0; }
    if (!data || typeof data !== 'object') return 0;
    const bank = getQuestionBank();
    let n = 0;
    const put = (q, a) => {
      const key = normalizeQuestion(q);
      if (!key || a === undefined || a === null || a === '') return;
      bank[key] = { a, q: String(q).slice(0, 120) };
      n++;
    };
    if (Array.isArray(data)) {
      data.forEach(it => {
        if (!it) return;
        const a = it.a !== undefined ? it.a : it.answer;
        put(it.q || it.question || it.stem, a);
      });
    } else {
      Object.keys(data).forEach(q => {
        const v = data[q];
        put(q, v && typeof v === 'object' && !Array.isArray(v) && 'a' in v ? v.a : v);
      });
    }
    saveQuestionBank(bank);
    try {
      if (window.__ui && window.__ui.$banksize) window.__ui.$banksize.textContent = Object.keys(bank).length;
    } catch (e) {}
    return n;
  }

  // 导出题库为 JSON 文件
  function exportBankJson() {
    const bank = getQuestionBank();
    try {
      const blob = new Blob([JSON.stringify(bank, null, 2)], { type: 'application/json' });
      const url = URL.createObjectURL(blob);
      const a = document.createElement('a');
      a.href = url;
      a.download = '超星题库.json';
      a.click();
      setTimeout(() => URL.revokeObjectURL(url), 2000);
      setStatus(`已导出题库 ${Object.keys(bank).length} 题`, 'ok');
    } catch (e) {}
  }

  // 显示题库详情弹窗
  function showBankDetail() {
    const shadow = window.__shadow;
    if (!shadow) return;
    // 关闭已存在的弹窗
    const old = shadow.querySelector('.bankmask');
    if (old) old.remove();

    const bank = getQuestionBank();
    const entries = Object.entries(bank);
    const letters = ['A', 'B', 'C', 'D', 'E', 'F'];

    const mask = document.createElement('div');
    mask.className = 'bankmask';
    let listHtml = '';
    if (entries.length === 0) {
      listHtml = '<div class="bankempty">题库为空，答过的题会自动存到这里</div>';
    } else {
      listHtml = entries.map(([q, val]) => {
        let ansText = '';
        let stem = q;
        // 新格式 {a, q}；老格式直接是选项序号
        if (val && typeof val === 'object' && !Array.isArray(val) && 'a' in val) {
          ansText = String(val.a);
          if (val.q) stem = val.q;
        } else {
          const arr = Array.isArray(val) ? val : [val];
          ansText = arr.map(i => letters[i] || String(i + 1)).join('、');
        }
        return `<div class="bankitem"><div class="bq">${stem}</div><div class="ba">答案：${ansText}</div></div>`;
      }).join('');
    }
    mask.innerHTML = `
      <div class="bankbox">
        <div class="bankhd"><b>题库（${entries.length}题）</b>
          <span class="banktools">
            <button class="bankexport">导出</button>
            <button class="bankimport">导入</button>
          </span>
          <button class="bankclose">×</button>
        </div>
        <div class="banklist">${listHtml}</div>
        <input class="bankfile" type="file" accept=".json,application/json" style="display:none">
        ${entries.length > 0 ? '<button class="bankclear">清空题库</button>' : ''}
      </div>
    `;
    shadow.appendChild(mask);

    // 关闭
    mask.querySelector('.bankclose').addEventListener('click', () => mask.remove());
    mask.addEventListener('click', (e) => { if (e.target === mask) mask.remove(); });

    // 导出题库
    const exportBtn = mask.querySelector('.bankexport');
    if (exportBtn) {
      exportBtn.addEventListener('click', () => {
        if (entries.length === 0) { setStatus('题库为空，无可导出内容'); return; }
        exportBankJson();
      });
    }

    // 导入题库
    const importBtn = mask.querySelector('.bankimport');
    const fileInput = mask.querySelector('.bankfile');
    if (importBtn && fileInput) {
      importBtn.addEventListener('click', () => fileInput.click());
      fileInput.addEventListener('change', (e) => {
        const file = e.target.files && e.target.files[0];
        if (!file) return;
        const reader = new FileReader();
        reader.onload = () => {
          const n = importBankJson(String(reader.result || ''));
          mask.remove();
          if (n > 0) setStatus(`题库导入 ${n} 题，共 ${getBankSize()} 题`, 'ok');
          else setStatus('题库导入失败：不是合法 JSON', 'err');
        };
        reader.readAsText(file, 'utf-8');
      });
    }

    // 清空题库
    const clearBtn = mask.querySelector('.bankclear');
    if (clearBtn) {
      clearBtn.addEventListener('click', () => {
        if (confirm('确定清空全部题库？此操作不可恢复。')) {
          saveQuestionBank({});
          mask.remove();
          if (window.__ui && window.__ui.$banksize) window.__ui.$banksize.textContent = '0';
          setStatus('题库已清空');
        }
      });
    }
  }

  // isMulti: 是否多选题。单选返回数字索引，多选返回索引数组
  async function aiSearchAnswer(question, optionTexts, isMulti) {
    if (!question || !optionTexts || optionTexts.length === 0) return isMulti ? [] : -1;
    try {
      const q = question.replace(/[（(].*?[）)]/g, '').replace(/\s+/g, ' ').trim().slice(0, 150);
      if (!q) return isMulti ? [] : -1;

      // 1) 先查本地题库（精确命中 + 模糊相似匹配）
      const bankHit = findInBank(q, optionTexts);
      const bankIdxs = (bankHit.idxs || []).filter(i => i >= 0 && i < optionTexts.length);
      if (bankIdxs.length) {
        const picked = isMulti ? bankIdxs : [bankIdxs[0]];
        const how = bankHit.score >= 1 ? '精确命中' : `相似 ${(bankHit.score * 100).toFixed(0)}%`;
        setStatus(`题库${how}：${picked.map(i => i + 1).join('、')}`, 'ok');
        return isMulti ? picked : picked[0];
      }

      setStatus('AI搜题中…');

      // 读取用户选择的搜题模式
      let aiMode = 'key';
      try { aiMode = GM_getValue('ai_mode', 'key') || 'key'; } catch (e) {}

      // 2) Key 模式：用 DeepSeek 直接答题；没填 Key 或调用失败时自动改用搜索引擎
      if (aiMode === 'key') {
        let hasKey = false;
        try { hasKey = !!GM_getValue('ds_api_key', ''); } catch (e) {}
        if (!hasKey) {
          setStatus('未填 Key，改用搜索引擎搜答案…', 'warn');
        } else {
          const dsResult = await askDeepSeek(question, optionTexts, isMulti);
          if (isMulti) {
            if (dsResult.length > 0) {
              addToBank(q, dsResult, optionTexts);
              setStatus(`AI：DeepSeek 选择 ${dsResult.map(i => i + 1).join('、')}`, 'ok');
              return dsResult;
            }
          } else if (dsResult >= 0) {
            addToBank(q, dsResult, optionTexts);
            setStatus(`AI：DeepSeek 选择第${dsResult + 1}个选项`, 'ok');
            return dsResult;
          }
          setStatus('DeepSeek 不可用，改用搜索引擎…', 'warn');
        }
      }

      // 3) 搜索引擎模式：并行请求 Bing 和 百度
      const bingUrl = `https://www.bing.com/search?q=${encodeURIComponent(q)}`;
      const baiduUrl = `https://www.baidu.com/s?wd=${encodeURIComponent(q)}`;
      const [bingText, baiduRaw] = await Promise.all([
        fetchSearchText(bingUrl),
        fetchSearchText(baiduUrl)
      ]);

      let baiduText = baiduRaw;
      if (/百度安全验证|安全验证|验证码|verify/i.test(baiduText) || baiduText.length < 300) {
        baiduText = '';
      }
      const text = (bingText + ' ' + baiduText).trim();
      if (!text) { setStatus('搜索引擎无结果（可能被拦截）', 'err'); return isMulti ? [] : -1; }

      // 判断题
      const isTrueFalse = optionTexts.length === 2 &&
        /^(对|正确|√|是|true)/i.test(stripOptionLetter(optionTexts[0] || '')) &&
        /^(错|错误|×|否|false)/i.test(stripOptionLetter(optionTexts[1] || ''));
      if (isTrueFalse) {
        const posCount = (text.match(/正确|是对的|没错|对的|√|✔/gi) || []).length;
        const negCount = (text.match(/错误|不对|错的|×|✘|不是/i) || []).length;
        if (posCount > negCount) { addToBank(q, 0, optionTexts); setStatus('AI：搜索引擎判断为「对」', 'ok'); return isMulti ? [0] : 0; }
        if (negCount > posCount) { addToBank(q, 1, optionTexts); setStatus('AI：搜索引擎判断为「错」', 'ok'); return isMulti ? [1] : 1; }
        setStatus('搜索引擎无法判断对错', 'warn');
        return isMulti ? [] : -1;
      }

      // 选择题：统计每个选项关键词出现次数
      const scores = optionTexts.map(opt => {
        let kw = stripOptionLetter(opt);
        if (!kw) return 0;
        let shortKw = kw.length > 12 ? kw.slice(0, 12) : kw;
        const shortScore = countKeyword(text, shortKw);
        const fullScore = shortKw !== kw ? countKeyword(text, kw) : 0;
        return shortScore * 2 + fullScore;
      });

      if (isMulti) {
        // 多选题：取得分大于0且排名前一半的选项
        const sorted = scores.map((s, i) => ({ s, i })).filter(x => x.s > 0).sort((a, b) => b.s - a.s);
        const pickCount = Math.max(2, Math.min(sorted.length, Math.ceil(optionTexts.length / 2)));
        const picked = sorted.slice(0, pickCount).map(x => x.i);
        if (picked.length > 0) {
          addToBank(q, picked, optionTexts);
          setStatus(`AI：选择 ${picked.map(i => i + 1).join('、')}`, 'ok');
          return picked;
        }
        return [];
      } else {
        const maxScore = Math.max(...scores);
        if (maxScore > 0) {
          const idx = scores.indexOf(maxScore);
          addToBank(q, idx, optionTexts);
          setStatus(`AI：搜索引擎选择第${idx + 1}个选项`, 'ok');
          return idx;
        }
        setStatus('搜索引擎没有匹配到选项', 'warn');
      }
    } catch (e) {}
    return isMulti ? [] : -1;
  }

  async function answerVideoQuiz() {
    const options = getQuizOptions();
    if (options.length === 0) return 'no-options';

    // 如果已经答对了（显示"已答对"），直接关闭弹窗
    if (isQuizCorrect() === true) {
      setStatus('弹题：已答对，关闭弹窗', 'ok');
      await closeQuizPopup();
      quizState = { answered: false, secondTry: false, aiTried: false };
      return 'correct';
    }

    // 确定要选的答案
    let targetIdx = quizState.secondTry ? 1 : 0;

    // AI 搜题（仅第一次尝试时调用）
    const aiEnabled = document.querySelector('.ai')?.checked;
    if (aiEnabled && !quizState.aiTried) {
      quizState.aiTried = true;
      const question = getQuizQuestion();
      const optionTexts = options.map(o => (o.textContent || '').trim());
      const aiIdx = await aiSearchAnswer(question, optionTexts);
      if (aiIdx >= 0 && aiIdx < options.length) {
        targetIdx = aiIdx;
        setStatus(`弹题：AI选择第${aiIdx + 1}个选项`);
      } else {
        setStatus('弹题：AI搜题失败，选A/对');
      }
    } else if (quizState.secondTry) {
      setStatus('弹题：第二次尝试（选另一个）');
    } else if (!aiEnabled) {
      setStatus('弹题：作答中（选A/对）');
    }

    const target = options[targetIdx];
    if (!target) return 'no-target';

    // 找到选项左侧的"白色单选圈"
    const radio = getRadioEl(target);

    // 点击白色圈，等待蓝点出现（最多重试3次）
    let selected = false;
    for (let i = 0; i < 3 && !selected; i++) {
      try { radio.click(); } catch (e) { try { target.click(); } catch (e2) {} }
      await new Promise(r => setTimeout(r, 400));
      selected = isOptionSelected(target);
    }
    if (!selected) {
      try { target.click(); } catch (e) {}
      await new Promise(r => setTimeout(r, 400));
    }

    // 点击提交
    const submit = getSubmitButton();
    if (submit) {
      submit.click();
      await new Promise(r => setTimeout(r, 1200));
    } else {
      setStatus('弹题：未找到提交按钮', 'warn');
    }

    // 判断结果
    const correct = isQuizCorrect();
    const submitStillThere = !!getSubmitButton();
    const answeredCorrect = correct === true || !submitStillThere;

    if (answeredCorrect) {
      setStatus('弹题：回答正确，关闭弹窗', 'ok');
      await closeQuizPopup();
      quizState = { answered: false, secondTry: false, aiTried: false };
      return 'correct';
    }

    // 答错了：弹题还在
    if (!quizState.secondTry) {
      quizState.secondTry = true;
      // 选另一个选项（AI选错了就换另一个）
      targetIdx = targetIdx === 0 ? 1 : 0;
      setStatus('弹题：答错了，尝试另一个选项', 'warn');
      await new Promise(r => setTimeout(r, 500));
      return answerVideoQuiz();
    } else {
      setStatus('弹题：两次尝试均错，关闭弹窗', 'warn');
      await closeQuizPopup();
      quizState = { answered: false, secondTry: false, aiTried: false };
      return 'wrong';
    }
  }

  // 判断一个容器内是否包含多个子题目（避免把外层容器当成单题）
  function hasMultipleSubQuestions(block) {
    try {
      const subs = block.querySelectorAll('.questionLi, .question-item, [class*="questionLi"]');
      if (subs.length > 1) return true;
      // 统计以数字+点开头的题目标题数量
      const titles = block.querySelectorAll('.question-title, [class*="title"], .stem');
      let count = 0;
      for (const t of titles) {
        const txt = (t.textContent || '').trim();
        if (/^\d+[\.、]/.test(txt) || /^(判断题|单选题|多选题)/.test(txt)) count++;
      }
      return count > 1;
    } catch (e) { return false; }
  }

  // 在题目容器内提取单个题目的题干文字
  function extractQuestionText(block) {
    try {
      // 优先找题目标题元素
      const qEl = block.querySelector('.subject_describe, .Zy_TItle, .stem_txt, .question-title, [class*="title"], .stem, .questionStem');
      if (qEl) {
        const t = (qEl.textContent || '').trim();
        if (t.length > 3 && t.length < 500) return t.replace(/\s+/g, ' ').slice(0, 200);
      }
      // 兜底：找 block 内第一个非选项的文本段
      const all = block.querySelectorAll('div, p, span');
      for (const el of all) {
        const t = (el.textContent || '').trim();
        if (t.length > 5 && t.length < 300 &&
            !/^[A-D][、.．]/.test(t) &&
            !/^(对|错|正确|错误)$/.test(t) &&
            !/A[、.．].*B[、.．]/.test(t)) {
          // 确保这个元素不包含选项（避免把整个题目+选项当题干）
          const childOpts = el.querySelectorAll('li, [class*="option"]');
          if (childOpts.length === 0) return t.replace(/\s+/g, ' ').slice(0, 200);
        }
      }
    } catch (e) {}
    return '';
  }

  // 在题目容器内按 DOM 顺序提取选项
  function extractOptions(block) {
    const options = [];
    try {
      // 学习通标准结构：.stem_answer 下每个 div 是一个选项
      const stdEls = block.querySelectorAll('.stem_answer > div, .stem_answer div[class*="option"]');
      for (const el of stdEls) {
        const t = (el.textContent || '').trim();
        if (t && t.length < 300) options.push(el);
      }
      if (options.length >= 2) return options;
      const optEls = block.querySelectorAll('li, [class*="option"], [class*="answer-item"], label');
      for (const el of optEls) {
        let contained = false;
        for (const other of optEls) {
          if (other !== el && other.contains(el)) { contained = true; break; }
        }
        if (contained) continue;
        const t = (el.textContent || '').trim();
        if (/^[A-D][、.．\s]/.test(t) || /^(对|错|正确|错误)/.test(t)) {
          options.push(el);
        }
      }
    } catch (e) {}
    return options;
  }

  // 检测题型：返回 'single' / 'multi' / 'judge'
  function detectQuestionType(block) {
    try {
      const cls = (block.className || '').toString();
      if (/mulQues|multi|multiple|多选/i.test(cls)) return 'multi';
      if (/singleQues|single/i.test(cls)) return 'single';
      if (/judgeQues|judge|truefalse|判断/i.test(cls)) return 'judge';
      // 看题型文字
      const titleText = block.innerText || '';
      if (/多选题/.test(titleText)) return 'multi';
      if (/单选题/.test(titleText)) return 'single';
      if (/判断题/.test(titleText)) return 'judge';
      // 看是否有 checkbox
      if (block.querySelector('input[type="checkbox"]')) return 'multi';
      // 看是否有多个 radio 被选中的可能（默认单选）
      return 'single';
    } catch (e) { return 'single'; }
  }

  // 可靠地点击一个选项（多次重试 + 多种方式）
  async function clickOptionReliably(optionEl) {
    if (!optionEl) return false;
    const methods = [];
    const radio = getRadioEl(optionEl);
    if (radio && radio !== optionEl) methods.push(radio);
    methods.push(optionEl);
    for (const el of methods) {
      for (let i = 0; i < 3; i++) {
        try { simulateClick(el); } catch (e) { try { el.click(); } catch (e2) {} }
        await new Promise(r => setTimeout(r, 350));
        if (isOptionSelected(optionEl)) return true;
      }
    }
    return isOptionSelected(optionEl);
  }

  // 处理提交后的确认弹窗（"确认提交？"等）
  function clickConfirmDialog() {
    // 只在弹窗容器内点"确定"，避免误点页面上的其它按钮
    const docs = getAllDocs();
    const CONTAINERS = '.popDiv, .layui-layer, .modal, .dialog, .alert, [class*="confirm"], [class*="dialog"], [class*="popup"], [class*="mask"], #popup_container';
    for (const doc of docs) {
      let containers;
      try { containers = doc.querySelectorAll(CONTAINERS); } catch (e) { continue; }
      for (const box of containers) {
        try {
          const r0 = box.getBoundingClientRect();
          if (r0.width <= 0 || r0.height <= 0) continue;
          if (!/(提交|确定|确认|提示)/.test(box.textContent || '')) continue;
          const btns = box.querySelectorAll('button, a, span, div, input[type="button"]');
          for (const b of btns) {
            const t = ((b.textContent || '') + (b.value || '')).trim();
            if (!/^(确定|确认|是|提交|好的|知道了)$/.test(t)) continue;
            const r = b.getBoundingClientRect();
            if (r.width <= 0 || r.height <= 0) continue;
            simulateClick(b);
            return true;
          }
        } catch (e) {}
      }
    }
    return false;
  }

  // ===== 学习通原生答题引擎（按学习通标准 DOM 结构作答，最可靠）=====
  const NATIVE_TYPE = { '0': 'single', '1': 'multi', '2': 'text', '4': 'text', '3': 'judge' };
  let lastQuizSubmitSig = '';
  let lastQuizSubmitTime = 0;
  let lastQuizSubmitTopHref = '';

  function topHref() {
    try { return (window.top && window.top.location && window.top.location.href) || location.href; } catch (e) { return location.href; }
  }

  function quizSigOf(doc) {
    try { return (doc.location.href || '') + '#' + doc.querySelectorAll('input[id^="answertype"]').length; } catch (e) { return ''; }
  }

  // 读取章节测验题目：题型以 input[id^="answertype"] 为准
  function collectNativeQuizQuestions(doc) {
    const list = [];
    let marks = [];
    try { marks = doc.querySelectorAll('input[id^="answertype"]'); } catch (e) { return list; }
    for (let m = 0; m < marks.length; m++) {
      const mark = marks[m];
      const qid = String(mark.id || '').slice('answertype'.length).trim();
      if (!qid) continue;

      let box = null;
      try { box = doc.querySelector('.singleQuesId[data="' + qid + '"]'); } catch (e) {}
      if (!box) { try { box = mark.closest('.TiMu') || mark.closest('.Zy_TItle') || mark.parentElement; } catch (e) {} }
      if (!box) continue;

      const type = NATIVE_TYPE[String(mark.value || '').trim()] || 'single';

      const options = [];
      let nodes = [];
      try { nodes = box.querySelectorAll('ul.Zy_ulTop li'); } catch (e) {}
      for (let i = 0; i < nodes.length; i++) {
        const node = nodes[i];
        const badge = node.querySelector('.num_option, .num_option_dx');
        let letter = badge ? String(badge.getAttribute('data') || '').toUpperCase() : '';
        if (letter.length !== 1 || letter < 'A' || letter > 'Z') letter = String.fromCharCode(65 + i);
        const body = node.querySelector('a.after') || node;
        const text = String(body.textContent || '').replace(/\s+/g, ' ').trim();
        if (text) options.push({ li: node, letter, text });
      }

      let question = '';
      try {
        const title = box.querySelector('.Zy_TItle .fontLabel') ||
                      box.querySelector('.subject_describe') ||
                      box.querySelector('.Zy_TItle');
        if (title) question = String(title.textContent || '').replace(/\s+/g, ' ').trim();
      } catch (e) {}
      question = question.replace(/^[[【(（]?\s*\d+\s*[\]】)）]?\s*[、.．]?\s*/, '').slice(0, 200);

      list.push({ qid, type, block: box, question, options });
    }
    return list;
  }

  // 填入答案：先点原生选项触发平台状态，再写隐藏域、补高亮
  function fillNativeQuizAnswer(doc, q, letters) {
    if (!q || !Array.isArray(letters) || !letters.length) return false;
    const multi = q.type === 'multi';
    const judge = q.type === 'judge';
    const value = judge
      ? (letters[0] === 'A' ? 'true' : 'false')
      : letters.slice().sort().join('');

    let field = null;
    try { field = doc.getElementById('answer' + q.qid); } catch (e) {}
    const current = field ? String(field.value || '') : '';
    if (current !== value) {
      for (let i = 0; i < letters.length; i++) {
        const target = q.options.find(o => o.letter === letters[i]);
        if (target && target.li) simulateClick(target.li);
      }
    }

    try {
      if (field) {
        field.value = value;
        field.dispatchEvent(new Event('input', { bubbles: true }));
        field.dispatchEvent(new Event('change', { bubbles: true }));
      }
      const area = q.block.querySelector('ul.Zy_ulTop');
      if (area) {
        const marks = area.querySelectorAll('.choice' + q.qid);
        for (let i = 0; i < marks.length; i++) {
          marks[i].classList.remove('check_answer', 'check_answer_dx');
        }
        for (let i = 0; i < letters.length; i++) {
          const raw = judge ? (letters[i] === 'A' ? 'true' : 'false') : letters[i];
          let mark = null;
          try { mark = area.querySelector(".choice" + q.qid + "[data='" + raw + "']"); } catch (e) {}
          if (!mark) { try { mark = area.querySelector(".choice" + q.qid + "[data='" + letters[i] + "']"); } catch (e) {} }
          if (!mark) continue;
          mark.classList.add(multi ? 'check_answer_dx' : 'check_answer');
          const row = mark.closest('li');
          if (row) {
            row.setAttribute('aria-checked', 'true');
            row.setAttribute('aria-pressed', 'true');
          }
        }
      }
    } catch (e) {}
    return true;
  }

  // 提交：优先调用学习通官方提交函数
  async function submitNativeQuiz(doc) {
    const win = doc.defaultView || window;
    try {
      if (typeof win.btnBlueSubmit === 'function') {
        win.btnBlueSubmit();
        await new Promise(r => setTimeout(r, 900));
        try { if (typeof win.submitCheckTimes === 'function') win.submitCheckTimes(); } catch (e) {}
        return true;
      }
      if (typeof win.submitWork === 'function') {
        win.submitWork();
        return true;
      }
    } catch (e) {}
    const btn = doc.querySelector('.btnSubmit, .btnSave, input[value="提交"]') || getSubmitButton();
    if (btn) { simulateClick(btn); return true; }
    return false;
  }

  // 等待提交完成（任务点完成 / 提交成功提示 / 页面跳转）
  async function waitNativeQuizDone(doc, ms) {
    const end = Date.now() + (ms || 8000);
    let startUrl = '';
    try { startUrl = doc.location.href; } catch (e) {}
    while (Date.now() < end) {
      try {
        for (const d of getAllDocs()) {
          if (d.querySelector('.ans-job-finished')) return true;
          const t = (d.body && d.body.innerText) || '';
          if (/提交成功|已提交/.test(t)) return true;
        }
      } catch (e) {}
      try { if (doc.location.href !== startUrl) return true; } catch (e) {}
      await new Promise(r => setTimeout(r, 300));
    }
    return false;
  }

  // 原生引擎答题（章节测验）
  async function answerChapterQuizNative(doc) {
    try {
      const qs = collectNativeQuizQuestions(doc);
      if (!qs.length) return 'no-questions';
      setStatus(`章节测验：发现 ${qs.length} 题`);
      let done = 0;
      for (const q of qs) {
        try {
          if (q.type === 'text') continue; // 填空/简答暂不自动填写
          if (q.options.length < 2) continue;
          const optionTexts = q.options.map(o => o.text);
          const isMulti = q.type === 'multi';
          let letters = [];
          if (isMulti) {
            const res = await aiSearchAnswer(q.question, optionTexts, true);
            letters = (Array.isArray(res) ? res : []).map(i => String.fromCharCode(65 + i));
          } else {
            const res = await aiSearchAnswer(q.question, optionTexts, false);
            if (typeof res === 'number' && res >= 0) letters = [String.fromCharCode(65 + res)];
          }
          if (!letters.length) letters = isMulti ? ['A', 'B'] : ['A'];
          fillNativeQuizAnswer(doc, q, letters);
          done++;
          setStatus(`章节测验：已答 ${done}/${qs.length} 题`);
          await new Promise(r => setTimeout(r, 700));
        } catch (e) {}
      }
      if (!done) return 'no-questions';

      setStatus(`章节测验：答完 ${done} 题，提交中…`);
      const ok = await submitNativeQuiz(doc);
      if (!ok) return 'done';
      await new Promise(r => setTimeout(r, 900));
      for (let i = 0; i < 4; i++) {
        if (clickConfirmDialog()) break;
        await new Promise(r => setTimeout(r, 500));
      }
      const finished = await waitNativeQuizDone(doc, 8000);
      lastQuizSubmitSig = quizSigOf(doc);
      lastQuizSubmitTime = Date.now();
      lastQuizSubmitTopHref = topHref();
      setStatus(finished ? '章节测验已提交' : '章节测验已提交（未确认完成）', finished ? 'ok' : '');
      return 'submitted';
    } catch (e) {
      return 'error';
    }
  }

  async function answerChapterQuiz() {
    // 有学习通标准题型标记时，走原生引擎；否则回退通用逻辑
    try {
      for (const d of getAllDocs()) {
        try {
          if (d.querySelector('input[id^="answertype"]')) {
            // 同一份测验已经提交过，不再重复答题
            if (lastQuizSubmitSig && quizSigOf(d) === lastQuizSubmitSig) return 'submitted';
            return await answerChapterQuizNative(d);
          }
        } catch (e) {}
      }
    } catch (e) {}
    return await answerChapterQuizLegacy();
  }

  async function answerChapterQuizLegacy() {
    // 章节测验 AI 答题：识别题型→搜答案→选对应选项→核对→提交，支持单选/多选/判断
    try {
      const docs = getAllDocs();
      let answeredCount = 0;
      const processedBlocks = new WeakSet();
      // 记录每道题的答案，提交前核对用
      const answerRecords = [];

      for (const doc of docs) {
        let questionBlocks = [];
        try {
          const primary = doc.querySelectorAll('.questionLi, .question-item, .singleQues, .mulQues, .judgeQues, .singleQuesId, .mulQuesId, .judgeQuesId, .TiMu');
          if (primary.length > 0) {
            questionBlocks = Array.from(primary);
          } else {
            const candidates = doc.querySelectorAll('.question, [class*="questionBox"], .ZyBottom');
            for (const c of candidates) {
              if (!hasMultipleSubQuestions(c)) questionBlocks.push(c);
            }
          }
        } catch (e) {}
        if (questionBlocks.length === 0) continue;

        for (const block of questionBlocks) {
          if (processedBlocks.has(block)) continue;
          processedBlocks.add(block);

          try {
            if (hasMultipleSubQuestions(block)) continue;

            const question = extractQuestionText(block);
            if (!question || question.length < 5) continue;

            const options = extractOptions(block);
            if (options.length < 2) continue;

            const qType = detectQuestionType(block);
            const isMulti = qType === 'multi';
            const optionTexts = options.map(o => (o.textContent || '').trim());

            // AI 搜题
            let targetIndices = [];
            if (isMulti) {
              const result = await aiSearchAnswer(question, optionTexts, true);
              targetIndices = Array.isArray(result) ? result : [];
            } else {
              const result = await aiSearchAnswer(question, optionTexts, false);
              if (typeof result === 'number' && result >= 0) targetIndices = [result];
            }

            if (targetIndices.length === 0) {
              if (isMulti) targetIndices = [0, 1].filter(i => i < options.length);
              else targetIndices = [0];
            }

            // 逐个点击目标选项
            for (const idx of targetIndices) {
              const target = options[idx];
              if (!target) continue;
              await clickOptionReliably(target);
              await new Promise(r => setTimeout(r, 200));
            }

            // 记录这道题的答案（用于提交前核对）
            answerRecords.push({ block, options, targetIndices });

            answeredCount++;
            const typeLabel = { single: '单选', multi: '多选', judge: '判断' }[qType] || '';
            setStatus(`章节答题：${answeredCount} 题（${typeLabel}）`);
          } catch (e) {}
        }
      }

      // 提交前核对：重新检查每道题的目标选项是否被选中，没选中的重新点击
      if (answerRecords.length > 0) {
        setStatus(`核对答案：共 ${answerRecords.length} 题…`);
        let fixCount = 0;
        for (const rec of answerRecords) {
          try {
            const { options, targetIndices } = rec;
            for (const idx of targetIndices) {
              const target = options[idx];
              if (!target) continue;
              if (!isOptionSelected(target)) {
                // 没选中，重新点击
                await clickOptionReliably(target);
                fixCount++;
                await new Promise(r => setTimeout(r, 200));
              }
            }
          } catch (e) {}
        }
        if (fixCount > 0) {
          setStatus(`核对完成：修正 ${fixCount} 题`, 'ok');
        } else {
          setStatus('核对完成：全部正确', 'ok');
        }
        await new Promise(r => setTimeout(r, 500));
      }

      // 提交 + 处理确认弹窗
      if (answeredCount > 0) {
        const submit = getSubmitButton();
        if (submit) {
          setStatus(`章节答题：完成${answeredCount}题，提交`);
          simulateClick(submit);
          await new Promise(r => setTimeout(r, 1500));
          for (let i = 0; i < 3; i++) {
            const clicked = clickConfirmDialog();
            if (clicked) {
              setStatus('已确认提交', 'ok');
              await new Promise(r => setTimeout(r, 1000));
              break;
            }
            await new Promise(r => setTimeout(r, 500));
          }
          lastQuizSubmitTime = Date.now();
          lastQuizSubmitTopHref = topHref();
          return 'submitted';
        }
      }
      return answeredCount > 0 ? 'done' : 'no-questions';
    } catch (e) {
      return 'error';
    }
  }

  function getVideoTaskPoints(doc) {
    const all = doc.querySelectorAll('span,button,div,a,p');
    const points = [];
    for (const el of all) {
      const t = (el.textContent || '').trim();
      if (/^\d*\s*视频$/.test(t)) {
        const r = el.getBoundingClientRect();
        if (r.width > 0 && r.height > 0) points.push(el);
      }
    }
    return points;
  }

  let lastVideoTabSig = { text: '', ts: 0 };

  function findNextVideoTaskPoint(doc) {
    // 遍历所有 document 查找视频任务点列表
    const docs = getAllDocs();
    for (const d of docs) {
      const points = getVideoTaskPoints(d);
      if (points.length <= 1) continue;
      // 找当前选中项（学习通激活类名：posCatalog_select / active / current 等）
      let curIdx = -1;
      for (let i = 0; i < points.length; i++) {
        const p = points[i];
        const style = (p.getAttribute && p.getAttribute('style')) || '';
        if (isActiveTaskEl(p) || /cursor:\s*default/i.test(style)) {
          curIdx = i;
          break;
        }
      }
      // 识别不出当前项时，宁可不点视频标签（避免点回同一个视频导致循环），交给下一节逻辑
      if (curIdx < 0) continue;
      for (let j = curIdx + 1; j < points.length; j++) {
        const p = points[j];
        if (isTreeCompleted(p)) continue; // 已完成的不点
        const text = (p.textContent || '').trim();
        // 同一标签 60 秒内不重复点击
        if (lastVideoTabSig.text === text && Date.now() - lastVideoTabSig.ts < 60000) continue;
        lastVideoTabSig = { text, ts: Date.now() };
        return p;
      }
    }
    return null;
  }

  // 模拟真实点击（兼容 Vue/React 事件绑定 + iframe 元素）
  function simulateClick(el) {
    if (!el) return;
    try {
      const rect = el.getBoundingClientRect();
      const x = rect.left + rect.width / 2;
      const y = rect.top + rect.height / 2;
      // 用元素所在 document 的 window，兼容 iframe 内元素
      const win = (el.ownerDocument && el.ownerDocument.defaultView) || window;
      const opts = { bubbles: true, cancelable: true, view: win, clientX: x, clientY: y };
      el.dispatchEvent(new win.MouseEvent('mousedown', opts));
      el.dispatchEvent(new win.MouseEvent('mouseup', opts));
      el.dispatchEvent(new win.MouseEvent('click', opts));
    } catch (e) {
      try { el.click(); } catch (e2) {}
    }
  }

  // 确保两次"下一节"点击之间至少间隔 5 秒
  async function throttleNextClick(reason) {
    const elapsed = Date.now() - lastNextClickTime;
    const remain = NEXT_CLICK_INTERVAL - elapsed;
    if (remain > 0) {
      const seconds = Math.ceil(remain / 1000);
      setStatus(`${reason}，${seconds}秒后进入下一节…`);
      await new Promise(r => setTimeout(r, remain));
    }
  }

  // 带倒计时的状态提示（每秒刷新一次）
  async function waitStatus(prefix, suffix) {
    let remain = NEXT_CLICK_INTERVAL - (Date.now() - lastNextClickTime);
    if (remain <= 0) return;
    let left = Math.ceil(remain / 1000);
    while (left > 0) {
      setStatus(`${prefix}，${left}秒以后${suffix}`);
      await new Promise(r => setTimeout(r, 1000));
      left--;
    }
  }

  // 点"下一节"的统一入口：节流 + 点击 + 记录时间
  async function clickNextSection(reason) {
    await throttleNextClick(reason);
    const btn = findNextSectionButton(document);
    if (btn) {
      setStatus(`${reason}，进入下一节`);
      simulateClick(btn);
      lastNextClickTime = Date.now();
      return true;
    }
    return false;
  }

  // 直接跳到下一节（多级兜底）：下一节按钮 → 滚动找 → 内容区任务点 → 右侧目录
  async function skipToNext(reason) {
    if (await clickNextSection(reason)) return true;
    if (await scrollFindNext(reason)) return true;
    if (clickContentNextTask(reason)) return true;
    if (clickSidebarNext()) return true;
    return false;
  }

  function findNextSectionButton(doc) {
    // 优先在所有 document 中查找精确的"下一节"按钮
    const docs = getAllDocs();
    // 第一轮：只找 button / a / input 标签（真正的可点击按钮）
    for (const d of docs) {
      try {
        const btns = d.querySelectorAll('button, a, input[type="button"], input[type="submit"]');
        for (const b of btns) {
          const t = (b.textContent || '').trim() || (b.value || '').trim();
          // 精确匹配"下一节"/"下一页"，允许后面跟箭头/空格
          if (t === '下一节' || t === '下一节点' || t === '下一页' || /^下一[节页][\s>»>]*$/.test(t)) {
            const r = b.getBoundingClientRect();
            if (r.width > 0 && r.height > 0) return pickClickable(b);
          }
        }
      } catch (e) {}
    }
    // 第二轮：找 span/div 中精确匹配的（可能是自定义按钮）
    for (const d of docs) {
      try {
        const els = d.querySelectorAll('span, div');
        for (const b of els) {
          const t = (b.textContent || '').trim();
          if (t === '下一节' || t === '下一节点' || t === '下一页') {
            // 排除文本很长的容器
            if (t.length > 10) continue;
            const r = b.getBoundingClientRect();
            if (r.width > 0 && r.height > 0) return pickClickable(b);
          }
        }
      } catch (e) {}
    }
    return null;
  }

  // 判断元素是否"已完成"（有绿色勾/完成类名）
  function isElCompleted(el) {
    if (!el) return false;
    try {
      const cls = (el.className || '').toString();
      if (/complet|finish|done|success/i.test(cls)) return true;
      if (el.querySelector('[class*="complet"],[class*="finish"],[class*="done"],[class*="success"]')) return true;
    } catch (e) {}
    return false;
  }

  // 含祖先的完成判断（只看祖先类名，避免误判兄弟节点）
  function isTreeCompleted(el) {
    if (isElCompleted(el)) return true;
    let node = el && el.parentElement;
    for (let i = 0; i < 2 && node; i++, node = node.parentElement) {
      const cls = (node.className || '').toString();
      if (/complet|finish|done|success/i.test(cls)) return true;
    }
    return false;
  }

  // 找"章节测验"任务点标签（视频上方那一排：1 视频 / 2 章节测验）
  // 注意：标签可能在同源 iframe 内，坐标是相对 iframe 的，不能用窗口坐标过滤
  function inSidebar(el) {
    let n = el;
    for (let i = 0; i < 8 && n; i++) {
      const cls = (n.className || '').toString();
      if (/catalog|directory|catalogue|sidebar|chapterList|rightPanel/i.test(cls)) return true;
      n = n.parentElement;
    }
    return false;
  }

  // 从文本元素向上几层找真正可点击的容器（限制尺寸，避免爬到整栏容器）
  function pickClickable(el) {
    let node = el;
    let best = el;
    for (let i = 0; i < 5 && node && node !== document.body; i++) {
      let r = null;
      try { r = node.getBoundingClientRect(); } catch (e) {}
      if (!r || r.width > 360 || r.height > 100) break; // 已爬到更大的容器，停止
      best = node;
      const tag = (node.tagName || '').toLowerCase();
      const cls = (node.className || '').toString();
      const style = node.getAttribute ? (node.getAttribute('style') || '') : '';
      if (tag === 'a' || tag === 'li' || tag === 'button' ||
          /cursor:\s*pointer/i.test(style) ||
          /tab|item|task|point|prev|next/i.test(cls)) {
        return node;
      }
      node = node.parentElement;
    }
    return best;
  }

  // 在"1 视频 / 2 章节测验"这一排标签里，找紧挨着"视频"的测验标签
  function findQuizTabNearVideo() {
    for (const d of getAllDocs()) {
      let els;
      try { els = d.querySelectorAll('a, li, span, div, p'); } catch (e) { continue; }
      for (const el of els) {
        const t = (el.textContent || '').replace(/\s+/g, '');
        if (!/^\d*视频$/.test(t)) continue; // 只认"视频"/"1视频"/"1 视频"
        let r = null;
        try { r = el.getBoundingClientRect(); } catch (e) {}
        if (!r || !(r.width > 0 && r.height > 0)) continue;
        const bar = pickClickable(el).parentElement; // 整个标签栏
        if (!bar) continue;
        let kids = [];
        try { kids = bar.querySelectorAll('a, li, span, div, p'); } catch (e) { continue; }
        for (const k of kids) {
          const kt = (k.textContent || '').replace(/\s+/g, '');
          if (!kt || kt.length > 12) continue;
          if (!/测验|作业|考试/.test(kt)) continue;
          if (k.children.length > 0 && k.textContent.trim().length > 6) continue;
          let kr = null;
          try { kr = k.getBoundingClientRect(); } catch (e) {}
          if (!kr || !(kr.width > 0 && kr.height > 0 && kr.width < 320 && kr.height < 90)) continue;
          return pickClickable(k);
        }
      }
    }
    return null;
  }

  function findQuizTab() {
    // 优先：视频标签旁边的"2 章节测验"
    const near = findQuizTabNearVideo();
    if (near) return near;
    const docs = getAllDocs();
    for (const d of docs) {
      let els;
      try { els = d.querySelectorAll('li, a, span, div, p'); } catch (e) { continue; }
      for (const el of els) {
        let t = (el.textContent || '').replace(/\s+/g, '');
        if (!t || t.length > 12) continue;
        // 兼容 "2章节测验"、"章节测验(未完成)" 等写法
        if (!/测验|作业|考试/.test(t)) continue;
        // 只要最内层的文本节点，避免匹配到整块容器
        if (el.children.length > 0 && el.textContent.trim().length > 6) continue;
        let r = null;
        try { r = el.getBoundingClientRect(); } catch (e) {}
        if (!r || !(r.width > 0 && r.height > 0 && r.width < 320 && r.height < 90)) continue;
        if (inSidebar(el)) continue; // 排除右侧目录里的同名文字
        return pickClickable(el);
      }
    }
    return null;
  }

  // 切到章节测验任务点（未完成才点）
  let quizTabClickTime = 0;
  let quizTabClickHref = '';
  function clickQuizTab(reason) {
    // 页面地址变化后重置冷却
    if (quizTabClickHref !== location.href) { quizTabClickTime = 0; quizTabClickHref = location.href; }
    // 6 秒内不重复点同一个标签（点不动时每 8 秒重试一次）
    if (Date.now() - quizTabClickTime < 6000) return false;
    const tab = findQuizTab();
    if (!tab) return false;
    if (isTreeCompleted(tab)) return false; // 已完成就不再进
    quizTabClickTime = Date.now();
    setStatus(`${reason}，切换到章节测验`);
    simulateClick(tab);
    lastNextClickTime = Date.now();
    return true;
  }

  // 侧面目录：切到下一个未完成的任务点
  function clickSidebarNext() {
    const docs = getAllDocs();
    for (const d of docs) {
      let items = [];
      try {
        items = Array.from(d.querySelectorAll(
          '.posCatalog_select, .posCatalog_level li, [class*="catalog"] li, [class*="chapter"] li'
        ));
      } catch (e) { continue; }
      items = items.filter(el => {
        const r = el.getBoundingClientRect();
        return r.width > 0 && r.height > 0;
      });
      if (items.length < 2) continue;

      // 找当前选中项
      let curIdx = -1;
      for (let i = 0; i < items.length; i++) {
        const cls = (items[i].className || '').toString();
        const style = items[i].getAttribute('style') || '';
        if (/active|current|selected/i.test(cls) || /cursor:\s*default/i.test(style)) { curIdx = i; break; }
      }

      const start = curIdx >= 0 ? curIdx + 1 : 0;
      for (let i = start; i < items.length; i++) {
        const el = items[i];
        if (isElCompleted(el)) continue;
        const t = (el.textContent || '').trim();
        if (!t) continue;
        setStatus('从侧面目录进入下一节');
        simulateClick(el);
        lastNextClickTime = Date.now();
        return true;
      }
    }
    return false;
  }

  // 收集所有可滚动容器（window / iframe 文档 / 内部 overflow 容器）
  function getScrollRoots() {
    const roots = [];
    for (const d of getAllDocs()) {
      try {
        const se = d.scrollingElement || d.documentElement;
        if (se) roots.push(se);
        if (d.body) roots.push(d.body);
      } catch (e) {}
      try {
        let n = 0;
        for (const el of d.querySelectorAll('div')) {
          if (n++ > 500) break;
          if (el.scrollHeight - el.clientHeight < 40) continue;
          let oy = '';
          try { oy = d.defaultView.getComputedStyle(el).overflowY; } catch (e) {}
          if (oy === 'auto' || oy === 'scroll') roots.push(el);
        }
      } catch (e) {}
    }
    return roots;
  }

  // 往下滚动直到页面最底部，边滚边找"下一节/下一页"按钮
  async function scrollFindNext(reason) {
    const roots = getScrollRoots();
    let idleRounds = 0;
    for (let i = 0; i < 40; i++) {
      let moved = false;
      try {
        const y0 = window.scrollY;
        window.scrollBy(0, 500);
        if (window.scrollY > y0) moved = true;
      } catch (e) {}
      for (const el of roots) {
        try {
          const before = el.scrollTop;
          el.scrollTop = before + 500;
          if (el.scrollTop > before + 1) moved = true;
        } catch (e) {}
      }
      await new Promise(r => setTimeout(r, 250));
      const btn = findNextSectionButton(document);
      if (btn) {
        setStatus(`${reason}，滑到最底部，点击下一节`);
        try { btn.scrollIntoView({ block: 'center' }); } catch (e) {}
        await new Promise(r => setTimeout(r, 200));
        simulateClick(btn);
        lastNextClickTime = Date.now();
        return true;
      }
      // 连续多轮滚不动（到底了）→ 结束
      if (!moved) idleRounds++; else idleRounds = 0;
      if (idleRounds >= 3) break;
    }
    return false;
  }

  // 回到页面顶部（任务点标签栏所在位置）
  async function scrollToTop() {
    try { window.scrollTo(0, 0); } catch (e) {}
    for (const d of getAllDocs()) {
      try {
        if (d.documentElement) d.documentElement.scrollTop = 0;
        if (d.body) d.body.scrollTop = 0;
      } catch (e) {}
    }
    await new Promise(r => setTimeout(r, 400));
  }

  // 章节测验提交后：回到顶部确认任务点状态 → 跳过测验标签 → 向下滚动找下一节 → 侧面目录
  async function goNextAfterQuiz() {
    await scrollToTop();
    if (isTaskCompleted(document, null)) {
      setStatus('任务点已完成');
    }
    // 1. 同章节还有未完成任务点（比如"测验在前、视频在后"）→ 先切换过去，别直接跳走
    const tab = findUnfinishedTaskTab({ skipQuizLike: true });
    if (tab && await clickTaskTab(tab, '测验已完成')) return 'tab';
    await throttleNextClick('测验已完成');
    // 2. 回到顶部后可能直接出现"下一节"按钮
    const btn = findNextSectionButton(document);
    if (btn) {
      setStatus('测验已完成，进入下一节');
      simulateClick(btn);
      lastNextClickTime = Date.now();
      return 'next';
    }
    // 3. 不再进入测验标签，避免重复答题死循环
    fallbackCooldown = 8;
    if (await scrollFindNext('测验已完成')) return 'scroll';
    if (clickSidebarNext()) return 'sidebar';
    return false;
  }

  // ========== 同章节任务点标签（顺序无关） ==========
  // 学习通章节页顶部是"1 视频 / 2 章节测验 / 3 视频"这一排标签，
  // 数量与顺序因课程而异（可能 2 个视频 + 1 个测验，也可能没有测验）。
  let lastTaskTabSig = { text: '', ts: 0 };

  function getTaskTabGroups() {
    const groups = new Map();
    for (const d of getAllDocs()) {
      let els;
      try { els = d.querySelectorAll('span, a, li, div, p'); } catch (e) { continue; }
      for (const el of els) {
        let t = '';
        try { t = (el.textContent || '').replace(/\s+/g, ''); } catch (e) { continue; }
        if (!t || t.length > 10) continue;
        if (!/^\d*(视频|章节测验|测验|作业|考试|文档|图书|阅读|直播)$/.test(t)) continue;
        let r = null;
        try { r = el.getBoundingClientRect(); } catch (e) {}
        if (!r || r.width <= 0 || r.height <= 0 || r.width > 320 || r.height > 90) continue;
        if (inCatalogTree(el)) continue;
        const p = el.parentElement;
        if (!p) continue;
        if (!groups.has(p)) groups.set(p, []);
        const arr = groups.get(p);
        if (!arr.some(x => x.el === el)) arr.push({ el, text: t });
      }
    }
    // 只认"标签栏"：同一个父容器里至少有两个任务点标签
    return [...groups.values()].filter(v => v.length >= 2);
  }

  // 找同章节里下一个未完成的任务点标签（视频/章节测验/文档/…），按页面顺序，和顺序无关
  // opts.skipVideo：跳过视频标签（视频之间切换交给 findNextVideoTaskPoint，避免点回已看完的视频）
  // opts.skipQuizLike：跳过测验/作业/考试（刚提交过测验，避免又点回去重复答题）
  function findUnfinishedTaskTab(opts) {
    const o = opts || {};
    const samePage = !!lastQuizSubmitTopHref && lastQuizSubmitTopHref === topHref();
    const skipQuiz = !!o.skipQuizLike || (samePage && Date.now() - lastQuizSubmitTime < 10 * 60000);
    for (const chips of getTaskTabGroups()) {
      for (const c of chips) {
        if (/直播/.test(c.text)) continue;                 // 直播不进去看，直接跳
        if (o.skipVideo && /视频/.test(c.text)) continue;
        if (skipQuiz && /测验|作业|考试/.test(c.text)) continue;
        if (isActiveTaskEl(c.el, true)) continue;          // 当前所在的任务点
        if (isElCompleted(c.el)) continue;
        try {
          // 只额外看父容器的类名（不能看后代，否则标签栏里别的任务点的勾会误判）
          const pcls = (c.el.parentElement && c.el.parentElement.className || '').toString();
          if (/complet|finish|done|success/i.test(pcls)) continue;
        } catch (e) {}
        if (lastTaskTabSig.text === c.text && Date.now() - lastTaskTabSig.ts < 60000) continue;
        return c;
      }
    }
    return null;
  }

  async function clickTaskTab(tab, reason) {
    if (!tab) return false;
    await throttleNextClick(reason);
    if (!running) return false;
    lastTaskTabSig = { text: tab.text, ts: Date.now() };
    setStatus(`${reason}，切换到同章节任务点「${tab.text}」`);
    simulateClick(pickClickable(tab.el));
    lastNextClickTime = Date.now();
    return true;
  }

  // 视频任务点完成后的跳转：滑到页面最底部点"下一页/下一节"
  // 找不到 → 有未完成的章节测验就先做测验 → 再兜底右侧目录
  let nextAttemptSig = { href: '', n: 0, ts: 0 };

  async function goNextAfterTaskDone(reason) {
    await waitStatus('视频任务点已完成', '进入下一节');
    if (!running) return false;

    // 同一页面连续尝试 4 次仍跳不动 → 停止反复滚动，提示手动处理
    const sig = quizSigOf(document);
    if (nextAttemptSig.href === sig && Date.now() - nextAttemptSig.ts < 90000) {
      nextAttemptSig.n++;
    } else {
      nextAttemptSig = { href: sig, n: 1, ts: Date.now() };
    }
    nextAttemptSig.ts = Date.now();
    if (nextAttemptSig.n > 4) {
      setStatus('未找到可跳转的「下一节」，请在右侧目录手动点一下', 'err');
      nextAttemptSig.ts = Date.now();
      return false;
    }

    // 1. 同章节还有未完成任务点（章节测验 / 第二个视频 / 文档 …）→ 先切换过去，顺序无关
    const tab = findUnfinishedTaskTab({ skipVideo: true });
    if (tab && await clickTaskTab(tab, reason)) return 'tab';

    // 2. 没有未完成任务点 → 一直往下滑到最底部，找"下一页/下一节"并点击
    if (await scrollFindNext(reason)) return 'scroll';

    // 3. 兜底：视频旁边的章节测验标签（结构不标准时）
    const quizTab = findQuizTab();
    if (quizTab && !isTreeCompleted(quizTab)) {
      if (clickQuizTab(reason)) return 'quiztab';
      return false;
    }

    // 4. 兜底：直接点内容区里下一个未完成的任务点（学习通 .ans-attach-ct / .ans-job-ct）
    if (clickContentNextTask(reason)) return 'content';

    // 5. 兜底：右侧目录换到下一个任务点
    if (fallbackCooldown > 0) return false;
    fallbackCooldown = 8;
    if (clickSidebarNext()) return 'sidebar';
    return false;
  }

  // 直接点内容区里下一个未完成的任务点
  function clickContentNextTask(reason) {
    for (const d of getAllDocs()) {
      let items;
      try { items = d.querySelectorAll('.ans-attach-ct, .ans-job-ct'); } catch (e) { continue; }
      for (const it of items) {
        const cls = (it.className || '').toString();
        if (/ans-job-finished|complet|finish|done|success/i.test(cls)) continue;
        // 跳过视频类任务点（含 iframe 内的视频），避免点回同一个视频造成循环
        let hasVideo = false;
        try {
          hasVideo = !!it.querySelector('video') ||
            !!it.querySelector('iframe[src*="video"], iframe[src*=".mp4"], iframe[data*="video"], iframe[data*="mp4"]');
        } catch (e) {}
        if (hasVideo) continue;
        const r = it.getBoundingClientRect();
        if (r.width <= 0 || r.height <= 0) continue;
        setStatus(`${reason}，切换到下一个任务点`);
        simulateClick(it);
        lastNextClickTime = Date.now();
        return true;
      }
    }
    return false;
  }

  function findReadButton() {
    // 查找"去阅读"按钮（进入阅读内容页）
    const docs = getAllDocs();
    for (const d of docs) {
      try {
        const btns = d.querySelectorAll('button, a, span, div');
        for (const b of btns) {
          const t = (b.textContent || '').trim();
          if (t !== '去阅读' && t !== '开始阅读' && t !== '立即阅读' && t !== '阅读') continue;
          if (t.length > 10) continue;
          const r = b.getBoundingClientRect();
          if (r.width > 0 && r.height > 0) return pickClickable(b);
        }
      } catch (e) {}
    }
    return null;
  }

  function slowScrollDown() {
    return new Promise(resolve => {
      let scrolled = 0;
      const step = () => {
        window.scrollBy(0, 200);
        scrolled += 200;
        if (scrolled < 2000) setTimeout(step, 100);
        else resolve();
      };
      step();
    });
  }

  // ========== 文档/图书任务点自动完成 ==========
  let docScrollState = null; // { phase: 'scrolling'|'waiting', scrollCount }

  function isDocTaskPoint() {
    // 检测是否是文档/图书/阅读类任务点（跨 iframe 检测，章节内容在 iframe 里）
    for (const d of getAllDocs()) {
      try {
        // 阅读器容器
        if (d.querySelector('.reader-pdf-container, .reader-doc-container, [class*="pdf-container"], [class*="docContainer"], .pdfContainer')) return true;
        // 任务点标签："文档"/"图书"/"阅读"（单个序号，排除右侧目录里的"08 阅读"章节名）
        let els;
        try { els = d.querySelectorAll('span, button, a, div'); } catch (e) { els = []; }
        for (const el of els) {
          const t = (el.textContent || '').replace(/\s+/g, '');
          if (!t || t.length > 8) continue;
          if (!/^\d?(文档|图书|阅读)$/.test(t)) continue;
          if (inCatalogTree(el)) continue;
          const r = el.getBoundingClientRect();
          if (r.width > 0 && r.height > 0) return true;
        }
        // 文字特征
        const body = (d.body && d.body.innerText) || '';
        if (/去阅读|开始阅读|阅读任务|文档任务/.test(body)) return true;
      } catch (e) {}
    }
    return false;
  }

  // 跨 iframe 判断"任务点已完成"文字/标记（用于阅读、测验等无视频场景）
  function hasTaskDoneText() {
    for (const d of getAllDocs()) {
      try {
        if (d.querySelector('.ans-job-finished')) return true;
        const t = (d.body && d.body.innerText || '').replace(/\s+/g, '');
        if (/任务点已完成/.test(t)) return true;
      } catch (e) {}
    }
    return false;
  }

  async function completeDocTaskPoint() {
    if (!docScrollState) docScrollState = { phase: 'scrolling', scrollCount: 0 };

    if (docScrollState.phase === 'scrolling') {
      // 滚动所有可滚动区域（含 iframe 和内部滚动容器）
      const roots = getScrollRoots();
      let scrolled = false;
      for (const s of roots) {
        try {
          if (s.tagName === 'IFRAME') {
            if (s.contentWindow) { s.contentWindow.scrollBy(0, 300); scrolled = true; }
          } else {
            const old = s.scrollTop;
            s.scrollTop += 300;
            if (s.scrollTop !== old) scrolled = true;
          }
        } catch (e) {}
      }
      try { window.scrollBy(0, 300); } catch (e) {}

      docScrollState.scrollCount++;

      if (docScrollState.scrollCount > 30 || !scrolled) {
        docScrollState.phase = 'waiting';
        setStatus('文档已浏览完成，等待任务点更新…');
        await new Promise(r => setTimeout(r, 2000));
        if (hasTaskDoneText()) {
          docScrollState = null;
          return 'completed';
        }
        if (await skipToNext('文档任务点完成')) {
          docScrollState = null;
          return 'next';
        }
        docScrollState = null;
        return 'done';
      }
      setStatus(`浏览文档中… (${docScrollState.scrollCount}/30)`);
      return 'scrolling';
    }
    return 'waiting';
  }

  // ========== 人脸识别提醒 ==========
  let faceNotified = false;
  function checkFaceRecognition() {
    if (!document.querySelector('.face')?.checked || faceNotified) return;
    const text = document.body ? document.body.innerText : '';
    const hasFace = /人脸|刷脸|人脸识别|face|活体检测/i.test(text) ||
                    document.querySelector('[class*="face"], [class*="live"], [id*="face"], video[class*="face"]');
    if (hasFace) {
      faceNotified = true;
      setStatus('⚠️ 检测到人脸识别！请手动处理', 'warn');
      // 弹出提示
      try {
        if (window.Notification && Notification.permission === 'granted') {
          new Notification('学习通助手', { body: '检测到人脸识别，请手动处理！' });
        }
      } catch (e) {}
      // 暂停挂机
      if (running) stopHang();
      setTimeout(() => { faceNotified = false; }, 30000);
    }
  }

  // ========== 字体解密 ==========
  // 学习通有时用自定义字体加密文字，解密后可复制
  let fontDecryptAttempted = false;
  async function decryptFonts() {
    if (!document.querySelector('.fontdec')?.checked || fontDecryptAttempted) return;
    fontDecryptAttempted = true;
    setStatus('正在尝试字体解密…');

    try {
      // 查找页面中的 @font-face 自定义字体
      const fontFaceRegex = /@font-face\s*\{[^}]*src:\s*url\(["']?([^"')]+)["']?\)[^}]*\}/g;
      const styles = document.querySelectorAll('style');
      let fontUrls = [];

      for (const style of styles) {
        const css = style.textContent || '';
        let match;
        while ((match = fontFaceRegex.exec(css)) !== null) {
          fontUrls.push(match[1]);
        }
      }

      if (fontUrls.length === 0) {
        setStatus('未检测到加密字体');
        return;
      }

      // 下载并解析字体文件的 cmap 表
      for (const url of fontUrls) {
        try {
          const resp = await fetch(url);
          const buffer = await resp.arrayBuffer();
          const view = new DataView(buffer);

          // 解析 TrueType/OpenType 字体的 cmap 表
          // 简化版：读取字体的 cmap 映射
          const numTables = view.getUint16(4);
          let cmapOffset = -1;
          for (let i = 0; i < numTables; i++) {
            const tag = String.fromCharCode(
              view.getUint8(12 + i * 16),
              view.getUint8(12 + i * 16 + 1),
              view.getUint8(12 + i * 16 + 2),
              view.getUint8(12 + i * 16 + 3)
            );
            if (tag === 'cmap') {
              cmapOffset = view.getUint32(12 + i * 16 + 8);
              break;
            }
          }

          if (cmapOffset < 0) continue;

          // 解析 cmap 表，建立 glyphId -> unicode 映射
          const numSubtables = view.getUint16(cmapOffset + 2);
          const glyphMap = {};
          for (let i = 0; i < numSubtables; i++) {
            const platformID = view.getUint16(cmapOffset + 4 + i * 8);
            const encodingID = view.getUint16(cmapOffset + 4 + i * 8 + 2);
            const subtableOffset = cmapOffset + view.getUint32(cmapOffset + 4 + i * 8 + 4);
            const format = view.getUint16(subtableOffset);

            if (format === 4) {
              // Format 4: Segment mapping to delta values
              const segCount = view.getUint16(subtableOffset + 6) / 2;
              const endCodes = [];
              const startCodes = [];
              const idDeltas = [];
              for (let j = 0; j < segCount; j++) {
                endCodes.push(view.getUint16(subtableOffset + 14 + j * 2));
              }
              for (let j = 0; j < segCount; j++) {
                startCodes.push(view.getUint16(subtableOffset + 16 + segCount * 2 + j * 2));
              }
              for (let j = 0; j < segCount; j++) {
                idDeltas.push(view.getUint16(subtableOffset + 16 + segCount * 4 + j * 2));
              }
              for (let j = 0; j < segCount; j++) {
                for (let code = startCodes[j]; code <= endCodes[j] && code !== 0xFFFF; code++) {
                  const glyphId = (code + idDeltas[j]) & 0xFFFF;
                  if (glyphId !== 0) glyphMap[glyphId] = code;
                }
              }
            } else if (format === 12) {
              // Format 12: Segmented coverage
              const numGroups = view.getUint32(subtableOffset + 12);
              for (let j = 0; j < numGroups; j++) {
                const startCharCode = view.getUint32(subtableOffset + 16 + j * 12);
                const endCharCode = view.getUint32(subtableOffset + 16 + j * 12 + 4);
                const startGlyphID = view.getUint32(subtableOffset + 16 + j * 12 + 8);
                for (let code = startCharCode; code <= endCharCode; code++) {
                  glyphMap[startGlyphID + (code - startCharCode)] = code;
                }
              }
            }
          }

          // 替换页面中的加密文字
          if (Object.keys(glyphMap).length > 0) {
            const textNodes = document.evaluate(
              '//text()', document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null
            );
            for (let i = 0; i < textNodes.snapshotLength; i++) {
              const node = textNodes.snapshotItem(i);
              if (node.parentElement && getComputedStyle(node.parentElement).fontFamily.includes('custom')) {
                let text = node.textContent;
                let result = '';
                for (const ch of text) {
                  const code = ch.charCodeAt(0);
                  result += glyphMap[code] ? String.fromCharCode(glyphMap[code]) : ch;
                }
                node.textContent = result;
              }
            }
            setStatus('字体解密完成（可复制文字）', 'ok');
          }
        } catch (e) {
          console.error('字体解密失败:', e);
        }
      }
    } catch (e) {
      setStatus('字体解密失败');
    }
  }

  // 空任务点章节：页面显示"暂无内容"，既没有视频也没有测验/文档
  let emptyChapterHits = 0;
  function isEmptyChapter() {
    let hasPlaceholder = false;
    try {
      for (const d of getAllDocs()) {
        let t = '';
        try { t = (d.body && d.body.innerText || '').replace(/\s+/g, ''); } catch (e) { continue; }
        if (/暂无内容|暂无任务点|暂无学习内容|该章节暂无|没有任务点|尚未发布/.test(t)) { hasPlaceholder = true; break; }
      }
    } catch (e) {}
    if (!hasPlaceholder) { emptyChapterHits = 0; return false; }
    if (collectVideos().length) { emptyChapterHits = 0; return false; }
    if (isQuizPage()) { emptyChapterHits = 0; return false; }
    if (isLiveStream()) { emptyChapterHits = 0; return false; }
    emptyChapterHits++;
    return emptyChapterHits >= 2; // 连续两轮确认，避免加载瞬间的占位文案误判
  }

  let ticking = false;
  async function tick() {
    // 单飞：上一轮还没跑完（等 8 秒/答题）时不重复进入，避免重复点击
    if (!running || ticking) return;
    ticking = true;
    try { await tickBody(); } catch (e) {} finally { ticking = false; }
  }

  // ========== 任务点类型自动识别 ==========
  // 识别完再决定动作：视频 → 刷视频；答题页 → AI搜题/跳过；直播 → 不观看直接下一节；
  // 阅读/文档 → 滚动完成或跳过；空任务点 → 直接下一节
  let currentTaskType = 'unknown';
  let unknownTaskHits = 0;

  function getActiveTaskTabText() {
    try {
      for (const chips of getTaskTabGroups()) {
        for (const c of chips) {
          if (isActiveTaskEl(c.el, true)) return c.text;
        }
      }
    } catch (e) {}
    return '';
  }

  function isChapterPage() {
    try { return /studentstudy/i.test(location.href); } catch (e) { return false; }
  }

  function detectTaskPoint() {
    try {
      if (isLiveStream()) return { type: 'live', label: '直播 · 跳过不观看' };
      if (isQuizPage()) return { type: 'quiz', label: '答题页 · 章节测验/作业' };
      if (collectVideos().length) return { type: 'video', label: '视频任务点' };
      if (isDocTaskPoint()) return { type: 'doc', label: '阅读 / 文档任务点' };
      if (isEmptyChapter()) return { type: 'empty', label: '空任务点 · 直接下一节' };
      // 页面还没渲染出来 → 用当前激活的任务点标签先推断
      const at = getActiveTaskTabText();
      if (at) {
        if (/直播/.test(at)) return { type: 'live', label: '直播 · 跳过不观看' };
        if (/测验|作业|考试/.test(at)) return { type: 'quiz', label: '答题页 · 章节测验/作业' };
        if (/视频/.test(at)) return { type: 'video', label: '视频任务点 · 加载中' };
        if (/文档|图书|阅读/.test(at)) return { type: 'doc', label: '阅读 / 文档任务点 · 加载中' };
      }
    } catch (e) {}
    return { type: 'unknown', label: '未识别（等待加载）' };
  }

  async function tickBody() {
    if (!running) return;
    if (fallbackCooldown > 0) fallbackCooldown--;
    ensureRate();

    // 检测人脸识别
    checkFaceRecognition();

    if (!isChaoxing) {
      setStatus('非学习通，仅倍速');
      return;
    }

    // 先自动识别当前是什么任务点，再按识别结果决定动作
    let tp;
    try { tp = detectTaskPoint(); } catch (e) { tp = { type: 'unknown', label: '未识别（等待加载）' }; }
    currentTaskType = tp.type;
    setTaskType(tp.label);

    // 直播任务 —— 不用观看，直接跳下一节
    if (tp.type === 'live') {
      if (await skipToNext('直播任务，跳过')) return;
      setStatus('直播任务：未找到下一节，等待…', 'warn');
      return;
    }

    // 空任务点（"暂无内容"）—— 直接跳下一节
    if (tp.type === 'empty') {
      if (await skipToNext('本章暂无内容，跳过')) return;
      setStatus('本章暂无内容：未找到下一节，等待…', 'warn');
      return;
    }

    const items = collectVideos();

    if (items.length === 0) {
      // 尝试字体解密
      if (document.querySelector('.fontdec')?.checked) decryptFonts();

      // 没找到视频元素，但可能"任务点已完成"（视频播完被移除）→ 跳下一节
      if (isTaskCompleted(document, null)) {
        if (await goNextAfterTaskDone('任务点已完成')) return;
      }

      // 检测是否是文档/图书/阅读类任务点（答题页优先，避免被误判成文档任务）
      if (document.querySelector('.doc')?.checked && isDocTaskPoint() && !isQuizPage()) {
        // 有"下一节"按钮 → 不是最后一节，直接跳过
        if (findNextSectionButton(document)) {
          if (await clickNextSection('阅读任务（非最后一节），跳过')) {
            docScrollState = null;
            return;
          }
        }
        // 最后一节：先点"去阅读"进入阅读页
        const readBtn = findReadButton();
        if (readBtn) {
          setStatus('阅读任务（最后一节），进入阅读');
          simulateClick(readBtn);
          docScrollState = null;
          return;
        }
        // 已在阅读页，开始滚动浏览
        const result = await completeDocTaskPoint();
        if (result === 'next' || result === 'completed' || result === 'done') {
          docScrollState = null;
        }
        return;
      }

      if (isQuizPage()) {
        const aiEnabled = document.querySelector('.ai')?.checked;
        const skipEnabled = document.querySelector('.skip')?.checked !== false;

        // AI 答题模式：逐题搜索答案并提交
        if (aiEnabled) {
          const result = await answerChapterQuiz();
          if (result === 'submitted' || result === 'done') {
            quizCooldown = 3;
            // 测验做完：回到顶部确认 → 找下一节 → 滚动 → 侧面目录
            if (await goNextAfterQuiz()) return;
            return;
          }
          // AI 没答出来（没配 Key/搜不到/结构不识别）→ 兜底跳过，避免一直卡在答题页
          if (quizCooldown > 0) {
            setStatus(`AI未答出，${quizCooldown}s 后跳过本测验`, 'warn');
            quizCooldown--;
            return;
          }
          if (await clickNextSection('答题页：AI未答出，跳过')) {
            quizCooldown = 6;
            scrollCount = 0;
            return;
          }
          setStatus('答题页：AI未答出，且未找到「下一节」', 'warn');
          return;
        }

        // 跳过模式（不提交）
        if (skipEnabled) {
          if (quizCooldown > 0) {
            setStatus(`答题页等待中… ${quizCooldown}s`, 'warn');
            quizCooldown--;
            return;
          }
          if (await clickNextSection('答题页：跳过（未提交）')) {
            quizCooldown = 5;
            scrollCount = 0;
            return;
          } else {
            if (scrollCount < 10) {
              setStatus(`答题页：滚动找下一节按钮… (${scrollCount + 1})`, 'warn');
              await slowScrollDown();
              scrollCount++;
              return;
            } else {
              setStatus('答题页：未找到下一节按钮，等待…', 'warn');
              return;
            }
          }
        }
      }
      // 识别不出类型（页面结构异常 / 一直加载不出来）→ 连续多轮后跳过，避免卡死
      if (tp.type === 'unknown') {
        unknownTaskHits++;
        if (unknownTaskHits >= 8 && (isChapterPage() || findNextSectionButton(document))) {
          unknownTaskHits = 0;
          if (await skipToNext('未识别到任务点，跳过')) return;
        } else {
          setStatus(`等待页面加载…（未识别任务点 ${unknownTaskHits}/8）`, 'warn');
          return;
        }
      } else {
        unknownTaskHits = 0;
      }
      setStatus('等待视频加载…');
      return;
    }

    for (const item of items) {
      const v = item.v;
      const doc = item.doc;

      // 尝试字体解密（视频页的描述文字也可能加密）
      if (document.querySelector('.fontdec')?.checked) decryptFonts();

      // 优先处理视频弹题 —— 弹题弹窗会挡住"下一节"按钮，必须先关掉
      // 视频弹题会挡住播放/下一节按钮，两种答题模式开着时都要处理
      const quizModeOn = (document.querySelector('.ai')?.checked) || (document.querySelector('.skip')?.checked !== false);
      if (isVideoQuiz() && quizModeOn) {
        const result = await answerVideoQuiz();
        if (result === 'correct' || result === 'wrong' || result === 'unknown') {
          // 弹题处理完，继续播放
          try { v.play(); } catch (e) {}
          return;
        }
        // no-options / no-target：不是真弹题，继续往下走
      }

      // 检测"任务点已完成" —— 交给 章节测验/右侧目录
      if (isTaskCompleted(doc, v)) {
        // 先关掉可能挡住按钮的弹窗
        await closeQuizPopup();
        const nextVid = findNextVideoTaskPoint(doc);
        if (nextVid) {
          await throttleNextClick('视频任务点已完成');
          setStatus('视频任务点已完成，切换下一个视频');
          simulateClick(nextVid);
          lastNextClickTime = Date.now();
          return;
        }
        if (await goNextAfterTaskDone('视频任务点已完成')) return;
        continue;
      }

      const dur = v.duration || 0;
      const cur = v.currentTime || 0;
      const paused = v.paused;
      const ended = v.ended;
      const pct = dur > 0 ? (cur / dur * 100) : 0;

      setProg(`${cur.toFixed(0)}s/${dur.toFixed(0)}s (${pct.toFixed(0)}%)`);

      if (ended || (dur > 5 && cur >= dur * 0.995)) {
        // 先关掉可能挡住按钮的弹窗
        await closeQuizPopup();
        // 视频看完了，先检查同节是否有下一个视频
        const nextVid = findNextVideoTaskPoint(doc);
        if (nextVid) {
          await throttleNextClick('已看完');
          setStatus('视频任务点已完成，切换下一个视频');
          simulateClick(nextVid);
          lastNextClickTime = Date.now();
          return;
        }
        // 章节测验标签优先，没有则右侧目录下一个（不碰下一节）
        if (await goNextAfterTaskDone('视频任务点已完成')) return;
        setStatus('视频任务点已完成，等待切换…');
        return;
      }

      if (paused) {
        setStatus('运行中…（暂停中，尝试播放）');
        try {
          const p = v.play();
          if (p && p.catch) {
            p.catch(() => {
              if (document.querySelector('.mute')?.checked !== false) {
                try { v.muted = true; v.play(); } catch (e) {}
              }
            });
          }
        } catch (e) {}
      } else {
        setStatus('运行中…');
      }

      setRate(currentRate);
      if (document.querySelector('.mute')?.checked !== false) {
        try { v.muted = true; } catch (e) {}
      }

      return;
    }
  }

  // 初始化面板
  if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', initPanel);
  } else {
    initPanel();
  }

  // 注册脚本猫菜单项（超星快捷入口）
  try {
    if (typeof GM_registerMenuCommand === 'function') {
      GM_registerMenuCommand('📖 超星首页', () => {
        if (typeof GM_openInTab === 'function') {
          GM_openInTab('https://www.chaoxing.com/', { active: true });
        } else {
          window.open('https://www.chaoxing.com/', '_blank');
        }
      });
      GM_registerMenuCommand('📚 我的课程', () => {
        if (typeof GM_openInTab === 'function') {
          GM_openInTab('https://i.chaoxing.com/', { active: true });
        } else {
          window.open('https://i.chaoxing.com/', '_blank');
        }
      });
      GM_registerMenuCommand('🎬 超星学习', () => {
        if (typeof GM_openInTab === 'function') {
          GM_openInTab('https://mooc1.chaoxing.com/', { active: true });
        } else {
          window.open('https://mooc1.chaoxing.com/', '_blank');
        }
      });
    }
  } catch (e) {}

  // 定时确保倍速
  setInterval(ensureRate, 1500);

})();