// ==UserScript==
// @name         Web Video Play Helper
// @namespace    https://workbuddy.local/web-video-play-helper
// @version      2.1.0
// @description  全站通用的网页视频播放辅助：倍速滑杆（可对平台隐藏真实倍速）、防切屏/失焦误暂停、静音、自动播放、每站倍速记忆。在超星/学习通下额外启用防挂机保活、自动连播下一节、弹题提醒。带可拖拽悬浮面板 + 快捷键 + 设置持久化。
// @author       WorkBuddy
// @license      MIT
// @match        *://*/*
// @run-at       document-start
// @grant        GM_getValue
// @grant        GM_setValue
// @grant        unsafeWindow
// ==/UserScript==

/* eslint-disable no-empty */
(function () {
  'use strict';

  /* --- 0. 基础常量与工具 --- */

  const IS_TOP = (function () { try { return window.top === window.self; } catch (e) { return false; } })();
  const FRAME_ID = 'wvph-' + Math.random().toString(36).slice(2, 9);
  const MSG_TAG = '__wvph_msg__';
  const CFG_KEY = 'wvph_cfg_v1';
  const SITE_KEY = 'wvph_sitespeed_v1';     // 每站倍速记忆（独立存储，避免污染配置）
  const PANEL_HOST_ID = 'wvph-panel-host';

  /** 是否处于超星 / 学习通（学习通专属功能只在这里真正生效） */
  function isChaoxing() {
    try { return /(^|\.)(chaoxing\.com|chaoxing\.com\.cn|xuexitong\.com|xuexitong\.com\.cn)$/i.test(location.hostname); } catch (e) { return false; }
  }

  const log = function () {
    try { console.log.apply(console, ['%c[Web Video Play Helper]', 'color:#1f9d6b;font-weight:600'].concat(Array.prototype.slice.call(arguments))); } catch (e) {}
  };

  function fmtTime(s) {
    if (!isFinite(s) || s < 0) s = 0;
    var m = Math.floor(s / 60);
    var ss = Math.floor(s % 60);
    return String(m).padStart(2, '0') + ':' + String(ss).padStart(2, '0');
  }

  function isVisible(el, win) {
    if (!el || !el.getBoundingClientRect) return false;
    try {
      var r = el.getBoundingClientRect();
      if (r.width <= 0 || r.height <= 0) return false;
      var cs = (win || window).getComputedStyle(el);
      if (cs.display === 'none' || cs.visibility === 'hidden' || cs.opacity === '0') return false;
      if (cs.pointerEvents === 'none') return false;
      return true;
    } catch (e) { return false; }
  }

  /* --- 1. 配置与状态 --- */

  var DEFAULTS = {
    speed: 1,              // 目标倍速
    spoof: 'auto',         // 隐藏真实倍速：'auto'（仅学习通）/ 'on' / 'off'
    antiPause: true,       // 被平台强制暂停时自动恢复
    keepAlive: true,       // 模拟操作避免挂机弹窗（仅学习通真正生效）
    mute: false,           // 静音
    autoplay: true,        // 视频出来后自动开始播放
    autoNext: true,        // 播完自动切下一节（仅学习通有匹配入口）
    rememberSpeed: true,   // 按站点记住倍速
    swsOpen: true,         // 通用开关分组是否展开
    swsCxOpen: false,      // 学习通专属分组是否展开
    panelX: null,
    panelY: null,
    collapsed: false,
    hidden: false
  };

  var state = {
    cfg: Object.assign({}, DEFAULTS),
    media: new Set(),       // 当前帧内的 video/audio 元素
    lastGesture: 0,         // 页面上最后一次真实用户交互时间
    quiz: false,            // 是否检测到弹题
    playing: false,         // 最近一次上报的播放状态（顶层帧里是全局聚合结果）
    siteSpeedDone: false    // 本页是否已应用过"每站倍速记忆"
  };

  /**
   * GM 存储读写：有 GM API 就用，没有则退化为 localStorage。
   * GM 存储在脚本的所有 frame 之间共享，这是跨 iframe 同步配置与指令的基础。
   */
  function readStore(key) {
    try {
      var raw = (typeof GM_getValue === 'function') ? GM_getValue(key, null) : localStorage.getItem(key);
      if (!raw) return null;
      return typeof raw === 'string' ? JSON.parse(raw) : raw;
    } catch (e) { return null; }
  }

  function writeStore(key, val) {
    try {
      var raw = JSON.stringify(val);
      if (typeof GM_setValue === 'function') GM_setValue(key, raw);
      else localStorage.setItem(key, raw);
    } catch (e) {}
  }

  /** 隐藏真实倍速是否生效：auto 模式下只有学习通需要
   *  （其他站点开着会让它们自带的倍速菜单读到恒为 1×，显示错乱） */
  function spoofOn() {
    return state.cfg.spoof === 'auto' ? isChaoxing() : state.cfg.spoof === 'on';
  }

  /* --- 更名迁移：旧前缀是 cxh_，把已有设置搬到新键，避免升级后丢掉配置与每站倍速 --- */
  (function migrateLegacyKeys() {
    ['cfg_v1', 'sitespeed_v1', 'cmd_v1'].forEach(function (suffix) {
      var nk = 'wvph_' + suffix;
      if (readStore(nk) !== null) return;
      var old = readStore('cxh_' + suffix);
      if (old !== null) writeStore(nk, old);
    });
  })();

  var storage = {
    read: function () {
      var obj = readStore(CFG_KEY);
      if (obj) Object.assign(state.cfg, DEFAULTS, obj);
    },
    write: function () { writeStore(CFG_KEY, state.cfg); }
  };

  storage.read();

  /* ---- 每站倍速记忆：按 hostname 存，只由顶层帧读写 ---- */
  function siteSpeedGet() {
    if (!state.cfg.rememberSpeed || !IS_TOP) return null;
    var map = readStore(SITE_KEY);
    var v = map && map[location.hostname];
    return typeof v === 'number' && v > 0 ? v : null;
  }

  function siteSpeedSet(v) {
    if (!state.cfg.rememberSpeed || !IS_TOP) return;
    var map = readStore(SITE_KEY) || {};
    if (map[location.hostname] === v) return;
    map[location.hostname] = v;
    writeStore(SITE_KEY, map);
  }

  /** 更新单个配置项：写盘 + 广播。
   *  注意不要再显式调 applyCfgLocally —— sendMessage 会先把消息投递给本帧，
   *  handleMessage 的 'cfg' 分支已经统一做了"写入 + 本地生效"，两处都调就会应用两次。 */
  function setCfg(key, value) {
    state.cfg[key] = value;
    storage.write();
    sendMessage({ type: 'cfg', key: key, value: value });
    return value;
  }

  function applyCfgLocally(key) {
    if (key === 'speed') {
      doSpeed(state.cfg.speed);          // 同时会同步包装播放器的倍速菜单
      siteSpeedSet(state.cfg.speed);     // 顶层帧顺手记下本站的倍速（内部自带 IS_TOP 判断）
    } else if (key === 'mute') {
      doMute(state.cfg.mute);
    } else if (key === 'autoplay') {
      if (state.cfg.autoplay) {
        liveMedia().forEach(function (m) {
          if (m.paused && !m.ended && !m.__wvphIntentPaused) safePlay(m);
        });
      }
    }
    reportSoon();
  }

  /* --- 2. 原型级 Hook（必须在 document-start 完成，越早越有效） --- */

  var rawRateDesc = null;   // playbackRate 原始描述符
  var rawDefaultRateDesc = null;

  function installProtoPatches() {
    var proto;
    try { proto = HTMLMediaElement.prototype; } catch (e) { return; }

    /* ---- 2.1 倍速伪装：对外读出恒为 1，对外写入被忽略 ---- */
    try {
      rawRateDesc = Object.getOwnPropertyDescriptor(proto, 'playbackRate');
      rawDefaultRateDesc = Object.getOwnPropertyDescriptor(proto, 'defaultPlaybackRate');
    } catch (e) {}

    [['playbackRate', rawRateDesc], ['defaultPlaybackRate', rawDefaultRateDesc]].forEach(function (pair) {
      var prop = pair[0], desc = pair[1];
      if (!desc || !desc.get || !desc.set) return;
      try {
        Object.defineProperty(proto, prop, {
          configurable: true,
          enumerable: true,
          get: function () {
            try {
              if (spoofOn() && this && this.__wvphRate != null) {
                return this.__wvphFakeRate != null ? this.__wvphFakeRate : 1;
              }
              return desc.get.call(this);
            } catch (e) { return 1; }
          },
          set: function (v) {
            // 伪装开启且已被我们接管时，平台写倍速一律忽略
            try { if (spoofOn() && this && this.__wvphRate != null) return; } catch (e) {}
            return desc.set.call(this, v);
          }
        });
      } catch (e) {}
    });

    /* ---- 2.2 页面可见性伪装：切标签页/最小化时，页面仍认为自己是可见且聚焦的 ---- */
    patchVisibility();

    /* ---- 2.3 拦截可见性/失焦类事件，避免平台监听后主动暂停 ---- */
    var BLOCK = ['visibilitychange', 'webkitvisibilitychange', 'blur', 'pagehide', 'freeze'];
    BLOCK.forEach(function (t) {
      var fn = function (e) {
        if (!state.cfg.antiPause) return;
        try { e.stopImmediatePropagation(); } catch (err) {}
      };
      try { window.addEventListener(t, fn, true); } catch (e) {}
      try { document.addEventListener(t, fn, true); } catch (e) {}
    });
  }

  /** 让页面认为自己始终可见且聚焦 —— 平台据此判断是否该暂停视频 */
  function patchVisibility() {
    var keys = { hidden: false, webkitHidden: false, visibilityState: 'visible', webkitVisibilityState: 'visible' };
    var targets = [document];
    try { targets.push(Document.prototype); } catch (e) {}
    targets.forEach(function (t) {
      Object.keys(keys).forEach(function (k) {
        try { Object.defineProperty(t, k, { configurable: true, get: function () { return keys[k]; } }); } catch (e) {}
      });
      try { t.hasFocus = function () { return true; }; } catch (e) {}
    });
  }

  /* --- 3. 跨 frame 消息总线（同源 iframe 之间同步配置与指令） --- */

  function rootWindow() {
    try { return window.top; } catch (e) { return window; }
  }

  function walkWindows(fn, fromWindow, depth) {
    var win = fromWindow || rootWindow();
    var d = depth || 0;
    if (d > 6) return;
    try { fn(win); } catch (e) {}
    var frames = [];
    try { frames = Array.prototype.slice.call(win.frames); } catch (e) {}
    frames.forEach(function (f) { walkWindows(fn, f, d + 1); });
  }

  var msgSeq = 0;
  var seenMsg = new Set();

  /** 消息去重：同一条消息可能同时经"直接调用"和"postMessage 回声"到达 */
  function alreadySeen(id) {
    if (!id) return false;
    if (seenMsg.has(id)) return true;
    seenMsg.add(id);
    if (seenMsg.size > 300) { seenMsg.delete(seenMsg.values().next().value); }
    return false;
  }

  /* ---- 指令兜底通道：GM 存储跨 frame 共享，postMessage 被拦也照样生效 ----
   * 两条通道（广播 + 存储轮询）会各自投递同一条指令，若不去重，
   * "下一节"会被点两次从而跳章。故给每条指令分配全局递增序号 cs，
   * 每个 frame 只执行序号更大的指令，实现跨通道的"恰好一次"。 */
  var CMD_KEY = 'wvph_cmd_v1';
  // 只有需要跨 frame 送达的动作才走兜底通道（其余靠 cfg 广播就够了）
  var JOURNAL_CMDS = { play: 1, pause: 1, next: 1 };
  var executedCmdSeq = 0;      // 本帧已执行到的指令序号

  /** 取下一个全局指令序号，并落盘到兜底通道 */
  function publishCmd(cmd) {
    if (!JOURNAL_CMDS[cmd]) return 0;
    var prev = readStore(CMD_KEY) || {};
    var seq = (typeof prev.seq === 'number' ? prev.seq : 0) + 1;
    writeStore(CMD_KEY, { seq: seq, cmd: cmd, t: Date.now() });
    return seq;
  }

  function pollCmd() {
    var rec = readStore(CMD_KEY);
    if (!rec || typeof rec.seq !== 'number' || rec.seq <= executedCmdSeq) return;
    executedCmdSeq = rec.seq;
    if (Date.now() - (rec.t || 0) > 10000) return;   // 过期指令丢弃（页面刷新后不该补跑）
    log('通过兜底通道收到指令：' + rec.cmd);
    runCommand(rec.cmd);
  }

  // 启动时对齐序号，避免重放历史指令
  (function () {
    var rec = readStore(CMD_KEY);
    if (rec && typeof rec.seq === 'number') executedCmdSeq = rec.seq;
  })();

  /** 向整棵 frame 树广播（含自身） */
  function sendMessage(payload) {
    var msg = Object.assign({}, payload);
    msg[MSG_TAG] = true;
    msg.from = FRAME_ID;
    msg.id = FRAME_ID + ':' + (++msgSeq);

    if (payload && payload.type === 'cmd') {
      msg.cs = publishCmd(payload.cmd);   // 0 表示走兜底通道
    }

    // 关键：先在本帧无条件执行一次。这样即使 window.top 的代理比较、
    // 或 frames 枚举在当前沙箱里失效，只要视频就在本窗口也一定能生效。
    // 重复投递由消息 id / 指令序号 cs 去重，不会执行两次。
    handleMessage(msg, 'self');

    walkWindows(function (w) {
      if (w === window) return;
      try { w.postMessage(msg, '*'); } catch (e) {}
    });
  }

  try {
    window.addEventListener('message', function (e) {
      var d = e.data;
      if (!d || typeof d !== 'object' || !d[MSG_TAG]) return;
      handleMessage(d, e.source);
    }, false);
  } catch (e) {}

  function handleMessage(msg, source) {
    if (!msg || !msg[MSG_TAG]) return;
    if (alreadySeen(msg.id)) return;

    switch (msg.type) {
      case 'cfg':
        if (msg.key) {
          state.cfg[msg.key] = msg.value;
          applyCfgLocally(msg.key);
        }
        if (IS_TOP) renderPanel();
        break;

      case 'cmd':
        // 跨通道去重：广播与存储轮询会送来同一条指令，只执行序号更大的那条
        if (typeof msg.cs === 'number' && msg.cs > 0) {
          if (msg.cs <= executedCmdSeq) break;
          executedCmdSeq = msg.cs;
        }
        runCommand(msg.cmd);
        break;

      case 'status':
        if (IS_TOP && source && source !== window) {
          if (msg.data && msg.data.count > 0) ensurePanel();   // 子帧里发现视频 → 该出面了
          statusMap.set(source, { data: msg.data, t: Date.now() });
          if (!tickScheduled) { tickScheduled = true; requestAnimationFrame(function () { tickScheduled = false; renderStatus(); }); }
        }
        break;

      case 'quiz':
        state.quiz = !!msg.value;
        if (IS_TOP) { renderStatus(); if (state.quiz) { beep(); flashTitle(); } }
        break;

      case 'diagInfo':
        if (IS_TOP && source && source !== window) {
          diagMap.set(source, { data: msg.data, t: Date.now() });
          renderDiag();
        }
        break;

      default: break;
    }
  }

  /* --- 4. 媒体元素：发现 / 注册 / 控制 --- */

  var hooked = new WeakSet();
  var statusMap = new Map();
  var diagMap = new Map();
  var diagOpen = false;
  var tickScheduled = false;

  function liveMedia() {
    var out = [];
    state.media.forEach(function (m) {
      if (m && m.isConnected) out.push(m);
    });
    return out;
  }

  /** 用原始描述符写入真实倍速（绕过我们自己的伪装层） */
  function setRealRate(el, rate) {
    try {
      el.__wvphRate = rate;                                   // 标记：已被接管
      if (el.__wvphFakeRate == null) el.__wvphFakeRate = 1;     // 对外读数
      if (rawRateDesc && rawRateDesc.set) rawRateDesc.set.call(el, rate);
      else el.playbackRate = rate;
    } catch (e) {}
  }

  function safePlay(el) {
    try {
      var p = el.play();
      if (p && typeof p.catch === 'function') {
        p.catch(function () {
          // 多半被浏览器自动播放策略拦截：先静音播放，再按用户偏好恢复
          try {
            var wantMuted = state.cfg.mute;
            el.muted = true;
            var p2 = el.play();
            if (p2 && typeof p2.catch === 'function') p2.catch(function () {});
            if (!wantMuted) setTimeout(function () { try { el.muted = false; } catch (e) {} }, 400);
          } catch (e) {}
        });
      }
    } catch (e) {}
  }

  function scanMedia() {
    // 清理已从 DOM 移除的元素，避免长会话内存泄漏
    state.media.forEach(function (m) {
      if (!m || !m.isConnected) state.media.delete(m);
    });

    var nodes;
    try { nodes = document.querySelectorAll('video, audio'); } catch (e) { return; }
    for (var i = 0; i < nodes.length; i++) {
      var el = nodes[i];
      if (hooked.has(el)) continue;
      hooked.add(el);
      state.media.add(el);
      hookMedia(el);
      onNewMedia(el);
    }
  }

  function onNewMedia(el) {
    setRealRate(el, state.cfg.speed);
    try { el.muted = state.cfg.mute; } catch (e) {}
    if (state.cfg.autoplay && el.paused && !el.ended) {
      setTimeout(function () {
        // 到点时要重新判断：这 600ms 内用户可能已经手动暂停了，不能抢回
        if (state.cfg.autoplay && el.paused && !el.ended &&
            !el.__wvphIntentPaused && !el.__wvphUserPaused) safePlay(el);
      }, 600);
    }
    reportSoon();
  }

  function hookMedia(el) {
    /* 平台强制暂停 → 自动恢复；用户主动暂停 → 上锁，绝不抢回 */
    el.addEventListener('pause', function () {
      if (!state.cfg.antiPause) return;
      if (el.__wvphUserPaused || el.__wvphIntentPaused) return;   // 用户意图是暂停 → 尊重
      if (el.ended) return;
      if (Date.now() - state.lastGesture < 800) {             // 刚有真实点击 → 判定为用户手动暂停
        el.__wvphUserPaused = true;
        el.__wvphIntentPaused = Date.now();
        return;
      }
      setTimeout(function () {
        if (!state.cfg.antiPause || el.__wvphUserPaused || el.__wvphIntentPaused) return;
        if (el.ended || !el.paused) return;
        log('检测到被动暂停，自动恢复播放');
        safePlay(el);
      }, 350);
    });

    /* 重新从头播时复位连播标记。
     * 注意：不能在 play 事件里无条件解除"用户暂停锁"——
     * 包装播放器会派发抖动性的 play 事件，那样会把锁冲掉，
     * 导致防暂停逻辑把自己的暂停又抢回播放（表现为"暂停键不起作用"）。 */
    el.addEventListener('play', function () {
      if (Date.now() - state.lastGesture < 1500) {            // 只有本帧刚有真实用户操作才解锁
        el.__wvphUserPaused = false;
        el.__wvphIntentPaused = 0;
      }
      if (isFinite(el.duration) && el.duration - el.currentTime > 5) el.__wvphNextFired = false;
      reportSoon();
    });

    /* 倍速被外部篡改 → 拉回目标值 */
    el.addEventListener('ratechange', function () {
      if (!spoofOn() || !rawRateDesc || el.__wvphRate == null) return;
      var real;
      try { real = rawRateDesc.get.call(el); } catch (e) { return; }
      if (Math.abs(real - el.__wvphRate) > 0.001) {
        var want = state.cfg.speed;
        setTimeout(function () { if (el.__wvphRate != null) setRealRate(el, want); }, 80);
      }
    });

    el.addEventListener('loadedmetadata', function () {
      setRealRate(el, state.cfg.speed);
      reportSoon();
    });

    /* 自动连播：timeupdate 兜底（部分超星播放器到结尾不派发 ended）+ ended 双触发，
     * 用 __wvphNextFired 保证只触发一次。 */
    function fireNext(why) {
      if (!state.cfg.autoNext || el.__wvphNextFired) return;
      el.__wvphNextFired = true;
      log(why);
      setTimeout(function () { if (state.cfg.autoNext) goNext(); }, 1500);
    }

    el.addEventListener('timeupdate', function () {
      var dur = el.duration;
      if (isFinite(dur) && dur > 3 && dur - el.currentTime <= 0.8) fireNext('视频接近结尾，准备切换下一节');
      reportSoon();
    });

    el.addEventListener('ended', function () { fireNext('视频播放结束，准备切换下一节'); });
  }

  /* --- 5. 播放器适配层 ---
   * 【为什么必须有这一层】
   * 超星的播放器不是"裸 <video>"，而是 videojs / 自研包装播放器。包装器内部维护着
   * 自己的播放状态（paused / playing）。如果只调用原生 element.play()/pause()，
   * 包装器的状态不会同步，于是：
   *   · 点"暂停" → 元素停了，但包装器认为还在播 → 下一帧又把视频 play() 回来
   *   · 点"播放" → 元素播了，但包装器认为已暂停 → 立刻又 pause() 回去
   * 结果就是"播放/暂停键不起作用"。所以必须优先操纵播放器对象，再回落到原生元素。 */

  var PLAYER_GLOBAL_NAMES = ('player myPlayer playerObj vdPlayer _player '
    + 'cxplayer h5player ansPlayer videoPlayer').split(' ');

  function pageWindow() {
    try { if (typeof unsafeWindow !== 'undefined' && unsafeWindow) return unsafeWindow; } catch (e) {}
    return window;
  }

  function findPlayers() {
    var out = [], seen = [];
    function push(p) {
      if (!p || (typeof p !== 'object' && typeof p !== 'function')) return;
      var usable = false;
      try { usable = typeof p.play === 'function' || typeof p.playVideo === 'function'; } catch (e) {}
      if (!usable || seen.indexOf(p) >= 0) return;
      seen.push(p);
      out.push(p);
    }

    var w = pageWindow();
    var vjs = null;
    try { vjs = w.videojs; } catch (e) {}

    // videojs 5/6 挂在 players 上，7+ 挂在 getPlayers() 上，都试一遍
    var bags = [];
    try { if (vjs && vjs.players) bags.push(vjs.players); } catch (e) {}
    try { if (vjs && typeof vjs.getPlayers === 'function') bags.push(vjs.getPlayers() || {}); } catch (e) {}
    bags.forEach(function (bag) { Object.keys(bag).forEach(function (k) { push(bag[k]); }); });

    // 页面级全局播放器变量
    PLAYER_GLOBAL_NAMES.forEach(function (n) { try { push(w[n]); } catch (e) {} });

    // 元素上挂的播放器引用，以及按元素 id 反查 videojs 实例
    liveMedia().forEach(function (m) {
      ['player', 'videojs', '_player', 'cxPlayer'].forEach(function (k) { try { push(m[k]); } catch (e) {} });
      try { if (vjs && typeof vjs.getPlayer === 'function' && m.id) push(vjs.getPlayer(m.id)); } catch (e) {}
    });
    return out;
  }

  /** 对每个播放器对象执行一次操作，返回命中数量 */
  function withPlayers(fn) {
    var hit = 0;
    findPlayers().forEach(function (p) {
      try { fn(p); hit++; } catch (e) {}
    });
    return hit;
  }

  function doPlay() {
    // 先操纵播放器对象（它内部会同步 UI 与状态）
    var hit = withPlayers(function (p) {
      if (typeof p.play === 'function') p.play();
      else if (typeof p.playVideo === 'function') p.playVideo();
    });
    // 再直接操作元素兜底
    liveMedia().forEach(function (m) {
      m.__wvphUserPaused = false;
      m.__wvphIntentPaused = 0;
      safePlay(m);
    });
    log('指令：播放' + (hit ? '（已同步 ' + hit + ' 个播放器对象）' : '（未发现包装播放器，直接操作元素）'));
  }

  function doPause() {
    var t = Date.now();
    var hit = withPlayers(function (p) {
      if (typeof p.pause === 'function') p.pause();
      else if (typeof p.pauseVideo === 'function') p.pauseVideo();
    });
    liveMedia().forEach(function (m) {
      m.__wvphUserPaused = true;
      m.__wvphIntentPaused = t;      // 上锁：自动恢复不再抢回，直到用户显式播放
      try { m.pause(); } catch (e) {}
    });
    log('指令：暂停' + (hit ? '（已同步 ' + hit + ' 个播放器对象）' : ''));
  }

  function doSpeed(rate) {
    liveMedia().forEach(function (m) { setRealRate(m, rate); });
    // 让包装播放器的倍速菜单也跟上；伪装开启时这次写入会被我们自己的 setter 忽略
    withPlayers(function (p) {
      if (typeof p.playbackRate === 'function') p.playbackRate(rate);
    });
  }

  function doMute(flag) {
    liveMedia().forEach(function (m) { try { m.muted = !!flag; } catch (e) {} });
    withPlayers(function (p) {
      if (typeof p.muted === 'function') p.muted(!!flag);
    });
  }

  /* --- 6. 指令执行 ---
   * 只有"需要驱动别的 frame"的动作才走指令通道；倍速 / 静音 / 开关都走 cfg 广播。 */

  function runCommand(cmd) {
    switch (cmd) {
      case 'play': doPlay(); break;
      case 'pause': doPause(); break;
      case 'next': goNext(); break;
      case 'rescan': scanMedia(); break;
      case 'diag': sendDiagBack(); break;
      case 'showPanel': if (IS_TOP) showPanel(true); break;
      default: break;
    }
    reportSoon();
  }

  /* --- 7. 自动连播：找"下一节" --- */

  // 用 | 分隔写成一串再 split：选择器里本身含空格（后代选择器、属性值），不能用空格分词
  var NEXT_SELECTORS = ('#prevNextFocusNext|.prev_next.next|.jb_btn_next|.prev_next .next|.nextButton|'
    + 'a.next|button.next|[title="下一节"]|[title="下一集"]|.ans-job-next|.video-next-btn').split('|');

  function findClickable(doc, win, selectors) {
    for (var i = 0; i < selectors.length; i++) {
      var nodes;
      try { nodes = doc.querySelectorAll(selectors[i]); } catch (e) { continue; }
      for (var j = 0; j < nodes.length; j++) {
        var n = nodes[j];
        if (n.disabled) continue;
        if (isVisible(n, win)) return n;
      }
    }
    return null;
  }

  function goNext() {
    // 只在学习通执行。通用站点的 "a.next / button.next" 之类的选择器太宽松，
    // 误点到一个分页"下一页"就会把当前页面跳走，风险远大于收益。
    if (!isChaoxing()) { log('自动连播 / 下一节 仅在超星·学习通生效'); return; }

    // 策略一：点"下一节/下一集"按钮（可能在本帧、播放器帧或外层帧）
    var hit = null;
    walkWindows(function (w) {
      if (hit) return;
      var doc;
      try { doc = w.document; } catch (e) { return; }
      var el = findClickable(doc, w, NEXT_SELECTORS);
      if (el) hit = el;
    });
    if (hit) {
      log('点击下一节按钮', hit);
      try { hit.click(); return; } catch (e) {}
    }

    // 策略二：章节列表里最后一个"未完成"的节点
    var item = nextCatalogItem();
    if (item) {
      log('点击章节列表中下一未完成节点', item);
      try { item.click(); return; } catch (e) {}
    }

    log('未找到下一节入口，请手动切换（可在面板上点"下一节"重试）');
  }

  function nextCatalogItem() {
    var result = null;
    walkWindows(function (w) {
      if (result) return;
      var doc;
      try { doc = w.document; } catch (e) { return; }
      var items;
      try { items = Array.prototype.slice.call(doc.querySelectorAll('.posCatalog_select, .chapter_item, .catalog_points')); } catch (e) { return; }
      if (items.length < 2) return;

      var cur = -1;
      for (var i = 0; i < items.length; i++) {
        var cls = items[i].className || '';
        if (/\b(active|current|posCatalog_active)\b/.test(cls) || items[i].getAttribute('aria-current') === 'true') { cur = i; break; }
      }
      if (cur < 0) return;

      for (var k = cur + 1; k < items.length; k++) {
        if (!isFinished(items[k])) { result = items[k]; return; }
      }
      if (items[cur + 1]) result = items[cur + 1];
    });
    return result;
  }

  /** 判断章节节点是否已完成（超星的完成态标记有多种写法，尽量都兜住） */
  function isFinished(el) {
    try {
      if (el.querySelector('.icon_Completed, .catalog_finish, [class*="complete" i], [class*="finish" i]')) return true;
      if (/已完成|完成/.test((el.getAttribute('title') || '') + (el.className || ''))) return true;
    } catch (e) {}
    return false;
  }

  /* --- 8. 防挂机保活 --- */

  function keepAliveTick() {
    // 只在学习通模拟鼠标活动。在别的站点合成鼠标事件可能触发各种悬浮/预览行为，得不偿失。
    if (!state.cfg.keepAlive || !isChaoxing()) return;
    var playing = liveMedia().filter(function (m) { return !m.paused && !m.ended; });
    if (!playing.length) return;

    var x = 40 + Math.floor(Math.random() * 80);
    var y = 40 + Math.floor(Math.random() * 80);

    // 派发到播放器元素上（会冒泡到播放器容器和 document 的监听）
    ['mousemove', 'pointermove'].forEach(function (type) {
      try {
        var ev = new MouseEvent(type, {
          bubbles: true, cancelable: true, view: window,
          clientX: x, clientY: y, screenX: x, screenY: y
        });
        playing[0].dispatchEvent(ev);
      } catch (e) {}
    });

    // 有些实现只在 window 上监听
    try {
      window.dispatchEvent(new MouseEvent('mousemove', { bubbles: false, view: window, clientX: x, clientY: y, screenX: x, screenY: y }));
    } catch (e) {}

    // 兜底：万一被静默暂停，顺手拉回来（用户主动暂停的不碰）
    playing.forEach(function (m) {
      if (m.paused && !m.ended && !m.__wvphUserPaused && !m.__wvphIntentPaused) safePlay(m);
    });
  }

  /* --- 9. 弹题检测 --- */

  var QUIZ_SELECTORS = ('.ans-videoquiz-opt|.ans-videoquiz|#videoquiz|.videoquiz|'
    + '[class*="videoquiz"]|.tkTopic').split('|');

  function detectQuiz() {
    for (var i = 0; i < QUIZ_SELECTORS.length; i++) {
      var nodes;
      try { nodes = document.querySelectorAll(QUIZ_SELECTORS[i]); } catch (e) { continue; }
      for (var j = 0; j < nodes.length; j++) {
        if (isVisible(nodes[j], window)) return true;
      }
    }
    return false;
  }

  function quizTick() {
    if (!isChaoxing()) return;          // 弹题提醒是学习通专属
    var now = detectQuiz();
    if (now !== state.quiz) {
      state.quiz = now;
      sendMessage({ type: 'quiz', value: now });
      if (now) {
        // 弹题出现时不要静音，方便你听到/看到
        log('检测到弹题，视频已暂停，请手动作答');
      }
    }
  }

  /* --- 10. 状态上报与诊断 --- */

  var lastReport = 0;
  function reportSoon() {
    var now = Date.now();
    if (now - lastReport < 600) return;
    lastReport = now;
    report();
  }

  function report() {
    var list = liveMedia();
    // 优先取正在播的那个作为代表，没有则退而取第一个
    var pick = list.filter(function (m) { return !m.paused && !m.ended; })[0] || list[0] || null;

    var data = { count: list.length, quiz: state.quiz, cur: 0, dur: 0, playing: false };
    if (pick) {
      data.cur = pick.currentTime || 0;
      data.dur = isFinite(pick.duration) ? pick.duration : 0;
      data.playing = !pick.paused && !pick.ended;
    }
    state.playing = data.playing;

    if (IS_TOP) {
      if (data.count > 0) ensurePanel();     // 本帧就有视频 → 直接出面
      statusMap.set('self', { data: data, t: Date.now() });
      renderStatus();
      return;
    }

    // 子帧：状态没有实质变化就不重复上报，避免每 300ms 一次的无谓广播；
    // 但仍保留 4 秒心跳，防止顶层把这一帧判成"已失效"。
    var sig = [data.count, data.playing ? 1 : 0, Math.floor(data.cur), Math.floor(data.dur), data.quiz ? 1 : 0].join('|');
    var now = Date.now();
    if (sig === lastStatusSig && now - lastStatusAt < 4000) return;
    lastStatusSig = sig;
    lastStatusAt = now;
    sendMessage({ type: 'status', data: data });
  }

  var lastStatusSig = '';
  var lastStatusAt = 0;

  /* ---- 诊断：一把看清"按键没反应"断在哪一环 ---- */
  function sendDiagBack() {
    var data = {
      top: IS_TOP,
      media: liveMedia().length,
      players: findPlayers().length,
      frames: 0,
      url: String(location.href).slice(0, 90)
    };
    try { data.frames = window.frames.length; } catch (e) {}
    if (IS_TOP) {
      diagMap.set('self', { data: data, t: Date.now() });
      renderDiag();
    } else {
      sendMessage({ type: 'diagInfo', data: data });
    }
  }

  function renderDiag() {
    if (!ui) return;
    var now = Date.now();
    var recs = [], media = 0, players = 0, frames = 0;
    // 一趟遍历：清理过期项 + 收集各帧数据 + 汇总计数
    diagMap.forEach(function (v, k) {
      if (!v || !v.data || now - v.t > 6000) { diagMap.delete(k); return; }
      recs.push(v.data);
      media += v.data.media || 0;
      players += v.data.players || 0;
      frames += v.data.frames || 0;
    });
    if (!diagOpen) { ui.diag.classList.remove('show'); return; }

    log('—— 诊断 ——');
    log('宿主帧总数 =', Math.max(frames, recs.length));
    recs.forEach(function (d) {
      log('  帧: top=' + d.top + ' 视频=' + d.media + ' 播放器=' + d.players + ' ' + d.url);
    });

    ui.diag.classList.add('show');
    ui.diag.innerHTML = media === 0
      ? ('未发现视频元素。<br>有脚本的帧 ' + recs.length +
         ' 个。若远少于实际层数，请确认脚本允许在 iframe 中运行。')
      : ('视频 ' + media + ' 个 · 包装播放器 ' + players + ' 个 · 帧 ' + recs.length + ' 个' +
         (players === 0 ? '<br>未识别到包装播放器，按原生元素控制' : ''));
  }

  /* --- 11. 悬浮面板（仅顶层窗口渲染） --- */

  var ui = null;

  /**
   * 面板由「页面上确实存在视频」驱动，而不是靠 URL 判断 —— 通用化之后没有固定域名可依据，
   * 而且顶层面板自己也常常没有 video（视频在 iframe 里），所以还要靠子帧的状态上报来触发。
   */
  function ensurePanel() {
    if (!IS_TOP || ui || state.cfg.hidden) return;
    buildPanel();
  }

  /** 每站倍速记忆：只在确认页面上有视频时应用一次，避免在无关页面乱写配置 */
  function applySiteSpeedOnce() {
    if (state.siteSpeedDone || !IS_TOP) return;
    state.siteSpeedDone = true;
    var v = siteSpeedGet();
    if (v != null && Math.abs(v - state.cfg.speed) > 0.001) {
      log('应用本站记忆倍速：' + v + '×');
      setCfg('speed', v);
    }
  }

  /* --- 面板样式 —— 「深色指挥台」 ---
   * 设计取向：课程基本在暗色视频区里看，浅色面板是范式错配；深色玻璃压在视频上
   * 近乎隐形，只让数字浮出来。等宽字体承载数值，LED 状态灯表达开关态。
   * 强调色只有 #3ddc84（播放态 / 进度 / 选中），其余全部中性灰阶。 */
  var PANEL_CSS = [
    ':host{all:initial;}',
    '*,*::before,*::after{box-sizing:border-box;margin:0;padding:0;}',
    '.wrap{position:fixed;z-index:2147483000;width:290px;color-scheme:dark;',
    'font:400 12px/1.55 -apple-system,BlinkMacSystemFont,"Segoe UI Variable Text","Segoe UI","PingFang SC","Hiragino Sans GB","Microsoft YaHei",sans-serif;',
    'color:#e9edf2;background:rgba(19,21,26,.95);',
    '-webkit-backdrop-filter:blur(18px) saturate(1.6);backdrop-filter:blur(18px) saturate(1.6);',
    'border:.5px solid rgba(255,255,255,.11);border-radius:13px;',
    'box-shadow:0 20px 50px -14px rgba(0,0,0,.58),0 2px 10px rgba(0,0,0,.38);',
    'overflow:hidden;user-select:none;-webkit-user-select:none;animation:wvph-in .18s cubic-bezier(.2,.8,.3,1);}',
    '@keyframes wvph-in{from{opacity:0;transform:translateY(-4px) scale(.985);}to{opacity:1;transform:none;}}',
    '.mono{font-family:ui-monospace,SFMono-Regular,"SF Mono",Menlo,Consolas,"Liberation Mono",monospace;}',

    /* ---------- 标题栏 ---------- */
    '.hd{display:flex;align-items:center;gap:8px;padding:11px 14px;cursor:grab;',
    'background:rgba(255,255,255,.04);border-bottom:.5px solid rgba(255,255,255,.08);}',
    '.hd:active{cursor:grabbing;}',
    '.dot{flex:none;width:7px;height:7px;border-radius:50%;background:#39414d;transition:background .2s,box-shadow .2s;}',
    '.dot.on{background:#3ddc84;box-shadow:0 0 9px rgba(61,220,132,.75);}',
    '.dot.warn{background:#ff5b5b;box-shadow:0 0 9px rgba(255,91,91,.75);}',
    '.ttl{flex:1;font-size:11.5px;font-weight:500;color:#aeb8c4;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;}',
    '.chip{display:none;align-items:baseline;gap:1px;border:0;background:transparent;padding:0;cursor:pointer;',
    'font:inherit;font-size:13px;font-weight:600;color:#fff;font-variant-numeric:tabular-nums;white-space:nowrap;}',
    '.chip i{font-style:normal;font-size:10.5px;font-weight:400;color:#7d8794;margin-left:4px;}',
    '.ico{flex:none;width:22px;height:22px;display:grid;place-items:center;border:0;border-radius:6px;background:transparent;',
    'color:#6b7583;cursor:pointer;transition:background .15s,color .15s;}',
    '.ico:hover{background:rgba(255,255,255,.08);color:#cdd6e0;}',
    '.ico svg{width:13px;height:13px;display:block;transition:transform .18s ease;}',
    '.ico.rot svg{transform:rotate(-90deg);}',

    /* ---------- 折叠态：紧凑胶囊 ---------- */
    '.wrap.collapsed{width:auto;}',
    '.wrap.hidden,.wrap.collapsed .bd,.wrap.collapsed .ttl,.wrap.collapsed #btn-hide{display:none;}',
    '.wrap.collapsed .chip{display:inline-flex;}',
    '.wrap.collapsed .hd{padding:8px 13px;background:transparent;border-bottom:0;}',

    /* ---------- 主体 ---------- */
    '.bd{padding:0 14px 14px;}',
    '.stat{display:flex;align-items:baseline;justify-content:space-between;gap:10px;padding:13px 0 7px;',
    'font-size:10.5px;letter-spacing:.02em;color:#78828f;font-variant-numeric:tabular-nums;}',
    '.stat .l{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;}',
    '.stat .r{flex:none;white-space:nowrap;}',
    '.stat .r.live{color:#3ddc84;font-weight:600;}',
    '.stat .r.warn{color:#ff5b5b;font-weight:600;}',
    '.bar{height:3px;border-radius:99px;background:rgba(255,255,255,.09);overflow:hidden;}',
    '.bar>i{display:block;height:100%;width:0;border-radius:99px;background:#3ddc84;',
    'box-shadow:0 0 10px rgba(61,220,132,.5);transition:width .3s linear;}',

    /* ---------- 倍速：视觉主角 ---------- */
    '.hero{display:flex;align-items:flex-end;gap:10px;padding:14px 0 8px;}',
    '.big{font-size:31px;font-weight:600;line-height:1;letter-spacing:-.02em;color:#fff;}',
    '.big small{font-size:12px;font-weight:400;color:#69737f;margin-left:1px;}',
    '.spacer{flex:1;}',
    '.tune{display:flex;align-items:center;gap:5px;}',
    '.tune button{width:26px;height:26px;display:grid;place-items:center;border:.5px solid rgba(255,255,255,.13);',
    'background:rgba(255,255,255,.05);border-radius:7px;color:#c3ccd7;font-size:13px;line-height:1;cursor:pointer;transition:background .15s;}',
    '.tune button:hover{background:rgba(255,255,255,.11);}',
    '.tune button:active{background:rgba(255,255,255,.16);}',
    '.tune input{width:52px;height:26px;border:.5px solid rgba(255,255,255,.13);border-radius:7px;',
    'background:rgba(255,255,255,.05);text-align:center;font:inherit;font-size:12px;font-weight:600;',
    'color:#e9edf2;font-variant-numeric:tabular-nums;outline:none;transition:border-color .15s,box-shadow .15s;}',
    '.tune input:focus{border-color:#3ddc84;box-shadow:0 0 0 3px rgba(61,220,132,.18);}',

    /* ---------- 滑杆：圆角长方形轨道 + 竖长圆角长方形手柄 ---------- */
    '.rng{display:block;width:100%;height:20px;-webkit-appearance:none;appearance:none;background:transparent;cursor:pointer;}',
    '.rng::-webkit-slider-runnable-track{height:8px;border-radius:3px;',
    'background:linear-gradient(90deg,#3ddc84 0%,#3ddc84 var(--p,17%),rgba(255,255,255,.1) var(--p,17%),rgba(255,255,255,.1) 100%);}',
    /* 手柄做成竖直的圆角长方形，比轨道高，骑在轨道上；margin-top = (轨道高 - 手柄高)/2 */
    '.rng::-webkit-slider-thumb{-webkit-appearance:none;width:7px;height:18px;margin-top:-5px;border-radius:2.5px;',
    'background:#e9edf2;box-shadow:0 1px 4px rgba(0,0,0,.55);transition:background .15s;}',
    '.rng:hover::-webkit-slider-thumb{background:#fff;}',
    '.rng:focus-visible::-webkit-slider-thumb{background:#fff;box-shadow:0 0 0 3px rgba(61,220,132,.3);}',
    '.rng::-moz-range-track{height:8px;border-radius:3px;background:rgba(255,255,255,.1);}',
    '.rng::-moz-range-progress{height:8px;border-radius:3px;background:#3ddc84;}',
    '.rng::-moz-range-thumb{width:7px;height:18px;border:0;border-radius:2.5px;background:#e9edf2;box-shadow:0 1px 4px rgba(0,0,0,.55);}',

    /* ---------- 滑杆刻度锚点 ---------- */
    /* 左右各内缩半个手柄宽度（手柄 7px → 3.5px），使刻度位置与手柄中心严格对齐；
       margin-top:-4px 让刻度线正好贴在轨道下缘（轨道 8px 高、垂直居中于 20px 的滑杆） */
    '.ticks{position:relative;height:24px;margin:-4px 3.5px 0;}',
    '.ticks button{position:absolute;top:0;transform:translateX(-50%);display:flex;flex-direction:column;align-items:center;gap:3px;',
    'border:0;background:transparent;padding:0;cursor:pointer;font:inherit;font-size:10px;color:#6b7583;',
    'font-variant-numeric:tabular-nums;transition:color .15s;}',
    '.ticks button:hover{color:#3ddc84;}',
    '.ticks button u{display:block;width:1px;height:5px;background:rgba(255,255,255,.22);text-decoration:none;transition:height .15s,background .15s;}',
    '.ticks button.on{color:#3ddc84;font-weight:600;}',
    '.ticks button.on u{background:#3ddc84;height:7px;box-shadow:0 0 6px rgba(61,220,132,.6);}',
    '.ticks button.first{transform:translateX(0);align-items:flex-start;}',
    '.ticks button.last{transform:translateX(-100%);align-items:flex-end;}',

    /* ---------- 行为开关：可折叠分组 + LED 指示条 ---------- */
    '.secbox{margin-top:13px;border-top:.5px solid rgba(255,255,255,.08);}',
    '.sec-hd{display:flex;align-items:center;gap:8px;width:100%;padding:12px 0 11px;border:0;background:transparent;',
    'font:inherit;color:#8a94a1;cursor:pointer;transition:color .15s;}',
    '.sec-hd:hover{color:#cdd6e0;}',
    '.sec-lb{flex:1;text-align:left;font-size:10px;letter-spacing:.14em;text-transform:uppercase;font-weight:600;}',
    '.sec-sum{flex:none;font-size:10px;font-variant-numeric:tabular-nums;color:#5d6672;letter-spacing:.02em;transition:color .15s;}',
    /* 「当前站点不适用」徽标：学习通专属分组在别的网站上显示它 */
    '.sec-tag{display:none;flex:none;font-size:9.5px;color:#8a94a1;background:rgba(255,255,255,.07);',
    'border:.5px solid rgba(255,255,255,.12);border-radius:4px;padding:1px 5px;}',
    '.secbox.na .sec-tag{display:inline-block;}',
    '.secbox.na .sec-lb{color:#6b7583;}',
    '.chev{flex:none;display:grid;place-items:center;color:#5d6672;transition:transform .22s ease;}',
    '.chev svg{width:11px;height:11px;display:block;}',
    /* 折叠用 grid-template-rows 0fr/1fr 做高度动画，可自适应内容高度 */
    '.sec-body{display:grid;grid-template-rows:1fr;transition:grid-template-rows .22s ease;}',
    '.secbox.closed .sec-hd{padding-bottom:0;}',
    '.secbox.closed .chev{transform:rotate(-90deg);}',
    '.secbox.closed .sec-sum{color:#4a525d;}',
    '.secbox.closed .sec-body{grid-template-rows:0fr;}',
    '.sws{display:grid;grid-template-columns:1fr 1fr;gap:0 14px;overflow:hidden;min-height:0;padding-bottom:2px;}',
    '.sws label{display:flex;align-items:center;justify-content:space-between;gap:8px;padding:5.5px 0;',
    'font-size:11px;color:#8a94a1;cursor:pointer;transition:color .15s;}',
    '.sws label:hover{color:#c3ccd7;}',
    '.sws label span{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;}',
    '.sws input{-webkit-appearance:none;appearance:none;flex:none;width:15px;height:8px;border-radius:2px;',
    'background:rgba(255,255,255,.15);cursor:pointer;outline:none;transition:background .18s,box-shadow .18s;}',
    '.sws input:checked{background:#3ddc84;box-shadow:0 0 7px rgba(61,220,132,.6);}',
    '.sws input:focus-visible{box-shadow:0 0 0 3px rgba(61,220,132,.3);}',
    '.sws label:has(input:checked){color:#dde4ec;}',

    /* ---------- 提示 / 操作 ---------- */
    '.quiz{display:none;margin-top:11px;padding:8px 10px;border-radius:8px;background:rgba(255,91,91,.12);',
    'border:.5px solid rgba(255,91,91,.4);color:#ff9b9b;font-size:11px;line-height:1.6;}',
    '.quiz.show,.diag.show{display:block;}',
    '.acts{display:flex;flex-wrap:wrap;gap:5px;padding:13px 0 0;margin-top:13px;border-top:.5px solid rgba(255,255,255,.08);}',
    '.acts button{flex:1 1 auto;min-width:calc(33.333% - 4px);height:29px;padding:0 8px;border:.5px solid rgba(255,255,255,.13);',
    'background:rgba(255,255,255,.05);border-radius:7px;color:#c3ccd7;font:inherit;font-size:11.5px;font-weight:500;',
    'cursor:pointer;white-space:nowrap;transition:background .15s,transform .1s;}',
    '.acts button:hover{background:rgba(255,255,255,.11);}',
    '.acts button:active{transform:translateY(.5px);background:rgba(255,255,255,.16);}',
    '.acts button.primary{background:#e9edf2;border-color:#e9edf2;color:#111519;font-weight:600;}',
    '.acts button.primary:hover{background:#fff;}',
    /* 当前站点不适用的操作按钮 */
    '.acts button.off{opacity:.45;}',
    '.acts button.off:hover{background:rgba(255,255,255,.05);}',
    '.diag{display:none;margin-top:11px;padding:8px 10px;border-radius:8px;background:rgba(255,255,255,.05);',
    'border:.5px solid rgba(255,255,255,.09);color:#8b95a3;font-size:10.5px;line-height:1.65;word-break:break-all;}',
    '.tip{margin-top:11px;font-size:10px;line-height:1.8;color:#5d6672;}',
    '.tip kbd{display:inline-block;padding:0 3px;border-radius:4px;background:rgba(255,255,255,.07);',
    'border:.5px solid rgba(255,255,255,.09);font:inherit;color:#8b95a3;}'
  ].join('');

  var SVG_CHEVRON = '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><path d="M4.2 6.4L8 10.2l3.8-3.8"/></svg>';
  var SVG_CLOSE = '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round"><path d="M4.6 4.6l6.8 6.8M11.4 4.6l-6.8 6.8"/></svg>';

  var PANEL_HTML = [
    '<div class="wrap" id="wrap">',
    '  <div class="hd" id="hd">',
    '    <span class="dot" id="dot"></span>',
    '    <span class="ttl">Web Video Play Helper</span>',
    '    <button class="chip" id="chip" title="展开面板"><b class="mono" id="chip-rate">1×</b><i id="chip-state">待检测</i></button>',
    '    <button class="ico" id="btn-collapse" title="折叠 / 展开">', SVG_CHEVRON, '</button>',
    '    <button class="ico" id="btn-hide" title="隐藏（Alt+H 唤回）">', SVG_CLOSE, '</button>',
    '  </div>',
    '  <div class="bd">',
    '    <div class="stat">',
    '      <span class="l" id="s-left">正在检测视频…</span>',
    '      <span class="r" id="s-right">—</span>',
    '    </div>',
    '    <div class="bar"><i id="bar-fill"></i></div>',

    '    <div class="hero">',
    '      <div class="big mono" id="speed-big">1<small>×</small></div>',
    '      <div class="spacer"></div>',
    '      <div class="tune">',
    '        <button data-act="minus" title="降低 0.25">−</button>',
    '        <input id="speed-in" type="number" min="0.1" max="16" step="0.25" value="1" title="输入精确倍速">',
    '        <button data-act="plus" title="提高 0.25">+</button>',
    '      </div>',
    '    </div>',
    '    <input class="rng" id="speed-range" type="range" min="0" max="17" step="1" value="2" title="拖动调节倍速（也可滚轮微调）">',
    '    <div class="ticks" id="speed-ticks"></div>',

    '    <div class="secbox" id="sws-section">',
    '      <button class="sec-hd" id="sws-hd" title="收起 / 展开通用开关">',
    '        <span class="sec-lb">通用</span>',
    '        <span class="sec-sum" id="sws-sum">0 / 4</span>',
    '        <span class="chev">', SVG_CHEVRON, '</span>',
    '      </button>',
    '      <div class="sec-body"><div class="sws" id="switches"></div></div>',
    '    </div>',

    '    <div class="secbox" id="cx-section">',
    '      <button class="sec-hd" id="cx-hd" title="收起 / 展开学习通专属开关">',
    '        <span class="sec-lb">学习通专属</span>',
    '        <span class="sec-tag">当前站点不适用</span>',
    '        <span class="sec-sum" id="cx-sum">0 / 3</span>',
    '        <span class="chev">', SVG_CHEVRON, '</span>',
    '      </button>',
    '      <div class="sec-body"><div class="sws" id="cx-switches"></div></div>',
    '    </div>',

    '    <div class="quiz" id="quiz">检测到弹题，视频已暂停，请手动作答</div>',
    '    <div class="acts">',
    '      <button class="primary" data-act="play">播放</button>',
    '      <button data-act="pause">暂停</button>',
    '      <button data-act="next">下一节</button>',
    '      <button data-act="rescan">重检测</button>',
    '      <button data-act="diag">诊断</button>',
    '    </div>',
    '    <div class="diag" id="diag"></div>',
    '    <div class="tip"><kbd>Alt</kbd>+<kbd>↑</kbd>/<kbd>↓</kbd> 调速 · <kbd>Alt</kbd>+<kbd>P</kbd> 播放暂停 · <kbd>Alt</kbd>+<kbd>M</kbd> 静音 · <kbd>Alt</kbd>+<kbd>H</kbd> 显隐</div>',
    '  </div>',
    '</div>'
  ].join('\n');

  // 滑杆下方的刻度锚点：点一下直接跳到该档。
  // 低倍速段排得密（那是最需要精度的区间），高倍速段稀疏。
  var SPEED_TICKS = [0.5, 1, 1.5, 2, 4, 16];

  // 滑杆等距取值表：线性滑杆会把低倍速区间挤成一团，所以用"档位索引"来映射
  var SPEED_STEPS = [0.5, 0.75, 1, 1.25, 1.5, 1.75, 2, 2.25, 2.5, 3, 3.5, 4, 5, 6, 8, 10, 12, 16];

  /**
   * 开关定义表：面板里的开关全部由它生成，避免 HTML / 渲染 / 计数三处各写一遍。
   * g: 'gen' 通用分组（任何网站都有意义）；'cx' 学习通专属分组（其他站点空转）
   */
  var SWITCHES = [
    { cfg: 'antiPause',     g: 'gen', label: '防误暂停', hint: '被平台因切屏 / 失焦强制暂停时，自动恢复播放' },
    { cfg: 'autoplay',      g: 'gen', label: '自动播放', hint: '检测到视频后自动开始播放' },
    { cfg: 'mute',          g: 'gen', label: '静音',     hint: '将视频静音' },
    { cfg: 'rememberSpeed', g: 'gen', label: '记住倍速', hint: '按站点记住倍速，下次打开该站自动应用' },
    { cfg: 'spoof',         g: 'cx',  label: '隐藏倍速', hint: '对平台隐藏真实倍速，它检测到的永远是 1×（默认仅学习通开启）' },
    { cfg: 'keepAlive',     g: 'cx',  label: '防挂机',   hint: '定时模拟鼠标活动，避免长时间无操作被弹窗打断' },
    { cfg: 'autoNext',      g: 'cx',  label: '自动连播', hint: '播完自动进入下一节' }
  ];

  /** 开关当前是否生效（spoof 是 'auto' 三态，需要换算成实际布尔值） */
  function swOn(key) {
    return key === 'spoof' ? spoofOn() : !!state.cfg[key];
  }

  function switchesHtml(group) {
    return SWITCHES.filter(function (s) { return s.g === group; }).map(function (s) {
      return '<label title="' + s.hint + '"><span>' + s.label + '</span>' +
             '<input type="checkbox" data-cfg="' + s.cfg + '"></label>';
    }).join('');
  }

  function fmtSpeed(v) {
    var n = parseFloat(Number(v).toFixed(2));
    return String(n);
  }

  function nearestStepIndex(v) {
    var best = 0, diff = Infinity;
    for (var i = 0; i < SPEED_STEPS.length; i++) {
      var d = Math.abs(SPEED_STEPS[i] - v);
      if (d < diff) { diff = d; best = i; }
    }
    return best;
  }

  function buildPanel() {
    if (ui || !IS_TOP) return;
    var host = document.getElementById(PANEL_HOST_ID);
    if (!host) {
      host = document.createElement('div');
      host.id = PANEL_HOST_ID;
      // 宿主元素隔离页面样式，避免被超星的全局 CSS 影响（也不影响页面布局）
      host.setAttribute('style', 'all:initial;position:fixed;top:0;left:0;width:0;height:0;z-index:2147483000;');
      (document.body || document.documentElement).appendChild(host);
    }
    var root = host.shadowRoot || host.attachShadow({ mode: 'open' });
    root.innerHTML = '<style>' + PANEL_CSS + '</style>' + PANEL_HTML;

    // 元素引用：键名 → DOM id。写成表比 21 行几乎相同的 getElementById 好维护
    var UI_IDS = {
      wrap: 'wrap', hd: 'hd', dot: 'dot', btnCollapse: 'btn-collapse',
      chipRate: 'chip-rate', chipState: 'chip-state',
      sLeft: 's-left', sRight: 's-right', barFill: 'bar-fill',
      big: 'speed-big', range: 'speed-range', speedIn: 'speed-in', ticks: 'speed-ticks',
      swsSection: 'sws-section', swsSum: 'sws-sum',
      cxSection: 'cx-section', cxSum: 'cx-sum',
      quiz: 'quiz', diag: 'diag'
    };
    ui = { host: host, root: root };
    Object.keys(UI_IDS).forEach(function (k) { ui[k] = root.getElementById(UI_IDS[k]); });

    // 开关由 SWITCHES 表生成，两个分组各渲染一次
    root.getElementById('switches').innerHTML = switchesHtml('gen');
    root.getElementById('cx-switches').innerHTML = switchesHtml('cx');

    // 滑杆刻度锚点（位置按等距档位表换算，不是均分，否则和滑块对不上）
    ui.ticks.innerHTML = SPEED_TICKS.map(function (v, i) {
      var pos = (nearestStepIndex(v) / (SPEED_STEPS.length - 1)) * 100;
      var edge = i === 0 ? 'first' : (i === SPEED_TICKS.length - 1 ? 'last' : '');
      return '<button data-tick="' + v + '"' + (edge ? ' class="' + edge + '"' : '') +
        ' style="left:' + pos.toFixed(2) + '%" title="' + fmtSpeed(v) + ' 倍速"><u></u><span>' + fmtSpeed(v) + '</span></button>';
    }).join('');

    ui.range.max = String(SPEED_STEPS.length - 1);

    // 位置与折叠
    if (state.cfg.panelX != null) { ui.wrap.style.left = state.cfg.panelX + 'px'; ui.wrap.style.top = state.cfg.panelY + 'px'; }
    else { ui.wrap.style.right = '18px'; ui.wrap.style.top = '90px'; }
    if (state.cfg.collapsed) ui.wrap.classList.add('collapsed');
    if (state.cfg.hidden) ui.wrap.classList.add('hidden');

    bindPanel();
    makeDraggable(ui.wrap, ui.hd);
    renderPanel();
    applySiteSpeedOnce();     // 面板就绪后再套用本站记忆倍速
  }

  /** 操作按钮 → 反馈文案（键名即指令名） */
  var ACT_HINT = { play: '播放', pause: '暂停', next: '下一节', rescan: '重新检测视频' };

  /** 面板交互：点击统一走一条事件委托，按 id / data-* 分派 */
  function bindPanel() {
    var wrap = ui.wrap;

    wrap.addEventListener('click', function (e) {
      var b = e.target.closest && e.target.closest('button');
      if (!b || !wrap.contains(b)) return;
      e.stopPropagation();                       // 面板内的点击不往页面里漏

      var id = b.id;
      var act = b.getAttribute('data-act');
      var tick = b.getAttribute('data-tick');

      // 走 setCfg 的分支不必自己再调 renderPanel：配置消息在 handleMessage 里已经触发了重绘
      if (id === 'btn-collapse') {
        wrap.classList.toggle('collapsed');
        setCfg('collapsed', wrap.classList.contains('collapsed'));
      } else if (id === 'chip') {
        wrap.classList.remove('collapsed');
        setCfg('collapsed', false);
      } else if (id === 'btn-hide') {
        wrap.classList.add('hidden');
        setCfg('hidden', true);
      } else if (id === 'sws-hd' || id === 'cx-hd') {
        var openKey = id === 'sws-hd' ? 'swsOpen' : 'swsCxOpen';
        setCfg(openKey, !state.cfg[openKey]);
      } else if (tick != null) {
        setCfg('speed', parseFloat(tick));       // 刻度锚点：直接跳档
      } else if (act === 'minus' || act === 'plus') {
        bumpSpeed(act === 'plus' ? 0.25 : -0.25);
      } else if (act === 'diag') {
        diagOpen = !diagOpen;
        diagMap.clear();
        if (diagOpen) sendMessage({ type: 'cmd', cmd: 'diag' });
        else renderDiag();
      } else if (ACT_HINT[act]) {
        sendMessage({ type: 'cmd', cmd: act });
        hint(act === 'next' && !isChaoxing() ? '「下一节」仅在学习通生效' : '已发送：' + ACT_HINT[act]);
      }
    });

    // 滑杆：拖动时视觉即时、写盘节流；松手 / 滚轮则精确落盘
    var lastRangeWrite = 0;
    function commitRange(idx, throttled) {
      var v = SPEED_STEPS[idx];
      if (!v) return;
      paintSpeed(v);
      var now = Date.now();
      if (throttled && now - lastRangeWrite < 120) return;
      lastRangeWrite = now;
      setCfg('speed', v);
    }
    ui.range.addEventListener('input', function () {
      commitRange(parseInt(ui.range.value, 10), true);
    });
    ui.range.addEventListener('change', function () {
      commitRange(parseInt(ui.range.value, 10), false);
    });
    ui.range.addEventListener('wheel', function (e) {
      e.preventDefault();
      var idx = parseInt(ui.range.value, 10);
      if (!isFinite(idx)) idx = nearestStepIndex(state.cfg.speed);
      commitRange(Math.min(SPEED_STEPS.length - 1, Math.max(0, idx + (e.deltaY < 0 ? 1 : -1))), false);
    }, { passive: false });

    ui.speedIn.addEventListener('change', function () {
      var v = parseFloat(ui.speedIn.value);
      if (!isFinite(v)) v = 1;
      setCfg('speed', Math.min(16, Math.max(0.1, v)));
    });

    // 开关：两个分组都在 wrap 内，用一条 change 委托统一处理
    wrap.addEventListener('change', function (e) {
      var key = e.target && e.target.getAttribute && e.target.getAttribute('data-cfg');
      if (!key) return;
      // spoof 是三态：手动拨动即从 auto 切为明确的 on / off
      setCfg(key, key === 'spoof' ? (e.target.checked ? 'on' : 'off') : e.target.checked);
    });
  }

  var hintUntil = 0;
  function hint(text, ms) {
    if (!ui) return;
    ui.sLeft.textContent = text;
    hintUntil = Date.now() + (ms || 2500);
  }

  function round2(n) { return Math.round(n * 100) / 100; }

  function makeDraggable(wrap, handle) {
    var drag = false, sx = 0, sy = 0, ox = 0, oy = 0;
    handle.addEventListener('pointerdown', function (e) {
      if (e.target.closest('button, input, label')) return;
      drag = true;
      var r = wrap.getBoundingClientRect();
      sx = e.clientX; sy = e.clientY; ox = r.left; oy = r.top;
      try { handle.setPointerCapture(e.pointerId); } catch (err) {}
      e.preventDefault();
    });
    handle.addEventListener('pointermove', function (e) {
      if (!drag) return;
      var nx = Math.min(Math.max(0, ox + e.clientX - sx), window.innerWidth - 80);
      var ny = Math.min(Math.max(0, oy + e.clientY - sy), window.innerHeight - 40);
      wrap.style.left = nx + 'px';
      wrap.style.top = ny + 'px';
      wrap.style.right = 'auto';
    });
    handle.addEventListener('pointerup', function () {
      if (!drag) return;
      drag = false;
      var r = wrap.getBoundingClientRect();
      state.cfg.panelX = Math.round(r.left);
      state.cfg.panelY = Math.round(r.top);
      storage.write();
    });
  }

  /** 只刷新倍速相关的视觉（读数 / 滑杆填充），用于拖动滑杆时的即时反馈 */
  function paintSpeed(v) {
    if (!ui) return;
    ui.big.innerHTML = fmtSpeed(v) + '<small>×</small>';
    var idx = nearestStepIndex(v);
    ui.range.value = String(idx);
    ui.range.style.setProperty('--p', ((idx / (SPEED_STEPS.length - 1)) * 100).toFixed(2) + '%');
    ui.chipRate.textContent = fmtSpeed(v) + '×';
  }

  function renderPanel() {
    if (!ui) return;

    // 开关状态（spoof 是三态，需换算成实际生效的布尔值）+ 分组摘要
    var cnt = { gen: [0, 0], cx: [0, 0] };
    ui.root.querySelectorAll('input[data-cfg]').forEach(function (inp) {
      inp.checked = swOn(inp.getAttribute('data-cfg'));
    });
    SWITCHES.forEach(function (s) {
      cnt[s.g][1]++;
      if (swOn(s.cfg)) cnt[s.g][0]++;
    });
    ui.swsSum.textContent = cnt.gen[0] + ' / ' + cnt.gen[1];
    ui.cxSum.textContent = cnt.cx[0] + ' / ' + cnt.cx[1];
    ui.swsSection.classList.toggle('closed', !state.cfg.swsOpen);
    ui.cxSection.classList.toggle('closed', !state.cfg.swsCxOpen);
    // 非学习通站点：学习通分组整块标灰并提示不适用
    ui.cxSection.classList.toggle('na', !isChaoxing());

    // 「下一节」在学习通之外没有可靠入口，置灰以示不可用
    var nextBtn = ui.root.querySelector('button[data-act="next"]');
    if (nextBtn) nextBtn.classList.toggle('off', !isChaoxing());

    // 刻度高亮：只在完全命中时点亮。否则 1.1× 时把「1」点亮会误导
    ui.root.querySelectorAll('button[data-tick]').forEach(function (b) {
      var v = parseFloat(b.getAttribute('data-tick'));
      b.classList.toggle('on', Math.abs(v - state.cfg.speed) < 0.001);
    });
    if (document.activeElement !== ui.speedIn) ui.speedIn.value = fmtSpeed(state.cfg.speed);
    paintSpeed(state.cfg.speed);

    // 折叠箭头方向（折叠时朝右，表示"可展开"）
    ui.btnCollapse.classList.toggle('rot', ui.wrap.classList.contains('collapsed'));

    renderStatus();
  }

  function renderStatus() {
    if (!ui) return;
    var now = Date.now();
    var total = 0, cur = 0, dur = 0, playing = false, quiz = false;
    // 一趟遍历同时完成「清理失效上报」与「聚合各帧状态」
    statusMap.forEach(function (entry, key) {
      if (!entry || now - entry.t > 15000) { statusMap.delete(key); return; }
      var d = entry.data;
      total += d.count || 0;
      if (d.quiz) quiz = true;
      if ((d.dur || 0) > dur || d.playing) { cur = d.cur || 0; dur = d.dur || 0; }
      if (d.playing) playing = true;
    });

    // 刚点过按钮的 2.5 秒内优先显示操作反馈，避免被状态刷新立刻盖掉
    state.playing = playing;
    if (now >= hintUntil) {
      ui.sLeft.textContent = total > 0 ? (total + ' 个视频 · ' + fmtTime(cur) + ' / ' + fmtTime(dur)) : '未检测到视频';
    }
    ui.barFill.style.width = dur > 0 ? Math.min(100, (cur / dur) * 100).toFixed(1) + '%' : '0';

    // 播放状态：展开时显示在状态行右侧，折叠时显示在胶囊里
    var stateText = quiz ? '弹题待答' : (playing ? '▶ 播放中' : (total > 0 ? '⏸ 已暂停' : '—'));
    var stateCls = quiz ? 'warn' : (playing ? 'live' : '');
    ui.sRight.className = 'r' + (stateCls ? ' ' + stateCls : '');
    ui.sRight.textContent = stateText;
    ui.chipState.textContent = stateText;

    ui.dot.className = 'dot' + (quiz ? ' warn' : (playing ? ' on' : ''));
    ui.quiz.classList.toggle('show', quiz);
  }

  function showPanel(force) {
    if (!IS_TOP) { sendMessage({ type: 'cmd', cmd: 'showPanel' }); return; }
    if (!ui && force) buildPanel();
    if (!ui) return;
    ui.wrap.classList.remove('hidden');
    setCfg('hidden', false);
  }

  function togglePanel() {
    if (!IS_TOP) return;
    if (!ui) { buildPanel(); return; }
    var hidden = ui.wrap.classList.toggle('hidden');
    setCfg('hidden', hidden);
  }

  /* ---- 提示音 & 标题闪烁 ---- */
  var audioCtx = null;
  function beep() {
    try {
      var Ctx = window.AudioContext || window.webkitAudioContext;
      if (!Ctx) return;
      if (!audioCtx) audioCtx = new Ctx();
      if (audioCtx.state === 'suspended') audioCtx.resume();
      var t0 = audioCtx.currentTime;
      [0, 0.25, 0.5].forEach(function (offset) {
        var o = audioCtx.createOscillator();
        var g = audioCtx.createGain();
        o.type = 'sine';
        o.frequency.value = 880;
        g.gain.setValueAtTime(0.0001, t0 + offset);
        g.gain.exponentialRampToValueAtTime(0.22, t0 + offset + 0.02);
        g.gain.exponentialRampToValueAtTime(0.0001, t0 + offset + 0.18);
        o.connect(g); g.connect(audioCtx.destination);
        o.start(t0 + offset); o.stop(t0 + offset + 0.2);
      });
    } catch (e) {}
  }

  var titleTimer = null, titleBase = null;
  function flashTitle() {
    if (titleTimer) return;
    titleBase = document.title;
    var on = false;
    titleTimer = setInterval(function () {
      on = !on;
      document.title = on ? '【有弹题，请作答】' + titleBase : titleBase;
      if (!state.quiz) {
        clearInterval(titleTimer); titleTimer = null;
        document.title = titleBase;
      }
    }, 900);
  }

  /* --- 12. 快捷键（所有 frame 都注册，命中后广播到有视频的那一帧） --- */

  var HOTKEY_ACTS = {
    'alt+arrowup': function () { bumpSpeed(0.25); },
    'alt+arrowdown': function () { bumpSpeed(-0.25); },
    'alt+p': function () {
      // 用最近一次的状态来决定切到哪个方向——顶层窗口里通常没有视频元素，
      // 靠 liveMedia() 判断会永远得到"该暂停"。而且必须走广播，否则跨 iframe 无效。
      var want = state.playing ? 'pause' : 'play';
      sendMessage({ type: 'cmd', cmd: want });
      if (ui) hint(want === 'play' ? '已发送：播放' : '已发送：暂停');
    },
    'alt+m': function () { setCfg('mute', !state.cfg.mute); },
    'alt+n': function () {
      sendMessage({ type: 'cmd', cmd: 'next' });
      if (ui) hint(isChaoxing() ? '已发送：下一节' : '「下一节」仅在学习通生效');
    },
    'alt+h': function () { if (IS_TOP) togglePanel(); else sendMessage({ type: 'cmd', cmd: 'showPanel' }); }
  };

  function bumpSpeed(delta) {
    var v = round2(Math.min(16, Math.max(0.1, state.cfg.speed + delta)));
    setCfg('speed', v);
    log('倍速 →', v);
  }

  function keyOf(e) {
    var parts = [];
    if (e.altKey) parts.push('alt');
    if (e.ctrlKey && !e.altKey) parts.push('ctrl');
    if (e.shiftKey) parts.push('shift');
    var k = (e.key || '').toLowerCase();
    if (k === 'up') k = 'arrowup';
    if (k === 'down') k = 'arrowdown';
    parts.push(k);
    return parts.join('+');
  }

  window.addEventListener('keydown', function (e) {
    // 通用化后脚本会出现在所有网站上，快捷键不能无条件吞掉页面按键：
    // 只有"本帧有视频"或"顶层面板已存在"时才响应，避免在无关页面劫持 Alt 组合键。
    if (!ui && state.media.size === 0) return;

    // 在输入框里打字时不拦截
    var t = e.target;
    if (t && t.tagName && /INPUT|TEXTAREA|SELECT/.test(t.tagName)) return;
    if (t && t.isContentEditable) return;

    var fn = HOTKEY_ACTS[keyOf(e)];
    if (!fn) return;
    e.preventDefault();
    e.stopPropagation();
    try { fn(); } catch (err) {}
  }, true);

  /* --- 13. 用户交互时间戳（区分"用户手动暂停"与"平台强制暂停"） --- */

  ['mousedown', 'pointerdown', 'touchstart', 'keydown', 'click'].forEach(function (t) {
    try {
      document.addEventListener(t, function () { state.lastGesture = Date.now(); }, true);
    } catch (e) {}
  });

  /* --- 14. 启动 --- */

  installProtoPatches();

  // DOM 就绪后：面板 + 观测
  function onReady() {
    scanMedia();

    // DOM 变化 → 重新扫描。通用化后这脚本会跑在每个网站的所有 frame 上，
    // 而重度 SPA 的 DOM 变动极其频繁，必须节流：否则每次变动都做一遍
    // querySelectorAll('video, audio')，开销不可接受。
    var scanTimer = null;
    try {
      var mo = new MutationObserver(function () {
        if (scanTimer) return;
        scanTimer = setTimeout(function () { scanTimer = null; scanMedia(); }, 400);
      });
      mo.observe(document.documentElement || document, { childList: true, subtree: true });
    } catch (e) {}

    // 定时兜底扫描（有些播放器是延迟注入的，观察器未必捕捉得到）
    setInterval(scanMedia, 2500);

    // 顶层面板不在这里建：它由"页面上真的出现了视频"驱动（见 ensurePanel）
    report();
  }

  if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', onReady, { once: true });
  } else {
    onReady();
  }

  // 定时任务
  var tickCount = 0;
  setInterval(function () {
    tickCount++;

    // 指令兜底通道：高频轮询，保证播放/暂停一定能送到有视频的那一帧
    pollCmd();

    keepAliveTick();
    quizTick();
    report();

    // 跨 frame / 跨标签页的配置同步兜底，不需要那么频繁
    if (tickCount % 4 !== 0) return;
    var cfgObj = readStore(CFG_KEY);
    if (!cfgObj) return;
    Object.keys(DEFAULTS).forEach(function (k) {
      if (k in cfgObj && cfgObj[k] !== state.cfg[k]) {
        state.cfg[k] = cfgObj[k];
        applyCfgLocally(k);
        if (IS_TOP && ui) renderPanel();
      }
    });
  }, 300);

  log('脚本已注入 (frame=' + (IS_TOP ? 'top' : 'child') + ')', location.href);

})();