// ==UserScript==
// @name         人教培训(px.pep.com.cn) 回放课程收集与连播
// @namespace    tabbit/pep-px-replay
// @version      3.3.0
// @description  按报名信息中的学段/学科遍历课程，列出全部可"观看回放"的课程，一键选择连播（含 gensee 播放页自动续播；跨域名/iframe/中间页/取链错误自适应；Chrome 自动播放策略与跨域 iframe 专项加固）
// @author       ruziniujs
// @match        *://*/*
// 说明：这里故意用全站匹配。原因是不同学科的"观看回放"可能跳到展视互动
// (gensee.com / gensee.cn / gensee.com.cn / csslcloud.net) 或其他机构自有域名，
// 枚举不完。脚本内部有严格闸门：只有处于"连播进行中"状态才会去接管页面，
// 平时在无关网站上完全不显示面板、不注册任何监听。
// @run-at       document-idle
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_deleteValue
// @noframes
// ==/UserScript==

(function () {
  'use strict';

  const VERSION = '3.3.0';
  const NS = 'pep_px_replay_v2';

  // 站点已确认的默认值（页面下拉框缺失时兜底）
  const DEFAULT_STAGES = [{ v: '3', t: '小学' }, { v: '4', t: '初中' }, { v: '5', t: '高中' }];
  const DEFAULT_SIDS = [
    { v: '18', t: '数学' }, { v: '6', t: '英语' }, { v: '13', t: '音乐' }, { v: '11', t: '美术' },
    { v: '7', t: '物理' }, { v: '8', t: '化学' }, { v: '9', t: '生物学' }, { v: '10', t: '地理' },
    { v: '34', t: '日语' }, { v: '35', t: '俄语' }, { v: '12', t: '体育与健康' }, { v: '93', t: '信息科技' },
    { v: '129', t: '特殊教育' }
  ];

  const CFG = {
    panelId: 'pep-px-replay-panel',
    concurrency: 5,
    videoWaitMs: 30000,
    stallMs: 120000,
    // 播放页迟迟找不到 video 时的提示阈值
    hintMs: 20000,
    // 落在列表页/错误页且找不到 video 时，多久后自动跳到下一门
    wrongPageSkipMs: 25000,
    // 中间页自动点击最多尝试次数（同一页面）
    maxHop: 3,
    // 轮询间隔（Chrome 后台标签页会被节流，配合事件唤醒使用）
    tickMs: 2500,
    // 发现播放器被嵌在 iframe 里，等待多久后把它提升为顶层页面
    iframePromoteMs: 6000,
    // 硬性看门狗：任何页面停留超过该秒数仍无有效播放，强制跳到下一门（Chrome 兜底）
    hardStuckSec: 100,
    // 找到 video 但一直无法开始播放，超过该秒数视为失败并计入看门狗
    playStartTimeoutSec: 60
  };

  // 展视互动（Gensee）及其播放器常用域名，任一命中都视为"播放页"
  const GENSEE_RE = /(^|\.)(gensee\.com|gensee\.cn|gensee\.com\.cn|gensee\.net|csslcloud\.net|263\.net)$/i;

  /* --------------------------------------------------------------- 存取 */
  const store = {
    cache: Object.create(null),
    get(k, d) {
      const id = NS + ':' + k;
      if (id in this.cache) return this.cache[id];
      try {
        if (typeof GM_getValue === 'function') {
          const v = GM_getValue(id);
          if (v !== undefined && v !== null) return v;
        }
      } catch (e) {}
      try {
        const raw = localStorage.getItem(id);
        return raw ? JSON.parse(raw) : d;
      } catch (e) { return d; }
    },
    // 普通写入：立即返回，用于界面状态等不跨页面的数据
    set(k, v) {
      const id = NS + ':' + k;
      this.cache[id] = v;
      try {
        if (typeof GM_setValue === 'function') { GM_setValue(id, v); return; }
      } catch (e) {}
      try { localStorage.setItem(id, JSON.stringify(v)); } catch (e) {}
    },
    /*
     * 关键写入：Chrome 版 Tampermonkey(MV3) 的 GM_setValue 是异步投递到后台的，
     * 写完立刻 location.href 跳转，新页面很可能读不到 —— 这正是"Chrome 里只播
     * 第一门、之后接不上"的根因。这里等到真正落盘（并回读校验）再跳转。
     */
    async setSync(k, v) {
      const id = NS + ':' + k;
      this.cache[id] = v;
      const ok = (x) => x && typeof x === 'object' &&
        x.active === v.active && x.index === v.index &&
        Array.isArray(x.queue) && v.queue && x.queue.length === v.queue.length;

      try {
        if (typeof GM_setValue === 'function') await Promise.resolve(GM_setValue(id, v));
      } catch (e) {}
      try { localStorage.setItem(id, JSON.stringify(v)); } catch (e) {}

      for (let i = 0; i < 20; i++) {
        let got = null;
        try { if (typeof GM_getValue === 'function') got = GM_getValue(id); } catch (e) {}
        if (!ok(got)) {
          try {
            const raw = localStorage.getItem(id);
            if (raw) got = JSON.parse(raw);
          } catch (e) {}
        }
        if (ok(got)) return true;
        // 还没落地就再写一次（部分版本首写会被丢弃）
        try { if (typeof GM_setValue === 'function') GM_setValue(id, v); } catch (e) {}
        await sleep(100);
      }
      return false;
    }
  };

  // 兼容旧调用名的同步写
  const setPlaySync = (s) => store.setSync('play', s);

  /* --------------------------------------------------------------- 工具 */
  const sleep = (ms) => new Promise(r => setTimeout(r, ms));
  const clean = (s) => (s || '').replace(/[\s\u00a0\u3000]+/g, ' ').trim();
  const esc = (s) => String(s == null ? '' : s).replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));

  const isPepListPage = () => /(^|\.)pep\.com\.cn$/i.test(location.hostname) && /\/px\/index\//i.test(location.href);
  const isPepPage = () => /(^|\.)pep\.com\.cn$/i.test(location.hostname);
  const isGenseePage = () => GENSEE_RE.test(location.hostname);

  /* ------------------------------------------------------- 活动ID（多站点适配） */
  // 支持 /px/index/187、/px/entryRoom/187/15330/2、/user/showInfo/187 等形态
  function getActId() {
    const m = location.href.match(/\/px(?:com)?\/[a-zA-Z]+\/(\d+)/i) || location.href.match(/\/user\/[a-zA-Z]+\/(\d+)/i);
    if (m && m[1]) {
      store.set('lastAct', m[1]);
      return m[1];
    }
    return store.get('lastAct', '') || '';
  }

  const regUrl = () => `/web/index.php?/user/showInfo/${getActId()}`;
  const listUrl = (sid, stage) => `/web/index.php?/px/index/${getActId()}/${sid}/${stage}`;

  // 按活动ID隔离课程列表与报名信息
  const itemsKey = () => 'items:' + getActId();
  const regKey = () => 'reg:' + getActId();
  const getItems = () => store.get(itemsKey(), []);
  const setItems = (arr) => store.set(itemsKey(), arr);

  /* =========================================================== 列表页解析 */
  function readStages() {
    const sel = document.getElementById('stage');
    if (sel && sel.options && sel.options.length) {
      return Array.from(sel.options).map(o => ({ v: o.value, t: clean(o.text) })).filter(x => x.v !== '');
    }
    return DEFAULT_STAGES.slice();
  }

  function readSids() {
    const sel = document.getElementById('sid');
    if (sel && sel.options && sel.options.length) {
      return Array.from(sel.options).map(o => ({ v: o.value, t: clean(o.text) })).filter(x => x.v !== '');
    }
    return DEFAULT_SIDS.slice();
  }

  // 站点标记可观看回放的按钮图片
  const REPLAY_IMG_RE = /btn_gkhf|gkhf|replay/i;

  const imgSrcOf = (el) => Array.from((el || document).querySelectorAll('img')).map(i => i.getAttribute('src') || '');

  /*
   * 【修复 4】取链更精准：
   * 原来是对整格取第一个 <a>，如果格子里先有"课程介绍""文件下载"等链接，
   * 就会把非播放链接存进队列，跳过去之后自然接不上。
   * 现在优先取"自身携带回放按钮图标"的那个链接，其次取文本含回放/观看的链接，
   * 最后才退回第一个链接。
   */
  function pickReplayAnchor(cell) {
    const links = Array.from(cell.querySelectorAll('a[href]'));
    if (!links.length) return null;

    const byImg = links.find(a => imgSrcOf(a).some(s => REPLAY_IMG_RE.test(s)));
    if (byImg) return byImg;

    const byText = links.find(a => /回放|观看|进入|播放/.test(clean(a.textContent)));
    if (byText) return byText;

    const byTitle = links.find(a => /回放|观看|play|replay|entry/i.test(a.getAttribute('title') || a.getAttribute('href') || ''));
    if (byTitle) return byTitle;

    return links[0];
  }

  function parseCourses(html, pageUrl) {
    const doc = new DOMParser().parseFromString(html, 'text/html');
    const rows = Array.from(doc.querySelectorAll('.con_table_pxkc_gztb2020b table tr'));
    const out = [];
    let lastName = '';
    for (const tr of rows) {
      const cell = tr.querySelector('td.txt_pxrk');
      if (!cell) continue;
      const h4 = tr.querySelector('td.txt_pxkc_xk h4');
      if (h4 && clean(h4.textContent)) lastName = clean(h4.textContent);

      const a = pickReplayAnchor(cell);
      const imgs = imgSrcOf(cell);
      // 有回放图标，或链接本身指向回放入口，才认为可观看
      const hasReplayImg = imgs.some(s => REPLAY_IMG_RE.test(s));
      const hasReplayLink = !!a && /回放|观看|进入|播放|play|replay|entry/i.test(
        (a.getAttribute('href') || '') + ' ' + (a.getAttribute('title') || '') + ' ' + clean(a.textContent)
      );
      if (!hasReplayImg && !hasReplayLink) continue;
      if (!a) continue;

      const title = clean((tr.querySelector('td.txt_pxkc_pxxx h6') || {}).textContent);
      if (!title) continue;
      const time = clean((tr.querySelector('.showtime_lesson') || {}).textContent);
      const spans = Array.from(tr.querySelectorAll('td.txt_pxkc_pxxx p span'))
        .map(s => clean(s.textContent)).filter(Boolean);
      let href = a.getAttribute('href') || '';
      try { href = new URL(href, pageUrl).href; } catch (e) {}

      out.push({ subjectLabel: lastName, title, time, extra: spans.join(' | '), entryUrl: href });
    }
    return out;
  }

  /* --------------------------------------------------- 报名信息（学段/学科） */

  // 从报名信息页面 HTML 解析已选学段×学科组合
  function parseRegistrationPairs(html) {
    const doc = new DOMParser().parseFromString(html, 'text/html');
    const selects = Array.from(doc.querySelectorAll('select'));
    const pairs = [];
    let curStage = null;

    for (const s of selects) {
      const name = (s.getAttribute('name') || '').toLowerCase();
      const v = s.value;
      const opt = s.selectedIndex >= 0 ? s.options[s.selectedIndex] : null;
      const text = opt ? clean(opt.text) : '';

      if (name.indexOf('stage') === 0) {
        curStage = (v && v !== '0' && text) ? { v, t: text } : null;
      } else if (name.indexOf('sid') === 0) {
        const sid = (v && v !== '0' && text) ? { v, t: text } : null;
        if (curStage && sid) pairs.push({ stage: curStage, sid });
        curStage = null;
      }
    }

    const seen = new Set();
    const out = [];
    for (const p of pairs) {
      const k = p.stage.v + '|' + p.sid.v;
      if (seen.has(k)) continue;
      seen.add(k);
      out.push(p);
    }
    return out;
  }

  async function fetchRegistrationPairs() {
    // 当前就在报名信息页时，直接解析当前文档，避免额外请求
    if (/\/user\/showInfo\//i.test(location.href)) {
      const p = parseRegistrationPairs(document.documentElement.outerHTML);
      if (p.length) return { pairs: p, source: 'current' };
    }
    try {
      const r = await fetch(location.origin + regUrl(), { credentials: 'include' });
      const html = await r.text();
      if (/请您先登录/.test(html)) return { pairs: [], source: 'login' };
      return { pairs: parseRegistrationPairs(html), source: 'showInfo' };
    } catch (e) {
      return { pairs: [], source: 'error' };
    }
  }

  /* ============================================================ 扫描主流程 */
  let scanning = false;

  async function scanAll() {
    if (scanning) return { ok: false, error: '扫描进行中' };
    scanning = true;
    try {
      const origin = location.origin;

      // 以报名信息为准：只遍历已报名的学段×学科
      setStatus('正在读取报名信息（学段/学科）…');
      const reg = await fetchRegistrationPairs();
      const onlyReg = ui && ui.els.onlyReg ? ui.els.onlyReg.checked : true;
      let regLabel = '';
      if (reg.pairs.length) {
        regLabel = reg.pairs.map(p => p.stage.t + p.sid.t).join('、');
        store.set(regKey(), { pairs: reg.pairs, source: reg.source, at: Date.now() });
      }

      const tasks = [];
      if (reg.pairs.length && onlyReg) {
        for (const p of reg.pairs) tasks.push({ st: p.stage, sd: p.sid });
      } else {
        // 无报名信息或用户关闭了"仅报名"时，回退为全站遍历
        const stages = readStages();
        const sids = readSids();
        for (const st of stages) for (const sd of sids) tasks.push({ st, sd });
      }

      if (reg.pairs.length && onlyReg) {
        setStatus(`报名学段学科：${regLabel}（共 ${tasks.length} 个组合），开始遍历…`);
      } else if (reg.pairs.length) {
        setStatus(`未勾选"仅报名"，全站遍历 ${tasks.length} 个组合…`);
      } else {
        setStatus(`未读取到报名信息，回退全站遍历 ${tasks.length} 个组合…`);
      }

      const map = new Map();
      const seenDup = new Set();
      let done = 0, idx = 0, loginBlocked = false;

      const worker = async () => {
        while (idx < tasks.length) {
          const t = tasks[idx++];
          const url = origin + listUrl(t.sd.v, t.st.v);
          try {
            const r = await fetch(url, { credentials: 'include' });
            const html = await r.text();
            if (/请您先登录/.test(html)) { loginBlocked = true; }
            else {
              for (const c of parseCourses(html, url)) {
                const key = c.entryUrl || (c.subjectLabel + '|' + c.title);
                // 同名同时间的记录（不同学段下重复挂载）视为同一门课，避免重复播放
                const dupKey = clean(c.title) + '@' + clean(c.time);
                if (map.has(key) || seenDup.has(dupKey)) continue;
                seenDup.add(dupKey);
                if (!map.has(key)) {
                  map.set(key, {
                    id: key,
                    title: c.title,
                    entryUrl: c.entryUrl,
                    stageOpt: t.st.t,
                    sidOpt: t.sd.t,
                    subjectLabel: c.subjectLabel || (t.st.t + t.sd.t),
                    time: c.time,
                    extra: c.extra,
                    disabled: false
                  });
                }
              }
            }
          } catch (e) {
            // 单个组合失败不影响整体
          }
          done++;
          if (done % 5 === 0 || done === tasks.length) {
            setStatus(`扫描中 ${done}/${tasks.length} —— 已发现 ${map.size} 门可回放课程`);
            renderList(Array.from(map.values()));
          }
        }
      };

      await Promise.all(Array.from({ length: Math.min(CFG.concurrency, tasks.length) }, worker));

      const items = Array.from(map.values());
      setItems(items);
      renderList(items);
      if (loginBlocked) {
        setStatus(`扫描完成但存在登录限制：共 ${items.length} 门。若数量偏少请确认已登录`);
      } else {
        setStatus(`扫描完成：${tasks.length} 个页面中找到 ${items.length} 门可回放课程`);
      }
      return { ok: true, count: items.length };
    } finally {
      scanning = false;
    }
  }

  /* ================================================================ 面板 UI */
  let ui = null;

  function ensurePanel() {
    if (ui && ui.host && ui.host.isConnected) return ui;
    const old = document.getElementById(CFG.panelId);
    if (old) old.remove();

    const host = document.createElement('div');
    host.id = CFG.panelId;
    host.style.cssText = 'position:fixed;z-index:2147483600;top:70px;right:12px;width:390px;';
    const root = host.attachShadow({ mode: 'open' });
    root.innerHTML = `
      <style>
        :host { all: initial; }
        .box { background:#1f2430; color:#e6e9ef; border:1px solid #3a4256; border-radius:10px;
               box-shadow:0 10px 30px rgba(0,0,0,.4); font:13px/1.45 system-ui,-apple-system,"Microsoft YaHei",sans-serif; overflow:hidden; }
        .hd { display:flex; align-items:center; gap:6px; padding:8px 10px; background:#2a3140; cursor:move; user-select:none; }
        .hd b { flex:1; font-size:13px; font-weight:600; }
        .hd .ver { color:#8b95a8; font-size:11px; }
        .hd button { background:transparent; border:0; color:#c3cad8; cursor:pointer; padding:2px 6px; font-size:13px; }
        .bd { padding:9px 10px 10px; }
        .bd.hide { display:none; }
        .st { color:#9fb0c8; font-size:12px; min-height:32px; margin-bottom:7px; line-height:1.35; word-break:break-all; }
        .row2 { display:flex; gap:6px; flex-wrap:wrap; margin-bottom:8px; }
        .btn { background:#3b82f6; color:#fff; border:0; border-radius:6px; padding:6px 10px; cursor:pointer; font-size:12px; }
        .btn.g { background:#4b5563; } .btn.r { background:#dc2626; } .btn.y { background:#b45309; }
        .btn:disabled { opacity:.45; cursor:not-allowed; }
        .opt { display:flex; align-items:center; gap:10px; color:#aab4c5; font-size:12px; margin-bottom:7px; flex-wrap:wrap; }
        .opt select { background:#2a3140; color:#e6e9ef; border:1px solid #3a4256; border-radius:4px; font-size:12px; }
        .cnt { color:#f59e0b; font-weight:600; }
        .now { color:#34d399; font-size:12px; margin-bottom:6px; min-height:16px; word-break:break-all; }
        .dbg { color:#6b7280; font-size:11px; margin-bottom:6px; word-break:break-all; }
        .log { color:#8b95a8; background:#171b24; border:1px solid #2f3646; border-radius:4px;
               font:10px/1.4 ui-monospace,Consolas,monospace; padding:4px 6px; margin:0 0 7px;
               max-height:72px; overflow:auto; white-space:pre-wrap; word-break:break-all; }
        .log:empty { display:none; }
        .warn { color:#fbbf24; font-size:11px; margin-bottom:6px; word-break:break-all; min-height:0; }
        .list { max-height:42vh; overflow:auto; border-top:1px solid #333b4d; padding-top:6px; }
        .grp { color:#7dd3fc; font-size:12px; margin:7px 0 3px; font-weight:600; display:flex; align-items:center; gap:5px; }
        .row { display:flex; gap:6px; align-items:flex-start; padding:3px 2px; border-bottom:1px dashed #2f3646; }
        .row .t { flex:1; word-break:break-all; cursor:pointer; }
        .row .m { color:#7d8798; font-size:11px; display:block; }
        .cur { background:#243447; }
        .empty { color:#8b95a8; text-align:center; padding:12px 0; }
        .btn.sm { padding:4px 8px; font-size:11px; }
        .selbar { display:flex; gap:5px; flex-wrap:wrap; margin-bottom:7px; }
        .row .mini { background:#374151; color:#cbd5e1; border:0; border-radius:4px; padding:1px 7px;
                     font-size:11px; cursor:pointer; flex:0 0 auto; line-height:16px; }
        .row .mini:hover { background:#4b5563; }
        .row .mini.playing { background:#059669; color:#fff; }
        .chk { display:flex; align-items:center; gap:4px; }
      </style>
      <div class="box">
        <div class="hd">
          <b>人教培训 · 回放收集/连播</b><span class="ver">v${VERSION}</span>
          <button data-act="fold" title="折叠">▾</button>
          <button data-act="close" title="隐藏">✕</button>
        </div>
        <div class="bd">
          <div class="st" data-el="status">就绪</div>
          <div class="now" data-el="now"></div>
          <div class="warn" data-el="warn"></div>
          <div class="reg" data-el="reginfo" style="color:#93c5fd;font-size:11px;margin-bottom:6px;word-break:break-all;"></div>
          <div class="dbg" data-el="dbg"></div>
          <pre class="log" data-el="log"></pre>
          <div class="row2">
            <button class="btn" data-act="scan">扫描报名学段/学科</button>
            <button class="btn" data-act="play">播放选中</button>
            <button class="btn y" data-act="skip">跳过本课</button>
            <button class="btn r" data-act="stop">停止</button>
            <button class="btn g" data-act="copy">复制列表</button>
            <button class="btn g" data-act="diag">复制诊断</button>
          </div>
          <div class="selbar">
            <button class="btn g sm" data-act="all">全选</button>
            <button class="btn g sm" data-act="none">全不选</button>
            <button class="btn g sm" data-act="invert">反选</button>
            <label class="chk" title="按报名信息中的学段/学科遍历"><input type="checkbox" data-el="onlyReg" checked> 仅报名学段/学科</label>
          </div>
          <div class="opt">
            <span>已选 <span class="cnt" data-el="selcount">0</span> / 共 <span class="cnt" data-el="count">0</span> 门</span>
            <label><input type="checkbox" data-el="mute" checked> 静音</label>
            <label>倍速
              <select data-el="rate">
                <option value="1">1.0x</option>
                <option value="1.25">1.25x</option>
                <option value="1.5">1.5x</option>
                <option value="2">2.0x</option>
                <option value="3">3.0x</option>
              </select>
            </label>
          </div>
          <div class="list" data-el="list"><div class="empty">点击「扫描报名学段/学科」</div></div>
        </div>
      </div>`;
    (document.body || document.documentElement).appendChild(host);

    const q = (s) => root.querySelector(s);
    ui = {
      host,
      els: {
        status: q('[data-el=status]'), now: q('[data-el=now]'), count: q('[data-el=count]'),
        list: q('[data-el=list]'), mute: q('[data-el=mute]'), rate: q('[data-el=rate]'), body: q('.bd'),
        selcount: q('[data-el=selcount]'), playBtn: q('[data-act=play]'), onlyReg: q('[data-el=onlyReg]'),
        regInfo: q('[data-el=reginfo]'), dbg: q('[data-el=dbg]'), warn: q('[data-el=warn]'),
        log: q('[data-el=log]')
      }
    };

    root.addEventListener('click', (ev) => {
      const el = ev.target.closest('[data-act]');
      if (!el) return;
      const act = el.getAttribute('data-act');
      if (act === 'fold') {
        ui.els.body.classList.toggle('hide');
        el.textContent = ui.els.body.classList.contains('hide') ? '▸' : '▾';
      } else if (act === 'close') {
        host.style.display = 'none';
        setTimeout(() => { host.style.display = ''; }, 400);
      } else if (act === 'scan') {
        if (isPepListPage()) scanAll();
        else setStatus('请在课程学习列表页（/px/index/）使用扫描');
      } else if (act === 'play') {
        startPlayback();
      } else if (act === 'skip') {
        advance('manual-skip');
      } else if (act === 'all') {
        setAllSelected(true);
      } else if (act === 'none') {
        setAllSelected(false);
      } else if (act === 'invert') {
        invertSelected();
      } else if (act === 'stop') {
        stopPlayback();
      } else if (act === 'copy') {
        const items = getItems();
        const txt = items.map((it, i) => `${i + 1}. [${it.stageOpt}${it.sidOpt}] ${it.title}${it.time ? ' (' + it.time + ')' : ''}\n${it.entryUrl}`).join('\n');
        try { navigator.clipboard.writeText(txt); setStatus('已复制 ' + items.length + ' 条到剪贴板'); }
        catch (e) { setStatus('复制失败，请手动选择列表'); }
      } else if (act === 'diag') {
        copyDiagnostics();
      }
    });

    const hd = root.querySelector('.hd');
    let drag = null;
    hd.addEventListener('mousedown', (e) => {
      if (e.target.closest('button')) return;
      const r = host.getBoundingClientRect();
      drag = { dx: e.clientX - r.left, dy: e.clientY - r.top };
      e.preventDefault();
    });
    window.addEventListener('mousemove', (e) => {
      if (!drag) return;
      host.style.left = Math.max(0, e.clientX - drag.dx) + 'px';
      host.style.top = Math.max(0, e.clientY - drag.dy) + 'px';
      host.style.right = 'auto';
    });
    window.addEventListener('mouseup', () => { drag = null; });

    return ui;
  }

  function setStatus(msg) { if (ui && ui.els.status) ui.els.status.textContent = msg; }
  function setNow(msg) { if (ui && ui.els.now) ui.els.now.textContent = msg || ''; }
  function setWarn(msg) { if (ui && ui.els.warn) ui.els.warn.textContent = msg || ''; }

  /* --------------------------------------------------------- 自诊断日志 */
  // Chrome 与 Edge 行为不一致时，靠这段日志定位"卡在哪一步"
  const diagLog = [];

  function setLog(msg) {
    if (!msg) return;
    const t = new Date().toLocaleTimeString('zh-CN', { hour12: false });
    const line = `${t} ${msg}`;
    diagLog.push(line);
    if (diagLog.length > 60) diagLog.shift();
    if (ui && ui.els.log) {
      ui.els.log.textContent = diagLog.slice(-6).join('\n');
    }
    try { console.log('[PEP连播]', line); } catch (e) {}
  }

  // 生成可复制的诊断快照，用户贴回来即可定位问题
  function buildDiagnostics() {
    const st = getPlay() || {};
    const cur = st.queue && st.queue[st.index] ? st.queue[st.index] : {};
    let vids = [];
    try { collectVideos(document, vids, 0); } catch (e) {}
    const v = pickVideo();
    const frames = Array.from(document.querySelectorAll('iframe,frame')).map(f => {
      let cross = false;
      try { void f.contentDocument; } catch (e) { cross = true; }
      const r = f.getBoundingClientRect();
      return `${cross ? '跨域' : '同源'} ${Math.round(r.width)}x${Math.round(r.height)} ${(f.getAttribute('src') || '').slice(0, 90)}`;
    });

    const lines = [
      `脚本版本：${VERSION}`,
      `时间：${new Date().toISOString()}`,
      `当前地址：${location.href}`,
      `域名：${location.hostname} ｜ 页面类型：${kindOfPage()}`,
      `连播状态：active=${!!st.active} index=${st.index}/${st.queue ? st.queue.length : 0}`,
      `当前课程：${cur.title || '(无)'}`,
      `课程链接：${cur.entryUrl || '(无)'}`,
      `video 元素数：${vids.length} ｜ 可播放候选：${v ? '有' : '无'}`,
      v ? `播放器状态：paused=${v.paused} ended=${v.ended} muted=${v.muted} readyState=${v.readyState} currentTime=${Math.round(v.currentTime)} duration=${isFinite(v.duration) ? Math.round(v.duration) : 'NaN'} rate=${v.playbackRate} src=${(v.currentSrc || v.src || '').slice(0, 90)}` : '播放器状态：(无)',
      `停留时长：${Math.round((Date.now() - (playCtx.since || Date.now())) / 1000)}s ｜ 轮询次数：${playCtx.tries || 0}`,
      `iframe(${frames.length})：`,
      ...frames.slice(0, 6).map(f => '  - ' + f),
      `cookieEnabled=${navigator.cookieEnabled}`,
      '',
      '—— 日志 ——',
      ...diagLog.slice(-25)
    ];
    return lines.join('\n');
  }

  async function copyDiagnostics() {
    const text = buildDiagnostics();
    try {
      await navigator.clipboard.writeText(text);
      setStatus('诊断信息已复制，可直接粘贴反馈');
    } catch (e) {
      // 剪贴板被拒时退回旧接口
      try {
        const ta = document.createElement('textarea');
        ta.value = text;
        ta.style.cssText = 'position:fixed;left:-9999px;';
        document.body.appendChild(ta);
        ta.select();
        document.execCommand('copy');
        ta.remove();
        setStatus('诊断信息已复制（兼容模式）');
      } catch (e2) {
        setStatus('复制失败，请手动查看面板日志');
      }
    }
    setLog('已生成诊断快照');
    return text;
  }

  // 调试行：显示当前页面类型与域名，方便判断"第二学科是否没被接管"
  function setDbg(msg) {
    if (!ui || !ui.els.dbg) return;
    const k = kindOfPage();
    ui.els.dbg.textContent = `页面类型：${k} ｜ 域名：${location.hostname}` + (msg ? ' ｜ ' + msg : '');
  }

  function groupKeyOf(it) {
    return it.subjectLabel || ([it.stageOpt, it.sidOpt].filter(Boolean).join(' ') || '未分组');
  }

  function getSelCount() {
    return getItems().filter(i => i.entryUrl && !i.disabled).length;
  }

  function updateSelCount() {
    if (!ui) return;
    const all = getItems();
    const sel = all.filter(i => i.entryUrl && !i.disabled).length;
    if (ui.els.selcount) ui.els.selcount.textContent = sel;
    if (ui.els.count) ui.els.count.textContent = all.length;
    if (ui.els.playBtn) {
      ui.els.playBtn.disabled = sel === 0;
      ui.els.playBtn.textContent = sel ? `播放选中 (${sel})` : '播放选中';
    }
  }

  function syncCheckboxes() {
    if (!ui || !ui.els.list) return;
    const all = getItems();
    ui.els.list.querySelectorAll('input[type=checkbox][data-id]').forEach(cb => {
      const it = all.find(x => x.id === cb.getAttribute('data-id'));
      if (it) cb.checked = !it.disabled;
    });
    // 分组复选框的选中/半选状态
    ui.els.list.querySelectorAll('input[type=checkbox][data-grp]').forEach(gcb => {
      const g = gcb.getAttribute('data-grp');
      const arr = all.filter(i => i.entryUrl && groupKeyOf(i) === g);
      const on = arr.filter(i => !i.disabled).length;
      gcb.checked = arr.length > 0 && on === arr.length;
      gcb.indeterminate = on > 0 && on < arr.length;
    });
    updateSelCount();
  }

  function applySelection(fn) {
    const all = getItems();
    fn(all);
    setItems(all);
    syncCheckboxes();
  }

  function setAllSelected(on) {
    applySelection(all => { all.forEach(it => { if (it.entryUrl) it.disabled = !on; }); });
    setStatus(on ? `已全选 ${getSelCount()} 门` : '已全部取消选择');
  }

  function invertSelected() {
    applySelection(all => { all.forEach(it => { if (it.entryUrl) it.disabled = !it.disabled; }); });
    setStatus(`已反选，当前选中 ${getSelCount()} 门`);
  }

  function toggleGroup(g, on) {
    applySelection(all => {
      all.forEach(it => { if (it.entryUrl && groupKeyOf(it) === g) it.disabled = !on; });
    });
    setStatus(`分组「${g}」${on ? '全选' : '全不选'}`);
  }

  function renderList(items) {
    if (!ui) return;
    ui.els.count.textContent = items.length;
    const box = ui.els.list;
    if (!items.length) {
      box.innerHTML = '<div class="empty">暂无条目</div>';
      updateSelCount();
      return;
    }

    const st = store.get('play', null);
    const curId = st && st.active && st.queue && st.queue[st.index] ? st.queue[st.index].id : '';

    const groups = new Map();
    for (const it of items) {
      const g = groupKeyOf(it);
      if (!groups.has(g)) groups.set(g, []);
      groups.get(g).push(it);
    }
    let html = '';
    for (const [g, arr] of groups) {
      const playable = arr.filter(i => i.entryUrl);
      const on = playable.filter(i => !i.disabled).length;
      const allOn = playable.length > 0 && on === playable.length;
      html += `<div class="grp">
        <input type="checkbox" data-grp="${esc(g)}" ${allOn ? 'checked' : ''}>
        <span>${esc(g)} · ${arr.length} 门</span>
      </div>`;
      for (const it of arr) {
        html += `<div class="row ${it.id === curId ? 'cur' : ''}">
          <input type="checkbox" data-id="${esc(it.id)}" ${it.disabled ? '' : 'checked'}>
          <span class="t" title="${esc(it.title)}">${esc(it.title)}
            <span class="m">${esc(it.time || '')}</span>
          </span>
          <button class="mini ${it.id === curId ? 'playing' : ''}" data-play="${esc(it.id)}" title="从此处播放">▶</button>
        </div>`;
      }
    }
    box.innerHTML = html;

    // 单条勾选
    box.querySelectorAll('input[type=checkbox][data-id]').forEach(cb => {
      cb.addEventListener('change', () => {
        applySelection(all => {
          const t = all.find(x => x.id === cb.getAttribute('data-id'));
          if (t) t.disabled = !cb.checked;
        });
      });
    });

    // 点击标题也能切换勾选
    box.querySelectorAll('.row .t').forEach(sp => {
      sp.addEventListener('click', () => {
        const cb = sp.parentElement.querySelector('input[type=checkbox][data-id]');
        if (!cb) return;
        cb.checked = !cb.checked;
        cb.dispatchEvent(new Event('change'));
      });
    });

    // 分组复选（半选状态用 indeterminate 表示）
    box.querySelectorAll('input[type=checkbox][data-grp]').forEach(gcb => {
      const g = gcb.getAttribute('data-grp');
      const all = getItems();
      const arr = all.filter(i => i.entryUrl && groupKeyOf(i) === g);
      const on = arr.filter(i => !i.disabled).length;
      gcb.indeterminate = on > 0 && on < arr.length;
      gcb.addEventListener('change', () => toggleGroup(g, gcb.checked));
    });

    // 行内「从此处播放」
    box.querySelectorAll('[data-play]').forEach(btn => {
      btn.addEventListener('click', (ev) => {
        ev.stopPropagation();
        startPlayback(btn.getAttribute('data-play'));
      });
    });

    updateSelCount();
  }

  /* ========================================================== 连播控制 */
  const getPlay = () => store.get('play', null);
  const setPlay = (s) => store.set('play', s);

  /*
   * 跳转前必须先让连播状态真正落盘，否则新页面读不到队列，
   * 就会表现为"第一门播完/跳走后不再续播"（Chrome 下最常见）。
   */
  async function gotoWithState(state, url, why) {
    setPlay(state);
    const ok = await setPlaySync(state);
    if (!ok) {
      setWarn('连播状态写入较慢，已尽力保存；若下一页未自动播放，请点「播放选中」继续。');
    }
    await sleep(120);
    location.href = url;
  }

  async function startPlayback(startId) {
    const all = getItems();
    let queue = all.filter(i => i.entryUrl && !i.disabled);

    // 行内「从此处播放」：即便该条未被勾选，也从它开始播，且后续只播已勾选课程
    if (startId) {
      const target = all.find(i => i.id === startId && i.entryUrl);
      if (!target) { setStatus('该课程无可播放链接'); return; }
      const before = queue.filter(i => i.id !== startId);
      queue = [target].concat(before);
    }

    if (!queue.length) { setStatus('没有可播放课程：请先扫描，并勾选要播放的条目'); return; }
    const muted = ui && ui.els.mute ? ui.els.mute.checked : true;
    const rate = ui && ui.els.rate ? Number(ui.els.rate.value) || 1 : 1;
    const state = { active: true, queue, index: 0, muted, rate, startedAt: Date.now(), log: [] };
    const first = queue[0];
    setStatus(`开始播放：1/${queue.length}`);
    setNow(first.title);
    await gotoWithState(state, first.entryUrl, 'start');
  }

  function stopPlayback() {
    const st = getPlay();
    if (st) { st.active = false; st.stoppedAt = Date.now(); setPlay(st); }
    const v = pickVideo();
    if (v) { try { v.pause(); } catch (e) {} }
    setStatus('已停止连播');
    setNow('');
    setWarn('');
  }

  let advancing = false;

  async function advance(reason) {
    if (advancing) return;
    advancing = true;
    try {
      const st = getPlay();
      if (!st || !st.active) return;
      const cur = st.queue[st.index] || {};
      st.log = (st.log || []).concat([{ at: new Date().toISOString(), title: cur.title, reason }]);
      st.index = st.index + 1;
      if (st.index >= st.queue.length) {
        st.active = false; st.finishedAt = Date.now(); setPlay(st);
        setStatus(`全部 ${st.queue.length} 门已播放完毕`);
        setNow('');
        setWarn('');
        return;
      }
      const next = st.queue[st.index];
      setStatus(`切换中：${st.index + 1}/${st.queue.length}`);
      setNow(next.title);
      playCtx = newCtx();
      await gotoWithState(st, next.entryUrl, reason);
    } finally {
      setTimeout(() => { advancing = false; }, 1500);
    }
  }

  /* ---------------- 深度查找 video：自身文档 + 同源 iframe + shadow DOM ---------------- */
  function collectVideos(root, out, depth) {
    if (!root || depth > 3) return;
    try {
      if (root.querySelectorAll) {
        for (const v of Array.from(root.querySelectorAll('video'))) out.push(v);
      }
      if (root.querySelectorAll) {
        for (const el of Array.from(root.querySelectorAll('*'))) {
          if (el.shadowRoot) collectVideos(el.shadowRoot, out, depth + 1);
        }
      }
      if (root.querySelectorAll) {
        for (const f of Array.from(root.querySelectorAll('iframe,frame'))) {
          try {
            const d = f.contentDocument;
            if (d) collectVideos(d, out, depth + 1);
          } catch (e) { /* 跨域 iframe：拿不到，属于已知限制 */ }
        }
      }
    } catch (e) {}
  }

  /*
   * 【修复 2】原版只查顶层 document 的 <video>，第二学科如果播放器在 iframe 里就永远
   * 找不到。现在同时深入同源 iframe 与 shadow DOM；跨域 iframe 无法访问，会在面板给出提示。
   */
  function pickVideo() {
    const vids = [];
    collectVideos(document, vids, 0);
    const visible = vids.filter(v => {
      try {
        const r = v.getBoundingClientRect();
        return r.width > 40 && r.height > 20;
      } catch (e) { return false; }
    });
    const pool = visible.length ? visible : vids;
    if (!pool.length) return null;
    pool.sort((a, b) => (b.clientWidth * b.clientHeight) - (a.clientWidth * a.clientHeight));
    return pool[0];
  }

  function hasCrossOriginFrame() {
    for (const f of Array.from(document.querySelectorAll('iframe,frame'))) {
      try { void f.contentDocument; } catch (e) { return true; }
    }
    return false;
  }

  /*
   * 找出"最可能是播放器"的 iframe 地址。
   * 拿不到 contentDocument 的跨域 iframe 里，优先选面积最大的那个，
   * 并尽量补全协议（播放器地址常见为 //xxx.gensee.com/... 这种协议相对写法）。
   */
  function pickPlayerFrameSrc() {
    let best = null, bestArea = 0;
    for (const f of Array.from(document.querySelectorAll('iframe,frame'))) {
      let cross = false;
      try { void f.contentDocument; } catch (e) { cross = true; }
      if (!cross) continue;

      let src = f.getAttribute('src') || f.getAttribute('data-src') || '';
      if (!src) continue;
      // 明显不是播放器的（统计、客服、广告）跳过
      if (/google|analytics|cnzz|51\.la|baidu|tawk|zendesk|beacon/i.test(src)) continue;

      const r = f.getBoundingClientRect();
      const area = Math.max(1, r.width) * Math.max(1, r.height);
      if (area >= bestArea) { bestArea = area; best = src; }
    }
    if (!best) return '';
    try { return new URL(best, location.href).href; } catch (e) { return best; }
  }

  async function waitForVideo(ms) {
    const t0 = Date.now();
    while (Date.now() - t0 < ms) {
      const v = pickVideo();
      if (v) return v;
      await sleep(400);
    }
    return null;
  }

  function newCtx() {
    return {
      key: '', video: null, lastMove: Date.now(), tries: 0, since: Date.now(),
      hop: 0, keyOfHop: '', rateApplied: 0, mutedApplied: null,
      // 本次进入页面后，用户是否已在页面上产生真实交互（Chrome 用它判断能否有声自动播放）
      userGestured: false,
      // 已经对播放器做过几次"唤醒"尝试
      nudge: 0,
      // iframe 提升是否已尝试
      promoted: false
    };
  }

  let playCtx = newCtx();

  async function applyOptions(v, st) {
    // 静音：状态变化时才设置，避免与播放器反复争夺
    try {
      const want = !!st.muted;
      if (v.muted !== want && playCtx.mutedApplied !== want) {
        v.muted = want;
        playCtx.mutedApplied = want;
      }
    } catch (e) {}
    // 倍速：gensee 播放器会自行重置倍速，因此发现被重置时重新设置（仅在轮询周期内，不会高频触发）
    try {
      const want = Number(st.rate) || 1;
      if (want !== 1 && Math.abs(v.playbackRate - want) > 0.05) {
        v.playbackRate = want;
      }
    } catch (e) {}
  }

  // 播放器重置倍速时立刻纠正（ratechange 派发后设置，避免与播放器内部逻辑冲突）
  function enforceRate(v, st) {
    if (!v || !st) return;
    const want = Number(st.rate) || 1;
    if (want === 1) return;
    if (Math.abs(v.playbackRate - want) <= 0.05) return;
    try { v.playbackRate = want; } catch (e) {}
  }

  // 展视网(HTML5播放器)自带的"是否允许播放声音"提示框：静音模式下自动忽略
  function dismissSoundPrompt(st) {
    if (!st || !st.muted) return;
    try {
      const btns = Array.from(document.querySelectorAll('button,a,span,div'));
      for (const b of btns) {
        const t = clean(b.textContent);
        if (t !== '忽略') continue;
        const r = b.getBoundingClientRect();
        if (r.width < 1 || r.height < 1) continue;
        b.click();
        return;
      }
    } catch (e) {}
  }

  /*
   * 【修复 3】中间页自动进入：部分课程的"观看回放"先落到 pep 域的确认/过渡页，
   * 需要再点一次按钮才跳到真正的播放页。这里自动识别并点击一次（每页最多 CFG.maxHop 次）。
   */
  const ENTER_TEXTS = ['观看回放', '进入教室', '进入直播', '进入课堂', '立即进入', '进入', '开始学习', '继续学习', '播放', '立即观看'];

  function tryEnterPlayback() {
    const key = location.href;
    if (playCtx.keyOfHop !== key) { playCtx.keyOfHop = key; playCtx.hop = 0; }
    if (playCtx.hop >= CFG.maxHop) return false;

    const cands = Array.from(document.querySelectorAll('a,button,input[type=button],input[type=submit],div[role=button],span[role=button],[onclick]'));
    for (const el of cands) {
      let t = clean(el.textContent);
      if (!t) {
        t = clean(el.getAttribute('value') || el.getAttribute('title') || el.getAttribute('aria-label') || '');
      }
      if (!t) continue;
      if (t.length > 20) continue;
      if (ENTER_TEXTS.indexOf(t) === -1) continue;
      const r = el.getBoundingClientRect();
      if (r.width < 4 || r.height < 4) continue;
      try {
        el.click();
        playCtx.hop++;
        setStatus(`检测到过渡页，已自动点击「${t}」进入播放页…`);
        return true;
      } catch (e) {}
    }
    return false;
  }

  /*
   * 很多展视互动播放器不理会 video.play()，只认自己的播放按钮。
   * Chrome 下手势受限时，点按钮往往比调 play() 更有效，这里补一条点击路径。
   */
  const PLAY_SELECTORS = [
    '.vjs-big-play-button', '.prism-big-play-btn', '.xgplayer-start', '.dplayer-play-icon',
    '.jw-display-icon-container', '.shaka-play-button', '.play-btn', '.playBtn', '.play-button',
    '.player-play', '.video-play', '.btn-play', '.gensee-play', '.gensee-play-btn',
    '[class*="big-play"]', '[class*="playBtn"]', '[class*="play-btn"]', '[class*="btn-play"]',
    '[aria-label*="播放"]', '[title*="播放"]', '[data-role="play"]'
  ];

  function clickPlayerPlayButton() {
    // 1) 已知播放器选择器
    for (const sel of PLAY_SELECTORS) {
      let el = null;
      try { el = document.querySelector(sel); } catch (e) {}
      if (!el) continue;
      const r = el.getBoundingClientRect();
      if (r.width < 2 || r.height < 2) continue;
      try { el.click(); setLog('已点击播放按钮：' + sel); return true; } catch (e) {}
    }
    // 2) 播放器容器中央的无文字遮罩层
    const v = pickVideo();
    if (!v) return false;
    let box = v.parentElement;
    for (let i = 0; i < 4 && box; i++) {
      const cands = Array.from(box.querySelectorAll('div,button,span,a,i'));
      for (const c of cands) {
        let cs;
        try { cs = getComputedStyle(c); } catch (e) { continue; }
        if (cs.position !== 'absolute' && cs.position !== 'fixed') continue;
        const r = c.getBoundingClientRect();
        if (r.width < 40 || r.height < 40 || r.width > 320 || r.height > 320) continue;
        if (clean(c.textContent).length > 6) continue;
        const cx = r.left + r.width / 2, cy = r.top + r.height / 2;
        if (cx < 0 || cy < 0 || cx > innerWidth || cy > innerHeight) continue;
        try {
          c.dispatchEvent(new MouseEvent('click', {
            bubbles: true, cancelable: true, clientX: cx, clientY: cy, view: window
          }));
          setLog('已点击播放器中央遮罩');
          return true;
        } catch (e) {}
      }
      box = box.parentElement;
    }
    return false;
  }

  /*
   * Chrome 的自动播放策略比 Edge 严格：没有用户手势时只允许"静音自动播放"。
   * Edge 常带有媒体参与度评分(MEI)而放行有声播放，所以同一脚本在 Edge 正常、
   * 在 Chrome 被拦截。这里的策略：
   *   1) 先尝试按用户设置播放；
   *   2) 失败则强制静音播放（保证"能续播"优先于"有声音"）；
   *   3) 一旦用户在本页有过交互，再尝试取消静音。
   */
  async function ensurePlaying(v, st) {
    await applyOptions(v, st);
    if (!v.paused && !v.ended) return true;

    const tryPlay = async () => {
      try {
        const p = v.play();
        if (p && p.then) await p;
        return !v.paused;
      } catch (e) { return false; }
    };

    if (await tryPlay()) return true;

    // 兜底一：静音重试
    const wasMuted = v.muted;
    try { v.muted = true; } catch (e) {}
    if (await tryPlay()) {
      playCtx.mutedApplied = true;
      if (!st.muted) {
        setWarn('Chrome 阻止了有声自动播放，已改用静音自动播放以继续连播（可在播放器上手动开启声音）。');
      }
      return true;
    }
    try { if (!wasMuted) v.muted = wasMuted; } catch (e) {}

    // 兜底二：点击播放器本体一次（部分播放器需要 click 才真正启动）
    try {
      const r = v.getBoundingClientRect();
      if (r.width > 0 && r.height > 0) {
        const cx = r.left + r.width / 2;
        const cy = r.top + r.height / 2;
        const opts = { bubbles: true, cancelable: true, clientX: cx, clientY: cy, view: window };
        v.dispatchEvent(new MouseEvent('click', opts));
        await sleep(300);
        if (await tryPlay()) return true;
      }
    } catch (e) {}

    // 兜底三：点击播放器自己的播放按钮（gensee 等播放器常不认 video.play()）
    if (clickPlayerPlayButton()) {
      await sleep(600);
      if (await tryPlay()) return true;
      // 点完按钮后播放器可能异步响应，再静音补一次
      try { v.muted = true; } catch (e) {}
      await sleep(400);
      if (await tryPlay()) {
        playCtx.mutedApplied = true;
        return true;
      }
    }

    return false;
  }

  // 记录用户是否在本页产生过真实交互（Chrome 用它放行有声播放）
  function installGestureWatch() {
    const mark = () => {
      playCtx.userGestured = true;
      const st = getPlay();
      if (st && st.active) {
        const v = pickVideo();
        // 用户交互后，若之前因策略被静音，尝试恢复用户期望的静音设置
        if (v && !v.paused && !st.muted && v.muted) {
          try { v.muted = false; } catch (e) {}
        }
      }
    };
    ['pointerdown', 'mousedown', 'keydown', 'touchstart'].forEach(t => {
      window.addEventListener(t, mark, { capture: true, passive: true });
    });
  }

  let playLoopBusy = false;

  // 播放页主循环（任何非列表页都会运行，找不到播放器就持续等待/尝试进入）
  async function playLoop() {
    if (playLoopBusy) return;
    playLoopBusy = true;
    try {
      const st = getPlay();
      if (!st || !st.active) return;
      if (advancing) return;
      const cur = st.queue[st.index];
      if (!cur) { await advance('queue-end'); return; }

      if (playCtx.key !== location.href) {
        const gestured = playCtx.userGestured;
        playCtx = newCtx();
        playCtx.key = location.href;
        playCtx.userGestured = gestured;
        setLog(`进入页面：${location.hostname} ｜ 课程 ${st.index + 1}/${st.queue.length}`);
      }
      playCtx.tries++;

      const kind = kindOfPage();
      setDbg(`${st.index + 1}/${st.queue.length} ｜ 尝试 ${playCtx.tries}`);
      setStatus(`播放中 ${st.index + 1}/${st.queue.length}`);
      setNow(cur.title);

      // 标题不匹配只作提示，不再影响接管（原版会因此放弃接管）
      const pageTitle = clean(document.title);
      const same = pageTitle && cur.title && (pageTitle.includes(cur.title.slice(0, 12)) || cur.title.includes(pageTitle.slice(0, 12)));
      if (!same && pageTitle) setNow(cur.title + '（页面标题与课程名不一致，仍按队列继续）');

      let v = pickVideo();

      if (!v) {
        // 先尝试自动进入（过渡页 / 教室入口页）
        const hopped = tryEnterPlayback();
        if (hopped) {
          setWarn('');
          await sleep(1200);
          return;
        }

        const waited = Date.now() - playCtx.since;

        // 硬性看门狗：任何页面停留过久仍无播放器，直接跳下一门。
        // Chrome 里若第三方 Cookie 被拦、播放器根本没渲染，靠这条避免整条队列卡死。
        if (waited > CFG.hardStuckSec * 1000) {
          setLog(`看门狗：${CFG.hardStuckSec}s 未出现播放器，跳到下一门`);
          setWarn(`本页 ${CFG.hardStuckSec} 秒内未出现播放器，已自动跳到下一门。`);
          await advance('watchdog-no-video');
          return;
        }

        // 落在列表页或明显错误的页面：等一会儿仍无播放器，直接跳下一门（修复取链错误导致的卡死）
        if (kind === 'list' && waited > CFG.wrongPageSkipMs) {
          setWarn('当前落在课程列表页，未找到播放器，自动跳到下一门…');
          await advance('list-page-no-video');
          return;
        }

        // 跨域 iframe 播放器：脚本读不到内部 video。
        // 做法：把播放器 iframe 提到顶层页面，脚本就能直接控制它（Chrome 下常见情形）
        if (hasCrossOriginFrame() && waited > CFG.iframePromoteMs && !playCtx.promoted) {
          const target = pickPlayerFrameSrc();
          if (target) {
            playCtx.promoted = true;
            setWarn('播放器嵌在跨域 iframe 中，正在直接打开播放器地址以便自动续播…');
            await sleep(300);
            location.href = target;
            return;
          }
        }

        if (hasCrossOriginFrame() && waited > CFG.hintMs) {
          setWarn('检测到跨域 iframe 播放器且无法直接打开其地址，请手动点一次播放，或点「跳过本课」。');
        } else if (waited > CFG.hintMs) {
          setWarn('暂未找到播放器，仍在等待页面加载…（可点「跳过本课」手动越过）');
        }

        setStatus(`等待播放器加载…（${Math.round(waited / 1000)}s）`);
        v = await waitForVideo(Math.min(CFG.videoWaitMs, 8000));
        if (!v) return;
      }

      setWarn('');

      if (playCtx.video !== v) {
        playCtx.video = v;
        playCtx.lastMove = Date.now();
        playCtx.keyOfHop = '';
        v.addEventListener('ended', () => advance('ended'));
        v.addEventListener('error', () => advance('error'));
        v.addEventListener('timeupdate', () => { playCtx.lastMove = Date.now(); });
        v.addEventListener('playing', () => { playCtx.lastMove = Date.now(); });
        // 播放器重置倍速后立即纠正
        v.addEventListener('ratechange', () => {
          const stNow = getPlay();
          if (stNow && stNow.active) setTimeout(() => enforceRate(v, stNow), 0);
        });
        v.addEventListener('loadedmetadata', () => {
          const stNow = getPlay();
          if (stNow) enforceRate(v, stNow);
        });
      }

      if (v.ended) { await advance('ended'); return; }

      const ok = await ensurePlaying(v, st);
      if (!ok) setWarn('自动播放被浏览器拦截：请手动点一次播放键，之后会自动续播');

      // 静音模式下自动忽略播放器"是否允许播放声音"的提示，避免遮挡
      dismissSoundPrompt(st);

      // 播放器可能重置倍速/静音，周期性重申
      await applyOptions(v, st);

      if (!v.paused) playCtx.lastMove = Date.now();

      // 播放器已找到但始终起不来（Chrome 自动播放被拦 / 流地址 403 / 跨站 Cookie 被拦）
      if (v.paused && !v.ended) {
        if (!playCtx.videoSeenAt) playCtx.videoSeenAt = Date.now();
        const stuck = (Date.now() - playCtx.videoSeenAt) / 1000;
        if (stuck > CFG.playStartTimeoutSec) {
          setLog(`看门狗：有播放器但 ${CFG.playStartTimeoutSec}s 未能开播，跳到下一门`);
          setWarn(`播放器 ${CFG.playStartTimeoutSec} 秒内未能开始播放，已跳到下一门（详见「复制诊断」）。`);
          await advance('watchdog-no-start');
          return;
        }
        setStatus(`等待开播…（${Math.round(stuck)}s）`);
      } else {
        playCtx.videoSeenAt = 0;
      }

      if (Date.now() - playCtx.lastMove > CFG.stallMs) await advance('stalled');
    } finally {
      playLoopBusy = false;
    }
  }

  function kindOfPage() {
    if (isPepListPage()) return 'list';
    if (isGenseePage()) return 'gensee';
    if (isPepPage()) return 'pep';
    return 'other';
  }

  /* ================================================================= 启动 */
  function boot() {
    const kind = kindOfPage();
    const st = getPlay();
    const playing = !!(st && st.active);

    // 未在连播、且不在本脚本关心的站点：完全不介入
    if (!playing && kind === 'other') return;

    ensurePanel();
    const items = getItems();
    if (items.length) renderList(items);
    setDbg();

    /*
     * 【修复 1 + 关键】原版只在 gensee/pep 页面才启动 playLoop，第二学科如果落在
     * 其他域名（gensee.cn / csslcloud.net / 机构自有域名…）就完全不被接管。
     * 现在只要处于连播状态，任何页面都会启动接管循环；列表页也启动（用于"取错链接"
     * 的自动跳过），只是优先保留扫描功能。
     */
    if (playing) {
      installGestureWatch();

      // Chrome 会节流后台标签页的定时器，这里用多路唤醒：
      // 定时轮询 + 页面可见性变化 + 聚焦 + 媒体事件，保证切学科后立刻被接管。
      const tick = () => { playLoop(); };
      playLoop();
      setInterval(tick, CFG.tickMs);

      document.addEventListener('visibilitychange', () => {
        if (!document.hidden) { playLoop(); }
      });
      window.addEventListener('focus', () => { playLoop(); });
      window.addEventListener('pageshow', () => { playLoop(); });
      ['loadedmetadata', 'canplay', 'playing', 'durationchange'].forEach(t => {
        document.addEventListener(t, () => { playLoop(); }, true);
      });
      // 页面结构变化（播放器异步挂载完成）时也唤醒一次
      try {
        const mo = new MutationObserver(() => {
          if (pickVideo()) playLoop();
        });
        mo.observe(document.documentElement, { childList: true, subtree: true });
      } catch (e) {}

      if (kind === 'list') {
        setStatus('连播进行中，但当前页是课程列表页：若长期无播放器将自动跳到下一门');
      } else if (kind === 'other') {
        setStatus('连播进行中（非培训域名）');
      }
      return;
    }

    if (kind === 'list') {
      setStatus('就绪：点「扫描报名学段/学科」按报名信息遍历');
      if (items.length) setStatus(`已加载 ${items.length} 门（点击可重新扫描）`);
      showRegInfo();
    } else if (kind === 'gensee') {
      setStatus('播放页已就绪（等待连播指令或手动控制）');
    } else if (kind === 'other') {
      setStatus('当前页面非培训站点，无可执行操作');
    } else {
      setStatus('当前页面无可用操作（请在课程学习列表页使用）');
      showRegInfo();
    }
  }

  // 读取并在面板展示报名信息中的学段/学科组合
  async function showRegInfo() {
    if (!ui || !ui.els.regInfo) return;
    let reg = store.get(regKey(), null);
    if (!reg || !reg.pairs || !reg.pairs.length) {
      const r = await fetchRegistrationPairs();
      if (r.pairs.length) {
        reg = { pairs: r.pairs, source: r.source, at: Date.now() };
        store.set(regKey(), reg);
      }
    }
    if (!reg || !reg.pairs || !reg.pairs.length) {
      ui.els.regInfo.textContent = '未读取到报名学段/学科（将回退全站遍历）';
      return;
    }
    const label = reg.pairs.map(p => p.stage.t + p.sid.t).join('、');
    ui.els.regInfo.textContent = `报名：${label}`;
  }

  globalThis.__PEP_PX_REPLAY__ = {
    version: VERSION,
    scanAll, startPlayback, stopPlayback, playLoop, advance,
    getPlay, setPlay, renderList, ensurePanel, showRegInfo,
    parseCourses, readStages, readSids, pickVideo, tryEnterPlayback,
    parseRegistrationPairs, fetchRegistrationPairs
  };

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