// ==UserScript==
// @name         山东省教师教育网 · 不用守着，自动一节接一节播完
// @namespace    https://scriptcat.org/zh-CN/users/219470
// @version      1.5.4
// @description  不用守着电脑：打开课程页自动播放，切窗口、锁屏被暂停会自动恢复，一节播完自动跳到下一节还没学的，十几二十节不用一直盯着。右下角小窗显示当前章节、本节进度、今日自动接了几节和运行日志。不改学时、不发请求、不需要卡密。
// @author       banger
// @match        *://*.qlteacher.com/*
// @match        *://qlteacher.com/*
// @grant        none
// @run-at       document-idle
// @icon         https://scriptcat.org/api/v2/resource/image/NH1cC8OAoyGu6Z6w
// @license      MIT
// @tag          山东省教师教育网
// @tag          山东教师教育网
// @tag          教师研修
// @tag          继续教育
// @tag          远程研修
// @tag          自动播放
// @tag          自动连播
// @tag          qlteacher
// ==/UserScript==

/*
 * 免费版做三件事，且只做这三件：
 *   1. 自动播放（被浏览器或平台暂停后自动恢复，必要时静音绕过自动播放限制）
 *   2. 一节播完 / 平台标记「已完成」后，自动点开章节列表切到下一节未完成的
 *   3. 右下角一个小面板，显示当前章节、播放进度、自动切换次数
 *
 * 刻意不做的事：
 *   · 自动答随堂题 / 章节测试（会误导学习者，也容易被判无效）
 *   · 跨课程连续学习、无人值守（同上）
 *   · 跳过或伪造播放时长
 * 原因很简单：「自动答题」和「跳过时长」都直接违反平台的学习规则，
 * 放进来会让脚本被举报下架，用户账号也可能被判学时无效。
 * 本脚本不改动视频进度、不伪造上报、不改倍速，只是替你点「播放」。
 */

(function () {
  'use strict';

  const VER = '1.5.4';

  /* 同一 frame 只跑一份；但**版本不同必须接管**——
     改过 @name 之后，脚本管理器会把新旧各装一份，旧实例先占位时
     若直接 return，新装的这一份就永远画不出面板（用户看到「升级后没反应」）。 */
  if (window.__sdfFree === VER) return;
  window.__sdfFree = VER;

  const IS_TOP = window.top === window.self;
  const LS_KEY = 'sdf_free_v1';
  const TICK = 2000;

  /* ================= 配置存取 ================= */
  const DEFAULT_CFG = { on: true, folded: false, x: null, y: null, switched: 0 };
  let cfg = Object.assign({}, DEFAULT_CFG);

  function loadCfg() {
    try {
      const o = JSON.parse(localStorage.getItem(LS_KEY) || '{}');
      cfg = Object.assign({}, DEFAULT_CFG, o);
    } catch (e) {
      cfg = Object.assign({}, DEFAULT_CFG);
    }
  }
  function saveCfg() {
    try {
      localStorage.setItem(LS_KEY, JSON.stringify(cfg));
    } catch (e) {
      /* 隐私模式下写不进去，忽略 */
    }
  }
  loadCfg();

  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

  /* ================= 平台接口失败记录（只看不动） =================
     平台把所有失败请求都弹成「出错了 + 状态文本 + 点击刷新」：
       status 0  → "Unknown Error"（请求被取消，比如切页把它掐了）
       status 5xx → "Server Error" / "Internal Server Error"（它后端自己挂了）
     脚本不发任何请求（@grant none），所以这类 5xx 与脚本无关；
     但光靠嘴说没用，这里把挂掉的那条接口记下来，面板日志里点名，
     用户截图一看就知道是平台的哪个接口在报错。 */
  const netFails = [];
  function recordFail(method, url, status, statusText, body) {
    try {
      const u = String(url || '').replace(location.origin, '').slice(0, 90);
      const item = {
        m: String(method || 'GET').toUpperCase(),
        u: u,
        s: status,
        t: statusText || '',
        b: String(body || '').replace(/\s+/g, ' ').slice(0, 80),
        at: Date.now()
      };
      netFails.push(item);
      while (netFails.length > 5) netFails.shift();
      /* 4xx 太吵（平台自己也会轮询 401），只在 5xx 时写进日志 */
      if (status >= 500) logLine('平台接口失败 ' + status + ' ' + item.t + '：' + item.m + ' ' + u);
    } catch (e) {
      /* ignore */
    }
  }

  (function hookNet() {
    try {
      const XO = window.XMLHttpRequest;
      if (XO && XO.prototype) {
        const op = XO.prototype.open;
        const sd = XO.prototype.send;
        XO.prototype.open = function (m, u) {
          this.__sdfM = m;
          this.__sdfU = u;
          return op.apply(this, arguments);
        };
        XO.prototype.send = function () {
          try {
            this.addEventListener('loadend', () => {
              try {
                if (this.status >= 400) {
                  recordFail(this.__sdfM, this.__sdfU, this.status, this.statusText, this.responseText);
                }
              } catch (e) {
                /* ignore */
              }
            });
          } catch (e) {
            /* ignore */
          }
          return sd.apply(this, arguments);
        };
      }
    } catch (e) {
      /* 页面把 XHR 冻住了就跳过，不影响主流程 */
    }
    try {
      const F = window.fetch;
      if (F) {
        window.fetch = function (input, init) {
          const u = typeof input === 'string' ? input : input && input.url;
          const m = (init && init.method) || (input && input.method) || 'GET';
          return F.apply(this, arguments).then((res) => {
            try {
              if (res && res.status >= 400) {
                res.clone().text().then((t) => recordFail(m, u, res.status, res.statusText, t)).catch(() => {});
              }
            } catch (e) {
              /* ignore */
            }
            return res;
          });
        };
      }
    } catch (e) {
      /* ignore */
    }
  })();

  /* ================= 基础判定 ================= */
  /* 章节页：不再猜死路径，凡是学习/播放类路径或页面上有章节列表都算 */
  const isChapterPage = () => {
    const u = location.pathname + location.hash + location.search;
    if (/\/learning\//i.test(u)) return true;
    if (/(player|\/play|learn|course|lesson|chapter|study|video|kecheng)/i.test(u)) return true;
    return !!document.querySelector('.chapter-drawer, nz-sider, [class*=chapter], [class*=section-list]');
  };
  const getVideo = () => document.querySelector('video');

  /* 平台的错误弹层：切章节那一刻，它自己还没发完的请求会被取消，
     Angular 把被取消的请求抛成 status=0 的 HttpErrorResponse
     （statusText 默认就是 "Unknown Error"），平台的全局错误处理
     原样显示出来，就成了「出错了 / Unknown Error / 点击刷新」。
     这跟脚本无关，但用户会以为是脚本坏了——认出来，在面板里说清楚。 */
  function platformErrorText() {
    const nodes = document.querySelectorAll(
      '[role=dialog], .ant-modal, .ant-modal-content, .el-message-box, .ant-message-notice'
    );
    for (const n of nodes) {
      if (!n.offsetParent) continue;
      const t = (n.innerText || '').replace(/\s+/g, ' ').trim();
      if (!t) continue;
      if (t.indexOf('Unknown Error') >= 0) return t.slice(0, 46);
      if (t.indexOf('出错了') >= 0 && t.indexOf('刷新') >= 0) return t.slice(0, 46);
    }
    return '';
  }

  /* 平台右上角的「剩余时长 / 已完成」角标 */
  function badgeText() {
    const el = document.querySelector('.count-down');
    return el ? (el.innerText || '').replace(/\s+/g, ' ').trim() : '';
  }

  /* 随堂题：弹出带输入框 / 选项的弹层。检测到就停下，别跟它抢播放 */
  function hasQuiz() {
    const boxes = document.querySelectorAll('.ant-modal textarea, .ant-modal .ant-checkbox-input, .ant-modal .ant-radio-input, textarea');
    for (const el of boxes) {
      if (el.offsetParent !== null) return true;
    }
    return false;
  }

  /* 平台「同一活动多窗口」提示，出现时别继续点播放，否则越点越乱 */
  function hasConflict() {
    const txt = (document.body && document.body.innerText) || '';
    return /同一活动.{0,16}多个窗口|多个窗口进行学习|只对最后一次打开的窗口/.test(txt);
  }

  /* ================= 视频守护 ================= */
  let lastTry = 0;

  /* ---------- 声音状态 ----------
     浏览器的自动播放策略会拦「有声 play()」，脚本的保命手段是「先静音再 play」。
     静音只是手段、不是目的，所以必须记住这两件事：
       1) 这次静音是脚本干的（autoMuted），不是用户的意愿；
       2) 用户自己点过静音（userMuted），那才是真的不要声音，别去覆盖。
     否则切到后台被平台暂停、脚本静音救回来之后，声音就再也不会自己回来，
     回到前台整节课都哑着——用户只会认为「这功能被故意限制了」。 */
  let autoMuted = false;
  let userMuted = false;
  /* 恢复声音也会失败：有的浏览器一 unmute 就把视频掐停。
     这时立刻退回静音续播，并且退避几秒再试，别每 2 秒来回抖一次。 */
  let restoreFails = 0;
  let restoreCoolUntil = 0;
  try { userMuted = localStorage.getItem('sdf_free_sound') === 'off'; } catch (e) { /* ignore */ }

  function setUserMuted(off) {
    userMuted = !!off;
    try { localStorage.setItem('sdf_free_sound', off ? 'off' : 'on'); } catch (e) { /* ignore */ }
  }

  /* 把脚本临时关掉的声音还回去。unmute 不需要用户手势，所以随时可以调用；
     个别浏览器 unmute 会把视频掐停（自动播放策略），900ms 后检查一次，
     真被掐了就退回静音续播，宁可有声变无声，也不能让进度停住。 */
  function restoreSound(why, force) {
    const v = getVideo();
    if (!v) return;
    if (!autoMuted) return;
    if (userMuted) { autoMuted = false; return; }
    if (!force && Date.now() < restoreCoolUntil) return; /* 刚试过被掐，歇一会儿 */
    const playing = !v.paused && !v.ended;
    autoMuted = false;
    v.muted = false;
    logLine('声音已恢复' + (why ? '（' + why + '）' : ''));
    if (!playing) return;
    setTimeout(() => {
      const vv = getVideo();
      if (!vv || vv.ended) return;
      if (vv.paused) {
        vv.muted = true;
        autoMuted = true;
        try {
          const p = vv.play();
          if (p && p.catch) p.catch(() => {});
        } catch (e) { /* ignore */ }
        restoreFails += 1;
        restoreCoolUntil = Date.now() + Math.min(60000, 6000 * restoreFails);
        logLine('这个浏览器不让直接出声，先静音保证不中断（' +
          Math.round((restoreCoolUntil - Date.now()) / 1000) + ' 秒后再试）');
        renderProgress(vv); /* 喇叭图标立刻跟着变成 🔇，别等下一拍 */
      } else {
        restoreFails = 0;
        restoreCoolUntil = 0;
      }
    }, 900);
  }

  async function tryPlay(v) {
    if (!v) return;
    if (Date.now() - lastTry < 2500) return;
    lastTry = Date.now();

    /* 已经回到前台了：先把上次为止的临时静音还回去，再尝试播放。
       否则「静音 play 一定成功」，播放是恢复了，用户听到的还是哑的。 */
    if (!document.hidden && autoMuted && !userMuted) {
      autoMuted = false;
      v.muted = false;
    }

    try {
      const p = v.play();
      if (p && p.catch) p.catch(() => {});
    } catch (e) {
      /* 自动播放被拦，下面静音重试 */
    }
    await sleep(700);
    if (v.paused) {
      try {
        /* 打标记：这声静音是脚本为了把暂停救回来干的，不是用户设的 */
        if (!v.muted) autoMuted = true;
        v.muted = true;
        const p2 = v.play();
        if (p2 && p2.catch) p2.catch(() => {});
      } catch (e) {
        /* ignore */
      }
    }
  }

  /* ================= 章节列表 ================= */
  /* 「章节」入口：先按平台原来的结构找，找不到再按文字兜底（平台改版时不至于整脚本失效） */
  function findChapterMenu() {
    const direct = [...document.querySelectorAll('nz-sider .menu-item')].find(
      (x) => (x.innerText || '').trim() === '章节'
    );
    if (direct) return direct;
    const cands = [
      ...document.querySelectorAll('.menu-item, .ant-menu-item, [class*="menu"] div, [class*="menu"] span'),
    ];
    return (
      cands.find((x) => (x.innerText || '').trim() === '章节' && x.offsetParent !== null) || null
    );
  }

  async function openDrawer() {
    let d = document.querySelector('.chapter-drawer');
    if (d && d.classList.contains('show')) return true;

    const btn = findChapterMenu();
    if (!btn) return false;
    btn.click();
    for (let i = 0; i < 12; i++) {
      await sleep(400);
      d = document.querySelector('.chapter-drawer');
      if (d && d.classList.contains('show')) return true;
    }
    return false;
  }

  function parseChapters() {
    const nodes = document.querySelectorAll('.chapter-drawer.show li.ant-list-item');
    return [...nodes]
      .map((el, i) => {
        const t = el.querySelector('ellipsis');
        const raw = (el.innerText || '').replace(/\s+/g, ' ').trim();
        return {
          el,
          i,
          raw,
          title: (t && t.getAttribute('title')) || raw.replace(/^必学\s*/, ''),
          done: raw.indexOf('已完成') >= 0,
          recent: raw.indexOf('最近学习') >= 0,
        };
      })
      .filter((c) => c.title);
  }

  let switching = false;
  let cooldownUntil = 0; /* 切换失败后的冷却，避免死循环狂点 */
  const triedFail = new Set(); /* 点过但没跳转的标题，避免反复点同一节 */
  const doneTitles = new Set(); /* 本次会话里已判定学完的标题，防止平台不标记时来回跳 */

  /* 标题归一化：去掉「必学」前缀和标点，用来比较「这一节是不是当前这一节」 */
  function normTitle(s) {
    return (s || '')
      .replace(/^(必学|必修|选修|必|选)\s*/, '')
      .replace(/[\s·、，,。.:：\-—_+()（）]/g, '')
      .toLowerCase();
  }
  const sameTitle = (a, b) => !!normTitle(a) && normTitle(a) === normTitle(b);

  /* 「简介 / 导学 / 前言」这类章节一般不计学时，平台也不给它们标「已完成」。
     把它们当候选的后果就是：整门课学完之后，一次一次跳回最前面那一节。
     标题写法很杂——「简介」「专题简介」「课程简介（必看）」「简介：本专题说明」，
     所以不看开头结尾，只看词 + 长度，短标题里出现这些词就当日志类章节。 */
  const INTRO_WORDS = /(简介|介绍|导学|导言|前言|序言|课程说明|学习说明|研修说明|使用说明)/;
  const isIntroTitle = (t) => {
    const s = normTitle(t);
    return !!s && s.length <= 10 && INTRO_WORDS.test(s);
  };

  /* ===== 「已播过」记录：按课程存本地，刷新页面、重进课程都不丢 ===== */
  function courseId() {
    const m = location.pathname.match(/\/learning\/([^/?#]+)/i);
    return m ? m[1] : location.pathname.replace(/[^\w-]/g, '_').slice(-48);
  }
  let visitedKey = '';
  let visited = new Set();
  function initVisited() {
    visitedKey = 'sdf_seen_' + courseId();
    try {
      const a = JSON.parse(localStorage.getItem(visitedKey) || '[]');
      visited = new Set(Array.isArray(a) ? a : []);
    } catch (e) {
      visited = new Set();
    }
  }
  function markVisited(title) {
    const k = normTitle(title);
    if (!k || visited.has(k)) return;
    visited.add(k);
    try {
      localStorage.setItem(visitedKey, JSON.stringify([...visited].slice(-200)));
    } catch (e) {
      /* 隐私模式写不进去，忽略 */
    }
  }
  initVisited();

  /* 页面上正在播的这一节叫什么 */
  function currentTitleFromPage() {
    const h = document.querySelector('.ellipsis-title, nz-header h1, h1');
    return h ? (h.innerText || '').replace(/\s+/g, ' ').trim() : '';
  }

  function markDoneHere() {
    const t = currentTitleFromPage();
    if (t) doneTitles.add(normTitle(t));
    const list = parseChapters();
    const r = list.find((c) => c.recent);
    if (r) doneTitles.add(normTitle(r.title));
  }

  async function goNextChapter(reason) {
    if (switching) return false;
    if (Date.now() < cooldownUntil) return false;
    switching = true;
    let closeAfter = false;
    let switchedOk = false;
    const fromTitle = currentTitleFromPage();
    try {
      setStatus(reason || '准备切换下一节…');
      const wasOpen = !!(
        document.querySelector('.chapter-drawer') &&
        document.querySelector('.chapter-drawer').classList.contains('show')
      );
      const ok = await openDrawer();
      if (!ok) {
        cooldownUntil = Date.now() + 20000;
        setStatus('没找到章节列表：手动点左侧「章节」再试');
        return false;
      }
      if (!wasOpen) closeAfter = true;

      const list = parseChapters();
      if (!list.length) {
        cooldownUntil = Date.now() + 20000;
        setStatus('章节列表是空的，请手动切下一节');
        return false;
      }

      /* 当前节定位：先用页面标题精确匹配，其次「最近学习」标记，
         最后才按「第一个未完成项的前一项」猜。
         只认「最近学习」有个坑：平台有时把标记停在最早打开的那一节上，
         当前节一旦认错，后面选「下一节」就全乱。 */
      const pageTitle = currentTitleFromPage();
      let cur = -1;
      if (pageTitle) cur = list.findIndex((c) => sameTitle(c.title, pageTitle));
      if (cur < 0 && pageTitle) {
        const p = normTitle(pageTitle);
        cur = list.findIndex((c) => {
          const k = normTitle(c.title);
          return k.length >= 4 && (p.includes(k) || k.includes(p));
        });
      }
      if (cur < 0) cur = list.findIndex((c) => c.recent);
      if (cur < 0) {
        const firstUndone = list.findIndex((c) => !c.done);
        cur = firstUndone <= 0 ? -1 : firstUndone - 1;
      }
      /* 能走到这里说明刚学完一节，把它记下来——平台上如果只有角标、
         不在列表里标「已完成」，不记就会来回跳同一节 */
      if (cur >= 0 && list[cur]) doneTitles.add(normTitle(list[cur].title));

      /* 候选分两段：
         after  = 当前位置之后所有未完成的（正常的前进方向）
         before = 当前位置之前漏掉的，只在 after 全都不合适时才轮到它
         旧版这里是「after.concat(整个列表)」，等于学完最后一节就回头，
         而「简介」一般不会被标「已完成」，于是每次都跳回最前面那一节。
         现在回头必须同时满足：不是简介类、没播过、没点失败过。 */
      const after = list.slice(cur + 1).filter((c) => !c.done);
      const before = list
        .slice(0, Math.max(cur, 0))
        .filter((c) => !c.done && !isIntroTitle(c.title) && !visited.has(normTitle(c.title)));
      const raw = after.concat(before);

      const seen = new Set();
      const cands = [];
      /* 「简介 / 导学」这类章节不参与自动切换：进课程时平台本来就会先播它，
         学完别的再跳回去只会打断后面。例外：整门课只有这一节。 */
      const skipIntro = list.length > 1;
      for (const c of raw) {
        const k = normTitle(c.title);
        if (!k) continue;
        /* 按位置去重，不按标题——有些专题每节都叫「视频」，
           按标题去重会把后面几节全当成重复项丢掉。 */
        if (seen.has(c.i)) continue;
        seen.add(c.i);
        if (triedFail.has(k)) continue;
        if (doneTitles.has(k)) continue;
        if (skipIntro && isIntroTitle(c.title)) continue;
        if (pageTitle && sameTitle(c.title, pageTitle)) continue;
        cands.push(c);
      }

      if (!cands.length) {
        cooldownUntil = Date.now() + 3600000; /* 都学完了，别再问 */
        courseFinished = true;
        setStatus('本课程章节已全部完成', 'ok');
        setHint('<b>完整版会自动进入下一门课</b>，并提交五星评价，一门接一门 ›');
        logLine('本课程已完成（完整版会自动切下一门）');
        return false;
      }

      /* 最多试 3 个候选，第一个点不动就换下一个，不要卡死在同一节 */
      for (const next of cands.slice(0, 3)) {
        const before = location.href;
        next.el.click();
        let moved = false;
        for (let i = 0; i < 16; i++) {
          await sleep(500);
          if (location.href !== before) {
            moved = true;
            break;
          }
        }
        if (moved) {
          switchedOk = true;
          cfg.switched = (cfg.switched || 0) + 1;
          saveCfg();
          triedFail.clear();
          if (fromTitle) {
            doneTitles.add(normTitle(fromTitle));
            markVisited(fromTitle);
          }
          markVisited(next.title);
          setStatus('已切到：' + next.title, 'ok');
          logLine('切到下一节：' + next.title);
          lastSwitchAt = Date.now();
          updateLic();
          return true;
        }
        triedFail.add(normTitle(next.title));
      }

      cooldownUntil = Date.now() + 20000;
      setStatus('自动切换没生效，请手动点左侧章节里的下一节');
      return false;
    } catch (e) {
      cooldownUntil = Date.now() + 20000;
      setStatus('切换失败：' + (e && e.message ? e.message : e));
      return false;
    } finally {
      /* 只有「没切走」时才去关抽屉：已经切到新页面的话，
         这一下点到的可能是新页的「章节」按钮，白开一次列表请求——
         请求刚发出去就被关掉，正好又是那种 status=0 的取消。 */
      if (closeAfter && !switchedOk) {
        const btn = findChapterMenu();
        if (btn) btn.click();
      }
      switching = false;
      /* 切换后重算一节的判定窗口 */
      pageEnterAt = Date.now();
      sawCountdown = false;
      doneStreak = 0;
      endHandled = false;
      endedAt = 0;
    }
  }

  /* ================= 面板 ================= */
  const CONTACT = {
    qq: '1131654415',
    qqLink: 'https://qm.qq.com/q/NVEaYbxOo2',
    email: 'voodoo4@163.com',
  };

  let host = null;
  let root = null;
  let ui = {};
  let lastError = '';
  let lastHint = '';

  /* 兜底面板：主面板万一构建失败，也要让用户看到「脚本在跑」，
     而不是一片空白以为装错了 */
  function fallbackPanel(err) {
    try {
      let h = document.getElementById('sdf-free-host2');
      if (!h) {
        h = document.createElement('div');
        h.id = 'sdf-free-host2';
        h.style.cssText =
          'position:fixed;z-index:2147483647;right:16px;bottom:16px;max-width:320px;' +
          'background:#fff;border:1px solid #fecaca;border-radius:10px;padding:10px 12px;' +
          'font:12px/1.6 -apple-system,"Microsoft YaHei",sans-serif;color:#991b1b;' +
          'box-shadow:0 8px 24px rgba(16,24,40,.18);line-height:1.6';
        document.documentElement.appendChild(h);
      }
      h.textContent =
        '自动学习助手已运行，但面板没能画出来。错误：' + String((err && (err.message || err)) || '未知');
      return h;
    } catch (e) {
      return null;
    }
  }

  /* 任何异常都不允许把面板整个吞掉 */
  function buildPanel(force) {
    try {
      const r = buildPanelInner(force);
      const fp = document.getElementById('sdf-free-host2');
      if (fp && fp.parentNode) fp.parentNode.removeChild(fp);
      return r;
    } catch (err) {
      lastError = String((err && (err.stack || err.message)) || err);
      try {
        console.error('[自动学习助手] 面板构建失败：', err);
      } catch (e) {
        /* ignore */
      }
      return fallbackPanel(err);
    }
  }

  function buildPanelInner(force) {
    if (!IS_TOP) return;
    const old = document.getElementById('sdf-free-host');
    if (old && old.shadowRoot && !old.__sdfOwn) {
      /* 容器是别的版本实例画的：直接接管它的 shadow 重画，
         避免两个面板叠在一起，也避免它因为 host 消失而重建 */
      host = old;
      host.__sdfOwn = true;
      host.style.display = '';
      root = old.shadowRoot;
      root.innerHTML = '';
    } else {
      if (old) {
        if (!force) return;
        if (old.parentNode) old.parentNode.removeChild(old);
      }
      host = document.createElement('div');
      host.id = 'sdf-free-host';
      host.__sdfOwn = true;
      host.style.cssText = 'position:fixed;z-index:2147483647;right:16px;bottom:16px;';
      root = host.attachShadow({ mode: 'open' });
    }

    const css = `
      *{box-sizing:border-box;margin:0;padding:0;font-family:-apple-system,"Microsoft YaHei",sans-serif}
      .wrap{width:302px;background:#fff;border:1px solid #e3e8ef;border-radius:12px;
        box-shadow:0 8px 30px rgba(16,24,40,.16);overflow:hidden;font-size:12px;color:#1f2937;
        max-height:calc(100vh - 24px);display:flex;flex-direction:column}
      .hd{display:flex;align-items:center;gap:6px;padding:9px 12px;
        background:linear-gradient(135deg,#1d4ed8,#3b82f6);color:#fff;cursor:move;user-select:none}
      .hd b{font-size:13px;font-weight:600;flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
      .dot{width:7px;height:7px;border-radius:50%;background:#9ca3af;flex:0 0 auto}
      .dot.on{background:#22c55e;box-shadow:0 0 0 3px rgba(34,197,94,.28)}
      .dot.warn{background:#fbbf24;box-shadow:0 0 0 3px rgba(251,191,36,.26)}
      .ver{font-size:10px;padding:1px 5px;border-radius:4px;background:rgba(255,255,255,.2);
        flex:0 0 auto;cursor:pointer}
      .ver:hover{background:rgba(255,255,255,.32)}
      /* 折叠成一条时，标题栏里挤一个进度胶囊：35% / 已切 3 节，
         扫一眼就知道脚本还在干活，不用展开面板 */
      .fp{display:none;flex:0 0 auto;font-size:10px;line-height:1;padding:3px 6px;border-radius:4px;
        background:rgba(255,255,255,.26);font-variant-numeric:tabular-nums;letter-spacing:.2px;
        white-space:nowrap;cursor:default}
      .fold .fp.on{display:inline-block}
      .fold .ver .vl{display:none}
      .mini{cursor:pointer;opacity:.9;padding:0 4px;font-size:14px;line-height:1}
      .bd{padding:10px 12px 12px;overflow-y:auto;flex:1;min-height:0}
      .uinfo{display:flex;align-items:center;gap:8px;padding:7px 9px;background:#f0f7ff;
        border:1px solid #d6e6ff;border-radius:8px;margin-bottom:8px}
      .avt{width:26px;height:26px;border-radius:50%;background:#2563eb;color:#fff;font-size:12px;
        display:flex;align-items:center;justify-content:center;flex:none}
      .utx{flex:1;line-height:1.35;overflow:hidden}
      .utx b{font-size:12.5px;color:#0f172a;display:block;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
      .utx span{display:block;color:#6b7280;font-size:10.5px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
      .link{color:#2563eb;cursor:pointer;font-size:11px;flex:none}
      .link.lock{color:#b45309}
      .status{margin-bottom:7px;padding:7px 9px;background:#f8fafc;border:1px solid #eef2f7;border-radius:8px;
        line-height:1.6;color:#374151;max-height:52px;overflow:auto}
      .status.ok{background:#f0fdf4;border-color:#bbf7d0;color:#15803d}
      .status.warn{background:#fff7ed;border-color:#fed7aa;color:#9a3412}
      .chap{margin-bottom:8px;padding:7px 9px;background:#fbfcfe;border:1px solid #eef2f7;border-radius:8px}
      .ct{font-size:11.5px;color:#334155;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;margin-bottom:5px}
      .bar{height:5px;background:#eef2f7;border-radius:3px;overflow:hidden}
      .bar>i{display:block;height:100%;width:0;background:linear-gradient(90deg,#3b82f6,#22c55e);transition:width .6s}
      .cp2{display:flex;justify-content:space-between;font-size:10.5px;color:#94a3b8;margin-top:4px}
      .cp2 #pc{font-variant-numeric:tabular-nums}
      .cp2 .vol{flex:none;margin-left:8px;cursor:pointer;font-size:11px;line-height:1;
        opacity:.85;transition:opacity .15s}
      .cp2 .vol:hover{opacity:1}
      .cp2 .vol.mute{color:#ea580c;opacity:1}
      .btns{display:flex;gap:8px}
      .btns button{flex:1;height:30px;border-radius:7px;border:1px solid #d8dee9;background:#fff;cursor:pointer;
        font-size:12px;color:#374151;font-family:inherit}
      .btns button.primary{background:#2563eb;border-color:#2563eb;color:#fff;font-weight:600}
      .btns button.primary.stop{background:#ef4444;border-color:#ef4444}
      .btns button:hover{filter:brightness(.97)}
      .adv{margin-top:8px;color:#2563eb;cursor:pointer;font-size:11px}
      .advbox{display:none;margin-top:6px;padding:8px 9px;background:#fbfcfe;border:1px solid #eef2f7;border-radius:8px}
      .advbox.show{display:block}
      .row{display:flex;align-items:center;gap:6px;margin-bottom:6px}
      .row:last-child{margin-bottom:0}
      .row label{width:56px;flex:none;color:#9aa3af;font-size:11px}
      .row input{flex:1;height:26px;border:1px solid #e8edf4;border-radius:6px;padding:0 7px;font-size:11px;
        background:#f4f6f9;color:#b6bec9;outline:none}
      .row input[type=checkbox]{flex:none;width:14px;height:14px;accent-color:#cbd5e1;padding:0}
      .lk{font-size:10px;color:#b45309;flex:none}
      .log{margin-top:8px;max-height:76px;overflow:auto;background:#0f172a;border-radius:8px;padding:7px 8px;
        color:#cbd5e1;line-height:1.55;font-family:Consolas,Menlo,monospace;font-size:10.5px}
      .log div{white-space:pre-wrap;word-break:break-all}
      .lic{margin-top:8px;padding-top:8px;border-top:1px dashed #e5e7eb;display:flex;align-items:center;gap:6px;
        color:#6b7280;font-size:10.5px;line-height:1.5}
      .lic span{flex:1}
      .link.buy{color:#ea580c;font-weight:600}
      .buybox{display:none;margin-top:7px;padding:8px 9px;background:#fffbf5;border:1px solid #fde3c8;
        border-radius:8px;font-size:10.5px;color:#7c2d12;line-height:1.6}
      .buybox.show{display:block}
      .bq{display:flex;align-items:center;gap:6px;margin-bottom:5px}
      .bq .lab{color:#9a6b45;flex:none}
      .bq b{font-family:Consolas,Menlo,monospace;font-size:12.5px;color:#b45309;letter-spacing:.4px;
        user-select:all;flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
      .feat{margin:4px 0 5px;padding-top:5px;border-top:1px dashed #f3d3b4}
      .feat div:first-child{color:#9a3412;font-weight:600;margin-bottom:2px}
      .feat div{line-height:1.7}
      .bhint{color:#9ca3af;font-size:10px;margin-top:4px;line-height:1.5}
      .tip{margin-top:7px;color:#a3adba;font-size:10px;line-height:1.5}
      .hint{display:none;margin-bottom:7px;padding:6px 9px 6px 8px;background:#fffdf8;
        border:1px solid #fde8c8;border-left:3px solid #f59e0b;border-radius:6px;
        font-size:10.5px;color:#b45309;line-height:1.55;cursor:pointer}
      .hint.show{display:block}
      /* 课件 / 文档类章节：没有视频，平台不会自己往下走，给一个手动跳过的按钮 */
      .skipbar{display:none;align-items:center;gap:8px;margin-bottom:7px;padding:7px 9px;
        background:#fff7ed;border:1px solid #fed7aa;border-radius:8px}
      .skipbar.show{display:flex}
      .skipbar button{flex:none;height:26px;padding:0 11px;border-radius:6px;border:1px solid #f59e0b;
        background:#f59e0b;color:#fff;font-size:11px;font-weight:600;cursor:pointer;font-family:inherit}
      .skipbar button:hover{filter:brightness(.96)}
      .skipbar button:disabled{opacity:.6;cursor:default}
      .skipbar span{font-size:10px;color:#9a3412;line-height:1.4}
      .hint:hover{background:#fff8ec}
      .hint b{color:#9a3412}
      .advmore{margin-top:6px;padding-top:6px;border-top:1px dashed #eef2f7;color:#ea580c;
        cursor:pointer;font-size:10.5px;text-align:center}
      .advmore:hover{text-decoration:underline}
      .feat h4{font-size:10.5px;color:#9a3412;margin:6px 0 2px;font-weight:600}
      .feat h4:first-child{margin-top:0}
      .feat div.it{line-height:1.7;color:#8a5a3d}
      .feat div.it::before{content:"· ";color:#c98a5e}
      .expanded .log{display:none}
      .capsule{width:auto}
      .capsule .bd{display:none}
      .fold{width:auto}
      .fold .bd{display:none}
    `;

    const style = document.createElement('style');
    style.textContent = css;

    const card = document.createElement('div');
    card.className = 'wrap';
    card.innerHTML = `
      <div class="hd" id="hd">
        <span class="dot" id="dot"></span>
        <b>自动学习助手</b>
        <span class="fp" id="fp"></span>
        <span class="ver" id="verTip" title="点这里看完整版还能做什么"><span class="vl">精简版 </span>v${VER}</span>
        <span class="mini" id="fo" title="收起 / 展开">—</span>
      </div>
      <div class="bd">
        <div class="uinfo">
          <span class="avt" id="avt">师</span>
          <div class="utx"><b id="uname">--</b><span id="uacc">平台未登录</span></div>
          <a class="link lock" id="swAcc" title="完整版支持换号不串号">换号</a>
        </div>
        <div class="status" id="st">待机中</div>
        <div class="chap">
          <div class="ct" id="ch">—</div>
          <div class="bar"><i id="pb"></i></div>
          <div class="cp2"><span id="pg">—</span><span id="pc">0%</span><a class="vol" id="vol" title="点一下切换声音" style="display:none">🔊</a></div>
        </div>
        <div class="hint" id="hint"></div>
        <div class="skipbar" id="skipbar">
          <button id="skipBtn">跳过这一节 ›</button>
          <span>完整版遇到课件会自动跳过<br>不用你点</span>
        </div>
        <div class="btns">
          <button class="primary" id="sw">暂停学习</button>
          <button id="clr">清空日志</button>
        </div>
        <div class="adv" id="advt">▸ 高级设置（项目地址 / 评价内容）</div>
        <div class="advbox" id="adv">
          <div class="row"><label>项目页</label><input disabled placeholder="完整版可自定义"><span class="lk">🔒</span></div>
          <div class="row"><label>评价语</label><input disabled placeholder="完整版自动填写"><span class="lk">🔒</span></div>
          <div class="row"><label>自动评价</label><input type="checkbox" disabled><span class="lk">🔒</span></div>
          <div class="row"><label>自动答题</label><input type="checkbox" disabled><span class="lk">🔒</span></div>
          <div class="advmore" id="advmore">查看完整版全部 12 项能力 ›</div>
        </div>
        <div class="log" id="log"></div>
        <div class="lic">
          <span id="licTxt">自动连播已启用</span>
          <a class="link buy" id="buyBtn">完整版 ›</a>
        </div>
        <div class="buybox" id="buybox">
          <div class="bq"><span class="lab">交流群</span><b id="qqNo">${CONTACT.qq}</b><a class="link" id="qqCopy">复制</a></div>
          <div class="feat">
            <h4>学完一门就没人管了？</h4>
            <div class="it">本课程学完自动进下一门，直到全部学完</div>
            <div class="it">登录跟着平台走，换号不串号、不丢进度</div>
            <div class="it">学完自动提交五星评价（评价语可自己改）</div>
            <div class="it">课程打不开、跳 404，自动跳过并继续下一门</div>
            <div class="it">多开了窗口会自动让位，避免被判学时作废</div>
            <h4>题还得自己一道道答？</h4>
            <div class="it">视频中途弹出的随堂题，自动作答并提交，答完接着播</div>
            <div class="it">章节测试自动交卷；答错会读平台答案改对再交</div>
            <div class="it">本地题库 + 从平台解析学答案，越用越准</div>
            <h4>有些章节只能干等？</h4>
            <div class="it">点开就显示「已完成」的章节，8 秒确认后直接跳过</div>
            <div class="it">文档 / PDF 课件，进去即完成、直接返回</div>
            <div class="it">发现被改成非 1 倍速，立即纠正回 1 倍速</div>
          </div>
          <div class="bhint">精简版负责「不用守着」；上面这些是完整版多出来的部分。<br>
            十几门课、上百个章节，手动点一遍是几百次；完整版只需点一次「开始学习」。<br>
            加群后看群公告；也可直接点 <a class="link" id="qqLink">加群链接</a></div>
        </div>
        <div class="tip">全程 1 倍速，不改学时；运行期间请勿关闭本标签页。</div>
      </div>
    `;

    root.append(style, card);
    document.documentElement.appendChild(host);

    ui = {
      card: card,
      dot: root.getElementById('dot'),
      ch: root.getElementById('ch'),
      pg: root.getElementById('pg'),
      pb: root.getElementById('pb'),
      pc: root.getElementById('pc'),
      fp: root.getElementById('fp'),
      vol: root.getElementById('vol'),
      st: root.getElementById('st'),
      more: root.getElementById('buybox'),
      hint: root.getElementById('hint'),
      log: root.getElementById('log'),
      avt: root.getElementById('avt'),
      uname: root.getElementById('uname'),
      uacc: root.getElementById('uacc'),
      skipBar: root.getElementById('skipbar'),
      skipBtn: root.getElementById('skipBtn'),
    };
    lastHint = '';

    /* 进度条右侧的喇叭可以点：手势内 play() 不会被自动播放策略拦，
       声音能立刻出来，不用去页面上找播放器的喇叭 */
    if (ui.vol) ui.vol.addEventListener('click', () => {
      const v = getVideo();
      if (!v) return;
      const wantSound = v.muted;
      /* 点了就是用户自己的决定，记下来：以后不再自动开声/自动静音 */
      setUserMuted(!wantSound);
      autoMuted = false;
      v.muted = !wantSound;
      if (wantSound) {
        try {
          const pr = v.play();
          if (pr && pr.catch) pr.catch(() => {});
        } catch (e) {
          /* ignore */
        }
      }
      renderProgress(v);
      logLine(wantSound ? '已开启声音' : '已静音（你自己设的，脚本不会自己开）');
    });

    /* 课件 / 文档类章节：没有视频可播，只能手动跳。点一次就好。 */
    ui.skipBtn.addEventListener('click', async () => {
      if (ui.skipBtn.disabled) return;
      ui.skipBtn.disabled = true;
      ui.skipBar.classList.remove('show');
      setStatus('正在跳到下一节…');
      await sleep(2200); /* 给平台记「已完成」的时间，别跳太快 */
      const ok = await goNextChapter('手动跳过本节');
      ui.skipBtn.disabled = false;
      if (!ok) {
        setStatus('没跳成功：可能是这一节平台还没记完成，稍等一下再点', 'warn');
        ui.skipBar.classList.add('show');
      }
    });

    card.classList.toggle('fold', !!cfg.folded);
    root.getElementById('fo').textContent = cfg.folded ? '+' : '—';
    root.getElementById('fo').title = cfg.folded ? '展开面板' : '收起面板';

    /* 平台用户信息（只读，不登录、不发请求） */
    fillUser();

    /* 开始 / 暂停 */
    root.getElementById('sw').addEventListener('click', () => {
      cfg.on = !cfg.on;
      saveCfg();
      renderSwitch();
      if (cfg.on) {
        setStatus('已开启，正在接管播放…', 'ok');
        logLine('开始接管');
      } else {
        setStatus('已暂停接管，视频需手动播放', 'warn');
        logLine('暂停接管');
      }
    });

    /* 折叠 */
    root.getElementById('fo').addEventListener('click', (e) => {
      e.stopPropagation();
      cfg.folded = !cfg.folded;
      saveCfg();
      card.classList.toggle('fold', cfg.folded);
      const fo = root.getElementById('fo');
      fo.textContent = cfg.folded ? '+' : '—';
      fo.title = cfg.folded ? '展开面板' : '收起面板';
      restoreCorner();
    });

    /* 高级设置展开 */
    root.getElementById('advt').addEventListener('click', () => {
      const box = root.getElementById('adv');
      const on = box.classList.toggle('show');
      root.getElementById('advt').textContent =
        (on ? '▾ ' : '▸ ') + '高级设置（项目地址 / 评价内容）';
    });

    /* 锁定项：点了就展示完整版能力 */
    const openBuy = () => {
      restoreCorner(); // 内容变高之前先贴角，否则会从半空往下长、顶出屏幕
      root.getElementById('buybox').classList.add('show');
      card.classList.add('expanded');
      setHint('');
    };
    root.getElementById('swAcc').addEventListener('click', openBuy);
    root.getElementById('advmore').addEventListener('click', openBuy);
    root.getElementById('verTip').addEventListener('click', openBuy);
    root.getElementById('hint').addEventListener('click', openBuy);
    root.getElementById('buyBtn').addEventListener('click', () => {
      const on = root.getElementById('buybox').classList.toggle('show');
      card.classList.toggle('expanded', on);
      restoreCorner(); // 收起来之后面板变矮，也要回到右下角，不能悬在上方
      if (on) setHint('');
    });
    root.querySelectorAll('.advbox input').forEach((el) => {
      el.parentElement.addEventListener('click', openBuy);
    });

    /* 复制群号 / 打开加群链接 */
    root.getElementById('qqCopy').addEventListener('click', async (e) => {
      e.stopPropagation();
      try {
        await navigator.clipboard.writeText(CONTACT.qq);
        e.target.textContent = '已复制';
        setTimeout(() => (e.target.textContent = '复制'), 1200);
      } catch (err) {
        window.prompt('手动复制', CONTACT.qq);
      }
    });
    root.getElementById('qqLink').addEventListener('click', () => {
      window.open(CONTACT.qqLink, '_blank');
    });

    /* 清空日志 */
    root.getElementById('clr').addEventListener('click', () => {
      const el = root.getElementById('log');
      if (el) el.innerHTML = '';
      logLine('日志已清空');
    });

    /* 拖动 */
    let dragging = false;
    let offX = 0;
    let offY = 0;
    const hd = root.querySelector('.hd');
    hd.addEventListener('mousedown', (e) => {
      if (e.target.tagName === 'BUTTON' || e.target.classList.contains('mini')) return;
      dragging = true;
      const r = host.getBoundingClientRect();
      offX = e.clientX - r.left;
      offY = e.clientY - r.top;
      e.preventDefault();
    });
    window.addEventListener('mousemove', (e) => {
      if (!dragging) return;
      const w = host.offsetWidth || 302;
      const h = host.offsetHeight || 200;
      let x = e.clientX - offX;
      let y = e.clientY - offY;
      x = Math.max(4, Math.min(x, innerWidth - w - 4));
      y = Math.max(4, Math.min(y, innerHeight - h - 4));
      host.style.left = x + 'px';
      host.style.top = y + 'px';
      host.style.right = 'auto';
      host.style.bottom = 'auto';
      cfg.x = x;
      cfg.y = y;
    });
    window.addEventListener('mouseup', () => {
      if (dragging) {
        dragging = false;
        saveCfg();
      }
    });

    /* 回到右下角：展开、收起、折叠都会改变高度，
       面板必须始终贴住右下角，不能因为变高变矮就悬在半空 */
    function restoreCorner() {
      if (!host) return;
      host.style.left = '';
      host.style.top = '';
      host.style.right = '16px';
      host.style.bottom = '16px';
      cfg.x = null;
      cfg.y = null;
      saveCfg();
    }

    /* 拖动过位置之后内容又变高：把底边夹回视口内，避免下半截看不见 */
    if (typeof ResizeObserver !== 'undefined') {
      try {
        new ResizeObserver(() => {
          if (!host || !host.style.top) return;
          const h = host.offsetHeight || 200;
          const y = parseFloat(host.style.top) || 0;
          const maxY = Math.max(4, innerHeight - h - 4);
          if (y > maxY) {
            host.style.top = maxY + 'px';
            cfg.y = maxY;
            saveCfg();
          }
        }).observe(card);
      } catch (e) {
        /* ignore */
      }
    }

    if (typeof cfg.x === 'number' && typeof cfg.y === 'number') {
      host.style.left = cfg.x + 'px';
      host.style.top = cfg.y + 'px';
      host.style.right = 'auto';
      host.style.bottom = 'auto';
    }

    renderSwitch();
    if (!cfg.on) setStatus('已暂停接管，视频需手动播放', 'warn');
  }

  /* 平台当前登录用户（只读 localStorage，不发请求） */
  function fillUser() {
    if (!ui.uname) return;
    let u = null;
    try {
      u = JSON.parse(localStorage.getItem('user') || 'null');
    } catch (e) {
      u = null;
    }
    if (u && u.name) {
      ui.uname.textContent = u.name;
      ui.avt.textContent = u.name.slice(0, 1);
      const acc = u.loginName || u.identityCardNum || '';
      ui.uacc.textContent = acc ? '平台已登录 · ' + acc : '平台已登录';
    } else {
      ui.uname.textContent = '未识别到账号';
      ui.avt.textContent = '?';
      ui.uacc.textContent = '请在平台登录后刷新';
    }
  }

  /* 场景化提示条：只在「用户正好卡住」的时候冒出来一句，平时不打扰 */
  function setHint(html) {
    if (!ui.hint) return;
    if (lastHint === (html || '')) return;
    lastHint = html || '';
    if (!html) {
      ui.hint.classList.remove('show');
      ui.hint.innerHTML = '';
      return;
    }
    ui.hint.innerHTML = html;
    ui.hint.classList.add('show');
  }

  /* 底部授权栏：用已切换节数制造「进度感」 */
  function updateLic() {
    if (!root) return;
    const el = root.getElementById('licTxt');
    if (!el) return;
    el.textContent = cfg.switched
      ? '精简版 · 已自动切换 ' + cfg.switched + ' 节'
      : '精简版 · 自动连播已启用';
    /* 切换节数变了，折叠胶囊也可能要跟着变（课件章节没有视频） */
    renderFoldProgress(getVideo());
  }

  let logCount = 0;
  function logLine(text) {
    if (!ui.log) return;
    const d = document.createElement('div');
    const t = new Date();
    const hh = String(t.getHours()).padStart(2, '0');
    const mm = String(t.getMinutes()).padStart(2, '0');
    const ss = String(t.getSeconds()).padStart(2, '0');
    d.textContent = '[' + hh + ':' + mm + ':' + ss + '] ' + text;
    ui.log.appendChild(d);
    logCount++;
    while (ui.log.children.length > 60) ui.log.removeChild(ui.log.firstChild);
    ui.log.scrollTop = ui.log.scrollHeight;
  }

  function renderSwitch() {
    if (!ui.dot) return;
    ui.dot.className = 'dot' + (cfg.on ? ' on' : '');
    const b = root.getElementById('sw');
    if (b) {
      b.textContent = cfg.on ? '暂停学习' : '开始学习';
      b.className = 'primary' + (cfg.on ? ' stop' : '');
    }
  }

  let statusTimer = null;
  function setStatus(text, kind) {
    if (!ui.st) return;
    ui.st.textContent = text;
    ui.st.className = 'status' + (kind ? ' ' + kind : '');
    if (statusTimer) clearTimeout(statusTimer);
    if (kind === 'ok') {
      statusTimer = setTimeout(() => {
        if (ui.st) ui.st.className = 'status';
      }, 4000);
    }
  }

  function showSkip(on) {
    if (!ui.skipBar) return;
    const want = !!on;
    if (ui.skipBar.classList.contains('show') !== want) {
      ui.skipBar.classList.toggle('show', want);
    }
  }

  /* 折叠成一条时，把进度挤进标题栏那颗小胶囊：
     有视频 → 「35%」（暂停时前面加 ⏸）；课件没视频 → 「已切 3 节」；都没有就不占位 */
  function renderFoldProgress(v) {
    if (!ui.fp) return;
    const dur = v && isFinite(v.duration) ? Math.floor(v.duration) : 0;
    let txt = '';
    let tip = '';
    if (dur) {
      const cur = Math.max(0, Math.floor(v.currentTime || 0));
      const p = Math.min(100, Math.round((cur / dur) * 100));
      const rest = Math.max(0, dur - cur);
      if (v.ended) {
        txt = p + '%';
        tip = '本节已播完（' + fmt(dur) + '）';
      } else {
        txt = (v.paused ? '暂停 ' : '') + p + '%';
        tip = '本节 ' + fmt(cur) + ' / ' + fmt(dur) +
          (v.paused ? '（已暂停）' : '') + ' · 还剩 ' + fmt(rest);
      }
    } else if (cfg.switched) {
      txt = '已切 ' + cfg.switched + ' 节';
      tip = '本次已自动切换 ' + cfg.switched + ' 节';
    }
    const on = !!txt;
    if (ui.fp.classList.contains('on') !== on) ui.fp.classList.toggle('on', on);
    if (ui.fp.textContent !== txt) ui.fp.textContent = txt;
    if (ui.fp.title !== tip) ui.fp.title = tip;
  }

  function renderProgress(v) {
    if (!ui.ch) return;
    renderFoldProgress(v);
    const title = currentChapterTitle();
    if (title) ui.ch.textContent = title;

    if (!v) {
      ui.pg.textContent = '—';
      ui.pb.style.width = '0%';
      ui.pc.textContent = '0%';
      if (ui.vol) ui.vol.style.display = 'none';
      return;
    }
    const cur = Math.floor(v.currentTime || 0);
    const dur = isFinite(v.duration) ? Math.floor(v.duration) : 0;
    ui.pg.textContent = dur ? fmt(cur) + ' / ' + fmt(dur) : fmt(cur) + ' / —';
    const p = dur ? Math.min(100, Math.round((cur / dur) * 100)) : 0;
    ui.pb.style.width = p + '%';
    ui.pc.textContent = p + '%' + (v.ended ? ' · 已播完' : v.paused ? ' · 已暂停' : '');
    if (ui.vol) {
      const muted = !!v.muted;
      ui.vol.style.display = '';
      ui.vol.textContent = muted ? '🔇' : '🔊';
      ui.vol.title = muted
        ? (userMuted ? '已静音（你设的）· 点一下打开声音'
                     : '浏览器不让自动出声，已先静音保证不停 · 点一下打开声音')
        : '有声 · 点一下静音';
      ui.vol.classList.toggle('mute', muted);
    }
  }

  function fmt(s) {
    s = Math.max(0, Math.round(s));
    const m = Math.floor(s / 60);
    const r = s % 60;
    return m + ':' + String(r).padStart(2, '0');
  }

  /* 当前章节标题：从页面标题或抽屉里「最近学习」那一项取 */
  function currentChapterTitle() {
    const h = document.querySelector('.ellipsis-title, nz-header h1, h1');
    if (h) {
      const t = (h.innerText || '').replace(/\s+/g, ' ').trim();
      if (t) return t.length > 18 ? t.slice(0, 18) + '…' : t;
    }
    const list = parseChapters();
    const r = list.find((c) => c.recent);
    if (r) return r.title.length > 18 ? r.title.slice(0, 18) + '…' : r.title;
    return '—';
  }

  /* ================= 主循环 ================= */
  let pageEnterAt = Date.now();
  let lastLoggedChapter = '';
  let lastSwitchAt = 0;
  let courseFinished = false; /* 本课程已学完，状态不再被后续 tick 覆盖 */
  let toldNoVideo = false;
  let noVideoAt = 0; /* 本节第一次确认「没有 video」的时间，用来区分「还在加载」和「确实是课件」 */
  let sawCountdown = false;
  let doneStreak = 0;
  let endHandled = false;
  let endedAt = 0; /* 视频播完的时刻：留出时间让平台把「已完成」上报发完 */

  async function tick() {
    if (!IS_TOP) {
      /* iframe 里的播放器：只管播放，播完通知顶层 */
      if (!cfg.on) return;
      const v = getVideo();
      if (v) {
        if (v.paused && !v.ended) await tryPlay(v);
        if (v.ended) {
          try {
            parent.postMessage({ __sdfFreeEnded: true }, '*');
          } catch (e) {
            /* ignore */
          }
        }
      }
      return;
    }

    /* host 丢了、被页面重渲染冲掉、或 shadow 内容被清空，就重建一次 */
    if (!host || !host.isConnected || !root || !root.getElementById('st')) buildPanel(true);

    /* 关键改动：不再用 display:none 隐藏面板。
       以前只要路径判定不上、视频又在 iframe 里，面板就整块消失，
       用户看到的就是「脚本没运行」。现在改成收成小胶囊，永远看得见。 */
    const here = isChapterPage() || !!getVideo();
    if (ui.card) ui.card.classList.toggle('capsule', !here);
    if (!here) {
      pageEnterAt = Date.now();
      doneStreak = 0;
      sawCountdown = false;
      endHandled = false;
      endedAt = 0;
      showSkip(false);
      if (!toldNoVideo) {
        toldNoVideo = true;
        setStatus('已运行，本页没有视频；打开课程播放页后自动接管');
        setHint('完整版可<b>从课程列表自动进入下一门</b>，不用手动点 ›');
      }
      return;
    }
    toldNoVideo = false;

    /* 已经学完就别再刷状态，否则「学完」提示会被下一次 tick 盖掉 */
    if (courseFinished) {
      showSkip(false);
      renderProgress(getVideo());
      return;
    }

    if (!cfg.on) {
      showSkip(false);
      renderProgress(getVideo());
      setHint('暂停期间视频不会动；<b>完整版可无人值守</b>，一门接一门往下学 ›');
      return;
    }

    const pErr = platformErrorText();
    if (pErr) {
      if (ui.dot) ui.dot.className = 'dot warn';
      /* 优先点名 5xx（那才是平台真挂），没有 5xx 才退回最近一条失败 */
      const five = netFails.filter((x) => x.s >= 500);
      const last = five.length ? five[five.length - 1] : netFails[netFails.length - 1] || null;
      if (last && last.s >= 400) {
        /* 知道是哪条接口挂的，就直接点名——用户截图比什么解释都清楚 */
        const path = last.u.split('?')[0];
        const line = '平台接口 ' + last.s + ' ' + (last.t || '') + '，不是脚本：' + last.m + ' ' + path;
        setStatus(line.length > 62 ? line.slice(0, 62) + '…' : line, 'warn');
      } else {
        setStatus('平台弹的「出错了」不是脚本问题：点关闭或刷新都行，本节进度已记录', 'warn');
      }
      showSkip(false);
      if (!window.__sdfErrLogged) {
        window.__sdfErrLogged = true;
        logLine('平台弹层：' + pErr + (last ? '｜最近失败 ' + last.m + ' ' + last.u + ' → ' + last.s : ''));
      }
      return;
    }
    window.__sdfErrLogged = false;

    if (hasConflict()) {
      showSkip(false);
      if (ui.dot) ui.dot.className = 'dot warn';
      setStatus('平台提示「同一活动多窗口」，请只留一个窗口', 'warn');
      setHint('完整版会<b>自动让其他窗口让位</b>，不会判学时作废 ›');
      return;
    }

    /* 随堂题：让用户自己答，答完自动继续 */
    if (hasQuiz()) {
      showSkip(false);
      if (ui.dot) ui.dot.className = 'dot warn';
      setStatus('检测到题目，请手动作答；答完会自动继续播放', 'warn');
      setHint('完整版可<b>自动作答并提交</b>，答错还会改对重交 ›');
      if (!window.__sdfQuizLogged) {
        window.__sdfQuizLogged = true;
        logLine('检测到题目，等待作答');
      }
      renderProgress(getVideo());
      return;
    }

    /* 接管中就是绿点：折叠成一条时，这颗点加右边那颗百分比是唯一能看出
       「还在跑」的信号；原来这里一律刷成灰的，看着像已经停了 */
    if (ui.dot) ui.dot.className = 'dot' + (cfg.on ? ' on' : '');

    const v = getVideo();
    if (!v) {
      if (!noVideoAt) noVideoAt = Date.now();
      const waited = Date.now() - noVideoAt;
      const fr = document.querySelectorAll('iframe').length;

      /* 刚进来那几秒视频可能还在加载，先不下结论 */
      if (waited < 6000) {
        if (ui.dot) ui.dot.className = 'dot';
        showSkip(false);
        setHint('');
        setStatus('正在识别本节内容…');
        renderProgress(null);
        return;
      }
      if (ui.dot) ui.dot.className = 'dot warn';

      /* 等了 6 秒还没有 video：这一节是课件 / 文档，平台不会自己往下走。
         精简版不替用户跳（那是完整版的能力），但必须给个按钮，
         否则看起来就是「卡住了、脚本坏了」。 */
      showSkip(true);
      setStatus('本节是课件（没有视频），需要你点一下才往下走', 'warn');
      /* 按钮右边已经写了「完整版会自动跳过」，这里只在有 iframe 时补充说明 */
      setHint(fr ? '页面上有 ' + fr + ' 个子框架，取不到播放器' : '');
      renderProgress(null);
      return;
    }
    noVideoAt = 0;
    showSkip(false);

    /* 前台正在播，但声音还停在后台那次的静音上：还回去。
       只在「没暂停」时做，避免和下面的 tryPlay 抢（救回来→静音→再救，来回闪）。 */
    if (!document.hidden && autoMuted && !v.paused && !v.ended) restoreSound('回到前台');

    if (v.paused && !v.ended) await tryPlay(v);
    renderProgress(v);

    /* 记住这一节播过：以后选「下一节」时，播过的一律不再回头 */
    {
      const t0 = currentTitleFromPage();
      if (t0) markVisited(t0);
    }

    /* 角标判定：只有先看到过「剩余时长」，才认后面的「已完成」，
       否则刚进页面残留的上一节角标会让人误以为这节已经学完。 */
    const txt = badgeText();
    if (txt.indexOf('剩余时长') >= 0) sawCountdown = true;
    const doneNow = txt.indexOf('已完成') >= 0;

    if (doneNow && sawCountdown) {
      if (!endHandled) {
        endHandled = true;
        markDoneHere();
        setHint('');
        setStatus('本节已标记完成，切换下一节…', 'ok');
        /* 3 秒：等平台把「学习完成」那条上报请求发完再切页。
           切太急会在请求在飞时把页面拆掉，Angular 会把被取消的请求
           抛成 status=0 的 HttpErrorResponse，页面上就弹「出错了 / Unknown Error」。 */
        await sleep(3000);
        await goNextChapter('本节已完成，切换下一节…');
      }
      return;
    }

    if (v.ended) {
      if (!endedAt) endedAt = Date.now();
      const waitedEnd = Date.now() - endedAt;
      /* 播完先别急着点下一节：平台自己要在这一刻上报学习进度、刷角标，
         有的课还会自己往下走。给它 8 秒（期间页面自己跳走就什么也不做），
         过了这个点还没动，脚本才接手。这是为了不掐断它正在发的请求。 */
      if (waitedEnd < 8000) {
        const left = Math.ceil((8000 - waitedEnd) / 1000);
        setStatus('本节播完，等平台记录完成（约 ' + left + ' 秒）…');
        return;
      }
      if (!endHandled) {
        endHandled = true;
        markDoneHere();
        setStatus('本节播完，切换下一节…', 'ok');
        await goNextChapter('本节播完，切换下一节…');
      }
      return;
    }

    doneStreak = 0;
    endedAt = 0;

    /* 刚进页面 8 秒内不判完成，给平台角标刷新的时间 */
    const waited = Date.now() - pageEnterAt;
    if (waited < 8000) {
      setStatus('已接管播放，正在等平台记录状态…');
      if (lastLoggedChapter !== (currentChapterTitle() || '')) {
        lastLoggedChapter = currentChapterTitle() || '';
        window.__sdfQuizLogged = false;
        logLine('开始播放：' + (lastLoggedChapter || '本节'));
      }
      return;
    }

    /* 兜底：角标一直只显示「已完成」、从未出现过「剩余时长」，
       且视频根本没动（currentTime < 2 秒）——说明这一节平台早就记过了，
       不切的话会一直卡在这里干等。给 18 秒观察期再判。
       刚切完 25 秒内不判：新页面角标是上一节残留的，容易连跳好几节。 */
    if (
      !sawCountdown &&
      doneNow &&
      (v.currentTime || 0) < 2 &&
      waited > 18000 &&
      Date.now() - lastSwitchAt > 25000
    ) {
      if (!endHandled) {
        endHandled = true;
        markDoneHere();
        setStatus('这一节平台已记为完成，切换下一节…', 'ok');
        await goNextChapter('本节早已完成，切换下一节…');
      }
      return;
    }

    setStatus(cfg.switched ? '正在播放 · 已自动切换 ' + cfg.switched + ' 节' : '正在播放');
    /* 刚切完 20 秒内提一次完整版能力，之后自动收起，避免每页都弹 */
    if (Date.now() - lastSwitchAt < 20000) {
      setHint('本节学完会自动切下一节；<b>完整版可跨课程连播</b>，一门接一门 ›');
    } else {
      setHint('');
    }
  }

  /* ================= 启动 ================= */
  try {
    console.log('[研修助手] 已注入 ' + location.href + ' | 顶层=' + IS_TOP);
  } catch (e) {
    /* ignore */
  }
  /* 1.4.9 之前折叠按钮没有对应样式，点了只记标记不改观感，
     历史状态可能是「折叠」——清一次，避免更新后一打开就是收起的 */
  if (!localStorage.getItem('sdf_free_fold_reset')) {
    cfg.folded = false;
    saveCfg();
    localStorage.setItem('sdf_free_fold_reset', '1');
  }

  buildPanel();
  updateLic();
  logLine('脚本已加载 · ' + location.hostname);

  /* 新用户不一定会注意到「完整版 ›」，第一次进播放页给一次入口提示 */
  if (!localStorage.getItem('sdf_free_seen')) {
    setTimeout(() => {
      if (!cfg.on || !getVideo()) return;
      if (ui.card && ui.card.classList.contains('capsule')) return;
      setHint('本节学完会自动切下一节 · 点右上「精简版」或底部「完整版」看还能做什么 ›');
      localStorage.setItem('sdf_free_seen', '1');
      setTimeout(() => setHint(''), 12000);
    }, 12000);
  }
  setInterval(() => {
    tick().catch(() => {});
  }, TICK);
  tick().catch(() => {});

  /* SPA 路由变化时重置判定窗口；换到另一门课则清掉本课程的已完成记录 */
  let lastHref = location.href;
  let lastCourse = courseId();
  setInterval(() => {
    if (location.href !== lastHref) {
      lastHref = location.href;
      pageEnterAt = Date.now();
      sawCountdown = false;
      doneStreak = 0;
      endHandled = false;
      endedAt = 0;
      lastTry = 0;
      courseFinished = false;
      noVideoAt = 0;
      const cur = courseId();
      if (cur !== lastCourse) {
        lastCourse = cur;
        doneTitles.clear();
        triedFail.clear();
        cooldownUntil = 0;
        cfg.switched = 0;
        lastLoggedChapter = '';
        saveCfg();
        initVisited();
      }
    }
  }, 800);

  /* 守护：不依赖主循环，面板一旦消失立刻补回来。
     主循环里任何一处异常都不该让面板永久消失。 */
  setInterval(() => {
    if (!IS_TOP) return;
    const h = document.getElementById('sdf-free-host');
    const ok = h && h.isConnected && h.shadowRoot && h.shadowRoot.getElementById('st');
    if (!ok) buildPanel(true);
  }, 1500);

  /* 视频全屏时把面板搬进全屏元素，退出再搬回来——
     否则 fixed 定位会被全屏层盖住，看起来就是「面板不见了」 */
  /* 视频被暂停就主动拉回来，不等主循环：
     切到别的窗口/别的标签页之后，平台常常自己把视频暂停，
     而后台的 setInterval 会被浏览器节流（时间一长只剩一分钟一拍），
     等 tick 来救就是几分钟的黑屏。挂到事件上，1.2 秒内就恢复。
     随堂题、平台报错、多窗口提示这几种「该停」的情况照旧不动。 */
  document.addEventListener('pause', async (e) => {
    const v = e.target;
    if (!v || v.tagName !== 'VIDEO') return;
    await sleep(1200);
    if (!v.isConnected || v.ended || !v.paused) return;
    if (!cfg.on) return;
    if (hasQuiz() || hasConflict() || platformErrorText()) return;
    lastTry = 0;
    await tryPlay(v);
  }, true);

  /* 切回前台：立刻把后台那次的临时静音还回去，并补跑一次主循环——
     后台标签页的定时器会被浏览器节流（久了只剩一分钟一次），
     切回来时进度/角标可能已经滞后，补一拍更跟手。 */
  document.addEventListener('visibilitychange', () => {
    if (document.hidden) return;
    try {
      restoreSound('切回前台', true);
      lastTry = 0;
      tick().catch(() => {});
    } catch (e) { /* ignore */ }
  });

  /* 用户在页面上真点了一下（真实手势）：这时候出声最稳，顺手把声音还回去 */
  document.addEventListener('pointerdown', (e) => {
    try {
      if (host && e.target === host) return; /* 面板里的按钮自己管自己的状态 */
    } catch (err) { /* ignore */ }
    restoreSound('你点了一下页面', true);
  }, true);

  document.addEventListener('fullscreenchange', () => {
    try {
      if (!host) return;
      const fs = document.fullscreenElement;
      if (fs) {
        if (!fs.contains(host) && fs.appendChild) fs.appendChild(host);
      } else if (host.parentNode !== document.documentElement) {
        document.documentElement.appendChild(host);
      }
    } catch (e) {
      /* ignore */
    }
  });

  /* 排查用：控制台执行 __sdfFreeInfo() 可看到当前状态 */
  window.__sdfFreeInfo = () => ({
    ver: VER,
    top: IS_TOP,
    here: isChapterPage(),
    hasVideo: !!getVideo(),
    hostInDom: !!document.getElementById('sdf-free-host'),
    shadowOk: !!(root && root.getElementById('st')),
    error: lastError || '(无)',
  });

  /* iframe 播放器播完 → 顶层切下一节 */
  window.addEventListener('message', (e) => {
    if (!e.data || !e.data.__sdfFreeEnded) return;
    if (!IS_TOP || !cfg.on) return;
    goNextChapter('iframe 播放结束，切换下一节…');
  });
})();