// ==UserScript==
// @name         百度网盘高清播放（个人版）
// @namespace    http://tampermonkey.net/
// @version      1.0.4
// @description  仅个人使用：替换播放器，获取更高清晰度 m3u8 流（v1.0.4 内置倍速 + document-start 抢先替换，移除会制造额外音频链路的 AudioContext 逻辑）
// @author       You
// @match        https://pan.baidu.com/play/video*
// @match        https://pan.baidu.com/pfile/video*
// @require      https://unpkg.com/artplayer@5.4.0/dist/artplayer.js
// @require      https://unpkg.com/hls.js@1.7.3/dist/hls.min.js
// @grant        unsafeWindow
// @grant        GM_getValue
// @grant        GM_setValue
// @run-at       document-start
// ==/UserScript==

/* global Artplayer, Hls */

(function () {
  'use strict';

  /* ==========================================================
   * 常量与全局状态
   * 说明：GM_getValue / GM_setValue 按规格书保留授权，
   * 但本版本不做设置持久化（规格第七节），因此暂不使用。
   * ========================================================== */
  const TAG = '[BDHQ]';
  const MAX_WAIT = 30000;   // 各类等待的最长时间（毫秒）
  const INTERVAL = 500;     // 轮询间隔（毫秒）

  const state = {
    videoInfo: null,        // 当前视频信息（来自 Pinia）
    vipLevel: 0,            // 如实读取的会员等级：0 普通 / 1 VIP / 2 SVIP
    qualities: [],          // 当前可用清晰度列表
    currentQuality: null,   // 当前播放的清晰度项
    art: null,              // ArtPlayer 实例
    hls: null,              // 当前 hls.js 实例
    observer: null,         // MutationObserver（路由 / 原播放器重建监控）
    lastHref: location.href,
    initializing: false,    // 防止初始化流程重入
    networkRetry: 0,        // hls 致命网络错误计数（用于升级恢复策略）
    playbackRate: 1         // [v1.0.4] 当前倍速（内置，不再依赖 Global Speed）
  };

  /* ==========================================================
   * [v1.0.2 新增] 深度媒体清理模块（修改1）
   * 背景：百度原播放器可能使用独立 <audio>（预加载/广告探测/独立音频通道）；
   * Global Speed 会扫描并接管页面所有媒体元素，持有引用后即使 DOM 移除也不释放；
   * 部分媒体元素可能位于 Shadow DOM 内，document.querySelectorAll 无法穿透。
   * 本函数只定义一次，供多处调用。
   * ========================================================== */
  // 深度清理页面中所有媒体元素（含 Shadow DOM 穿透）
  // selfVideo: 当前 ArtPlayer 的 video 元素，不清理它
  function killAllOtherMedia(selfVideo) {
    const killInRoot = (root) => {
      try {
        root.querySelectorAll('video, audio').forEach(m => {
          if (selfVideo && (m === selfVideo || m === selfVideo._video)) return;
          try {
            m.pause();
            m.muted = true;
            m.removeAttribute('src');
            if (m.srcObject) { try { m.srcObject.getTracks().forEach(t => t.stop()); } catch(e) {} m.srcObject = null; }
            m.load();
            if (m.parentNode) m.parentNode.removeChild(m);
          } catch (e) {}
        });
        // 递归穿透 Shadow DOM
        root.querySelectorAll('*').forEach(el => {
          if (el.shadowRoot) killInRoot(el.shadowRoot);
        });
      } catch (e) {}
    };
    killInRoot(document);
  }

  /* ==========================================================
   * [v1.0.4] 关于 Web Audio 的重要更正
   * v1.0.3 的 suspendAllAudioContexts() 已整体移除。
   * 原因：它每次 pause/play 都 new AudioContext() 并把 captureStream()
   * 的音频 connect(actx.destination)，等于主动新建一路 Web Audio 输出；
   * 而且它 suspend 不到 Global Speed 在扩展 isolated world 里的 context。
   * 现在的方向是「从源头只留一个 <video> + 自带倍速」，不再碰 Web Audio。
   * ========================================================== */

  // 防止同一页面重复注入执行
  if (unsafeWindow.__BDHQ_BOOTED__) {
    console.warn(TAG, '检测到脚本已在运行，跳过重复初始化');
    return;
  }
  unsafeWindow.__BDHQ_BOOTED__ = true;

  /* ==========================================================
   * 3.1 页面就绪检测模块
   * ========================================================== */
  function waitFor(conditionFn, callback, maxWait = MAX_WAIT, interval = INTERVAL, onTimeout) {
    const start = Date.now();
    const timer = setInterval(() => {
      let ok = false;
      try { ok = !!conditionFn(); } catch (e) { ok = false; }
      if (ok) {
        clearInterval(timer);
        callback();
      } else if (Date.now() - start > maxWait) {
        clearInterval(timer);
        console.error(TAG, '等待超时');
        if (typeof onTimeout === 'function') onTimeout();
      }
    }, interval);
  }

  // 读取页面侧 Vue 应用实例。
  // 优先通过 unsafeWindow.document 访问，确保能读到页面 JS 挂在 DOM 上的 __vue_app__。
  function getVueApp() {
    try {
      const doc = unsafeWindow.document || document;
      const el = doc.querySelector('#app');
      if (el && el.__vue_app__) return el.__vue_app__;
    } catch (e) { /* 继续尝试沙箱 document */ }
    const el = document.querySelector('#app');
    return el && el.__vue_app__ ? el.__vue_app__ : null;
  }

  /* ==========================================================
   * 3.2 数据提取模块
   * ========================================================== */

  // 3.2.1 从 Pinia 拿视频信息
  function getVideoInfo() {
    try {
      const vueApp = getVueApp();
      if (!vueApp) {
        console.error(TAG, '未找到 Vue 应用实例（#app.__vue_app__ 不可访问）');
        return null;
      }
      const pinia = vueApp.config.globalProperties.$pinia;
      if (!pinia) {
        console.error(TAG, '未找到 Pinia 实例（$pinia 不存在）');
        return null;
      }
      const videoinfo = pinia.state.value.videoinfo?.videoinfo;
      if (!videoinfo) {
        console.error(TAG, 'Pinia 中没有 videoinfo 数据（页面可能尚未渲染完成）');
        return null;
      }
      return {
        fs_id: videoinfo.fs_id,
        path: videoinfo.path,
        resolution: videoinfo.resolution,   // 形如 "width:1920,height:1080"
        thumbs: videoinfo.thumbs,           // 封面图集合
        server_filename: videoinfo.server_filename
      };
    } catch (e) {
      console.error(TAG, '提取视频信息失败:', e);
      return null;
    }
  }

  // 3.2.2 获取 jsToken（每次调用都取最新值，应对短时效，规格 5.1）
  function getJsToken() {
    try {
      if (unsafeWindow.jsToken) return unsafeWindow.jsToken;
      if (unsafeWindow.yunData && unsafeWindow.yunData.jsToken) return unsafeWindow.yunData.jsToken;
    } catch (e) {
      console.error(TAG, '读取 jsToken 异常:', e);
    }
    return '';
  }

  // 3.2.3 获取会员状态（如实返回，绝不伪造）
  function getVipLevel() {
    try {
      if (unsafeWindow.yunData && !unsafeWindow.yunData.neglect) {
        if (unsafeWindow.yunData.ISSVIP === 1) return 2;
        if (unsafeWindow.yunData.ISVIP === 1) return 1;
        return 0;
      }
      if (unsafeWindow.locals) {
        if (typeof unsafeWindow.locals.get === 'function') {
          if (unsafeWindow.locals.get('is_svip') === 1) return 2;
          if (unsafeWindow.locals.get('is_vip') === 1) return 1;
        } else {
          if (unsafeWindow.locals.is_svip === 1) return 2;
          if (unsafeWindow.locals.is_vip === 1) return 1;
        }
      }
    } catch (e) { /* 读取失败按普通用户处理 */ }
    return 0;
  }

  /* ==========================================================
   * 3.3 streaming URL 构造模块
   * ========================================================== */

  // 统一构造 /api/streaming 请求 URL（同域请求，直接 fetch，规格 5.6）。
  // 修正：URLSearchParams.toString() 会自动对参数值做一次 URL 编码，
  // 因此这里传入原始 path。规格书示例中手动 encodeURIComponent 后再交给
  // URLSearchParams 会造成双重编码，服务端将解析出错误路径。
  function buildStreamingUrl(type, path, vipLevel, adToken) {
    const params = new URLSearchParams({
      type: type,
      path: path,
      vip: vipLevel,
      jsToken: getJsToken()
    });
    let url = '/api/streaming?' + params.toString();
    if (adToken) url += '&adToken=' + encodeURIComponent(adToken);
    return url;
  }

  // 3.3.1 清晰度列表生成
  // 修正：规格书签名 buildQualityList(resolution, adToken, vipLevel) 内部
  // 引用了未传入的 path，这里补充 path 参数，保证代码可直接运行。
  function buildQualityList(resolution, path, adToken, vipLevel) {
    const qualities = [];

    let width = 0, height = 0;
    if (resolution) {
      const match = String(resolution).match(/width:(\d+),height:(\d+)/);
      if (match) {
        width = parseInt(match[1], 10);
        height = parseInt(match[2], 10);
      }
    }
    const pixelCount = width * height;
    if (!pixelCount) console.warn(TAG, '未能解析源视频分辨率，将只提供 480P/360P');

    // 非 SVIP 请求 1080 时服务端可能拒绝或自动降级，故不展示
    const templates = [
      { key: 1080, label: '超清 1080P', minPixels: 921600 },
      { key: 720,  label: '高清 720P',  minPixels: 409920 },
      { key: 480,  label: '流畅 480P',  minPixels: 0 },
      { key: 360,  label: '省流 360P',  minPixels: 0 }
    ];

    for (const t of templates) {
      if (pixelCount >= t.minPixels || t.minPixels === 0) {
        if (t.key === 1080 && vipLevel < 2) continue;
        qualities.push({
          html: t.label,
          url: buildStreamingUrl('M3U8_AUTO_' + t.key, path, vipLevel, adToken),
          type: 'hls',
          key: t.key
        });
      }
    }
    return qualities;
  }

  // 带 jsToken 刷新的 fetch：网络异常或 401/403 时自动重试一次（规格 5.1）
  async function fetchWithTokenRetry(makeUrl) {
    let resp;
    try {
      resp = await fetch(makeUrl(), { credentials: 'same-origin' });
    } catch (e) {
      console.warn(TAG, '请求失败，重新读取 jsToken 后重试一次:', e);
      resp = await fetch(makeUrl(), { credentials: 'same-origin' });
    }
    if (resp.status === 401 || resp.status === 403) {
      console.warn(TAG, '收到 HTTP ' + resp.status + '（jsToken 可能已过期），重试一次');
      resp = await fetch(makeUrl(), { credentials: 'same-origin' });
    }
    return resp;
  }

  // 3.3.2 adToken 获取（关键步骤）
  async function getAdToken(path, vipLevel) {
    if (vipLevel >= 2) return ''; // SVIP 不需要 adToken
    const makeUrl = () => buildStreamingUrl('M3U8_AUTO_480', path, vipLevel, '');
    try {
      const resp = await fetchWithTokenRetry(makeUrl);
      const text = await resp.text();
      let data;
      try {
        data = JSON.parse(text);
      } catch (e) {
        // 返回的不是 JSON（例如直接是 m3u8 正文），说明无需 adToken
        return '';
      }
      if (data.errno === 133 && data.adToken) {
        console.log(TAG, '获取到 adToken');
        return data.adToken;
      }
      if (typeof data.errno === 'number' && data.errno !== 0) {
        console.warn(TAG, 'streaming 接口返回 errno=' + data.errno + '，可能权限不足或凭证失效');
      }
    } catch (e) {
      console.error(TAG, '获取 adToken 失败:', e);
    }
    return '';
  }

  /* ==========================================================
   * 3.4 DOM 替换模块
   * ========================================================== */

  function findOriginalPlayer() {
    return document.getElementById('video-wrap') ||
      document.querySelector('.vp-video__player') ||
      document.querySelector('.video-content');
  }

  /* ==========================================================
   * [v1.0.4] 抢先占位（参考可正常倍速的插件做法）
   * 关键：在「原播放器容器刚插入 DOM」的那一刻就把它换成我们的容器，
   * 让百度自己的 <video> 根本没有机会被创建、也不会被 Global Speed 接管。
   * 这比等 Pinia 就绪后再去清理残留媒体要早得多，是消除第二路音频的根本。
   * ========================================================== */
  function earlyReplace() {
    const wrap = findOriginalPlayer();
    if (!wrap || document.getElementById('bdhq-player')) return false;
    const holder = document.createElement('div');
    holder.id = 'bdhq-player';
    holder.style.cssText = 'width:100%; height:100%; background:#000;';
    try {
      wrap.parentNode.replaceChild(holder, wrap);
      console.log(TAG, '已抢先占位，阻止原播放器创建 video');
      return true;
    } catch (e) {
      return false;
    }
  }

  // 3.4.1 等待原播放器出现
  // [v1.0.4] 用 MutationObserver 抢占 + 100ms 轮询兜底，尽量缩短原 video 的存活窗口
  function waitForPlayerDOM(callback, onTimeout) {
    if (findOriginalPlayer() || document.getElementById('bdhq-player')) {
      callback();
      return;
    }
    let done = false;
    const obs = new MutationObserver(() => {
      if (!done && (findOriginalPlayer() || document.getElementById('bdhq-player'))) finish();
    });
    const timer = setInterval(() => {
      if (!done && (findOriginalPlayer() || document.getElementById('bdhq-player'))) finish();
    }, 100);
    const timeoutId = setTimeout(() => {
      if (!done && typeof onTimeout === 'function') onTimeout();
      cleanup();
    }, MAX_WAIT);
    function cleanup() {
      done = true;
      obs.disconnect();
      clearInterval(timer);
      clearTimeout(timeoutId);
    }
    function finish() {
      cleanup();
      callback();
    }
    obs.observe(document, { childList: true, subtree: true });
  }

  // 3.4.2 替换播放器
  function replacePlayer(posterUrl) {
    const oldPlayer = findOriginalPlayer();
    if (!oldPlayer) {
      // [v1.0.4] earlyReplace 已经占好位，直接复用容器
      const holder = document.getElementById('bdhq-player');
      if (holder) return holder;
      console.error(TAG, '找不到原播放器');
      return null;
    }

    // 已替换过则直接复用容器
    const existing = document.getElementById('bdhq-player');
    if (existing) return existing;

    const container = document.createElement('div');
    container.id = 'bdhq-player';
    container.style.cssText = 'width:100%; height:100%; background:#000;';

    // [修复1·v1.0.2] 替换前深度清理页面上所有 video/audio（含 Shadow DOM 穿透），
    // 防止百度原播放器的媒体元素被 Global Speed 接管后在后台继续出声（双声音的根源之一）
    killAllOtherMedia(null); // 替换时还没创建 ArtPlayer，传 null（修改2a）

    // [v1.0.4] 参考可正常倍速插件的做法：原播放器可能把独立 <audio>/<video>
    // 挂在 video-wrap 之外，替换前把容器外的媒体元素也停掉（不误伤非媒体 DOM）。
    try {
      Array.from(oldPlayer.parentNode.children).forEach(sib => {
        if (sib === oldPlayer || !sib.querySelectorAll) return;
        sib.querySelectorAll('video, audio').forEach(m => {
          try { m.pause(); m.muted = true; m.removeAttribute('src'); m.load(); } catch (e) {}
        });
      });
    } catch (e) {}

    // 替换
    oldPlayer.parentNode.replaceChild(container, oldPlayer);

    // [修复2·v1.0.2] 彻底销毁原播放器实例及其全局引用
    // （内层对 pause/src/load 与 dispose 分别保护，确保 player=false 一定执行）
    try {
      if (unsafeWindow.player && typeof unsafeWindow.player.dispose === 'function') unsafeWindow.player.dispose();
      if (unsafeWindow.videoPlayer && typeof unsafeWindow.videoPlayer.dispose === 'function') unsafeWindow.videoPlayer.dispose();
      // [修改2b] 深度清理媒体元素（含 audio 与 Shadow DOM），替代原先仅清理 video 的循环
      killAllOtherMedia(null);
      if (unsafeWindow.require && unsafeWindow.require.async) {
        unsafeWindow.require.async('file-widget-1:videoPlay/context.js', (data) => {
          try {
            const ctx = data.getContext();
            if (ctx && ctx.playerInstance && ctx.playerInstance.player) {
              const p = ctx.playerInstance.player;
              try { p.pause(); p.src = ''; p.load(); } catch (e) {}
              if (typeof p.dispose === 'function') p.dispose();
              ctx.playerInstance.player = false;
            }
          } catch (e) {}
        });
      }
    } catch (e) {}

    return container;
  }

  /* ==========================================================
   * 3.5 播放器初始化模块
   * ========================================================== */

  // hls.js 播放函数（ArtPlayer customType.hls）
  function playHls(video, url, art) {
    // 销毁旧实例：清晰度切换 / 路由重入 / 刷新流地址都会再次进入这里
    if (video._bdhqHls) {
      try { video._bdhqHls.destroy(); } catch (e) { /* 忽略 */ }
      video._bdhqHls = null;
    }
    state.networkRetry = 0;

    if (typeof Hls !== 'undefined' && Hls.isSupported()) {
      const hls = new Hls({
        debug: false,
        enableWorker: true,
        lowLatencyMode: false,
        backBufferLength: 90,
        maxBufferLength: 30,
        maxMaxBufferLength: 60,
        xhrSetup: function (xhr, reqUrl) {
          // 同域请求自动携带 Cookie，无需自定义 header（规格 5.6）
        }
      });
      video._bdhqHls = hls;
      state.hls = hls;

      hls.loadSource(url);
      hls.attachMedia(video);

      // 错误处理（含规格 5.3：ts 分片签名过期 → 重新获取 m3u8）
      hls.on(Hls.Events.ERROR, function (event, data) {
        if (!data.fatal) return;
        switch (data.type) {
          case Hls.ErrorTypes.NETWORK_ERROR:
            state.networkRetry += 1;
            if (state.networkRetry <= 2) {
              console.error(TAG, 'hls 网络错误，尝试恢复...');
              hls.startLoad();
            } else {
              console.error(TAG, 'hls 网络错误反复出现（分片签名可能过期），重新获取 m3u8');
              state.networkRetry = 0;
              refreshStreamUrl();
            }
            break;
          case Hls.ErrorTypes.MEDIA_ERROR:
            console.error(TAG, 'hls 媒体错误，尝试恢复...');
            hls.recoverMediaError();
            break;
          default:
            console.error(TAG, 'hls 致命错误，无法恢复');
            hls.destroy();
            break;
        }
      });
    } else if (video.canPlayType('application/vnd.apple.mpegurl')) {
      // Safari 原生 HLS
      video.src = url;
    } else {
      console.error(TAG, '浏览器不支持 hls');
    }
  }

  // 用最新 jsToken / adToken 重建当前清晰度的流地址并重新加载
  async function refreshStreamUrl() {
    try {
      if (!state.art || !state.currentQuality || !state.videoInfo) return;
      const q = state.currentQuality;
      const adToken = await getAdToken(state.videoInfo.path, state.vipLevel);
      const freshUrl = buildStreamingUrl('M3U8_AUTO_' + q.key, state.videoInfo.path, state.vipLevel, adToken);
      // 重新赋值 url 会再次触发 customType.hls（旧 hls 实例在其中被销毁）
      state.art.url = freshUrl;
    } catch (e) {
      console.error(TAG, '刷新流地址失败:', e);
    }
  }

  function initArtPlayer(container, qualities, posterUrl, filePath) {
    if (typeof Artplayer === 'undefined') {
      console.error(TAG, 'ArtPlayer 依赖未加载（请检查 @require 是否成功）');
      return null;
    }

    const defaultQuality = qualities[0]; // 列表按清晰度降序，默认最高
    state.currentQuality = defaultQuality;

    const art = new Artplayer({
      container: container,
      url: defaultQuality.url,
      type: 'hls',
      title: filePath.split('/').pop(),
      poster: posterUrl,
      volume: 0.8,
      isLive: false,
      muted: false,
      autoplay: true,
      pip: true,
      fullscreen: true,
      fullscreenWeb: true,
      subtitleOffset: true,
      miniProgressBar: true,
      playsInline: true,
      lock: true,
      fastForward: true,
      autoPlayback: true,
      airplay: true,
      theme: '#409eff',
      lang: 'zh-cn',
      // [v1.0.4] 内置倍速：直接改 <video>.playbackRate，音频由浏览器原生时间拉伸处理，
      // 不经过 Global Speed 的 captureStream → AudioWorklet → AudioContext 链路，
      // 因此全程只有一个音频输出通道，暂停即全停。
      settings: [{
        html: '倍速',
        tooltip: '1.0x',
        selector: [
          { html: '0.5x',        value: 0.5 },
          { html: '0.75x',       value: 0.75 },
          { html: '1.0x 正常',   value: 1, default: true },
          { html: '1.25x',       value: 1.25 },
          { html: '1.5x',        value: 1.5 },
          { html: '1.75x',       value: 1.75 },
          { html: '2.0x',        value: 2 },
          { html: '2.5x',        value: 2.5 },
          { html: '3.0x',        value: 3 }
        ],
        onSelect: function (item) {
          state.playbackRate = item.value;
          try { art.video.playbackRate = item.value; } catch (e) {}
          console.log(TAG, '倍速切换:', item.value + 'x');
          return item.html;
        }
      }],
      // 额外带上 key，供切换清晰度时重建 URL 使用
      quality: qualities.map(q => ({
        default: q.key === defaultQuality.key,
        html: q.html,
        url: q.url,
        key: q.key
      })),
      customType: {
        hls: playHls
      }
    });

    // 切换清晰度 / 重新 attachMedia / 刷新流地址后浏览器可能把 playbackRate 重置为 1，
    // 因此在 loadeddata / play 时重新套用用户选择的倍速。
    const applyPlaybackRate = () => {
      try {
        const v = art.video || art._video;
        if (v && v.playbackRate !== state.playbackRate) v.playbackRate = state.playbackRate;
      } catch (e) {}
    };

    // 规格 5.2：adToken 与 (文件 + 清晰度 + 会话) 绑定，
    // 每次切换清晰度都重新获取 adToken、用最新 jsToken 重建 URL。
    // （规格 3.5 内联写法会引用已销毁的旧 hls 实例，故移到此处统一处理。）
    art.on('quality', async (q) => {
      try {
        if (!q || !q.key || !state.videoInfo) return;
        state.currentQuality = q;
        console.log(TAG, '切换清晰度:', q.html);
        const adToken = await getAdToken(state.videoInfo.path, state.vipLevel);
        const freshUrl = buildStreamingUrl('M3U8_AUTO_' + q.key, state.videoInfo.path, state.vipLevel, adToken);
        art.url = freshUrl;
      } catch (e) {
        console.error(TAG, '切换清晰度失败:', e);
      }
    });

    art.on('error', (err) => {
      console.error(TAG, '播放器错误:', err);
    });

    art.on('video:loadeddata', () => {
      console.log(TAG, '视频加载成功');
      applyPlaybackRate();
    });

    // [v1.0.4] 暂停时不再做任何 AudioContext / media 清理。
    // v1.0.3 的 suspendAllAudioContexts() 会 new AudioContext + connect(destination)，
    // 反而额外造出一路 Web Audio 输出，是「暂停后仍有一个声音停不下来」的元凶之一，
    // 已整体移除。现在暂停就是原生 pause，音频链路只有一条，自然全停。
    art.on('pause', () => {
      console.log(TAG, '检测到暂停');
    });

    // 播放时重新套用倍速（应对 url 切换后 playbackRate 被重置）
    art.on('play', () => {
      applyPlaybackRate();
    });

    return art;
  }

  /* ==========================================================
   * 规格 5.4 / 5.5：路由变化与原播放器重建监控
   * ========================================================== */

  function isPlayPage() {
    return /^\/(play|pfile)\/video/.test(location.pathname);
  }

  function teardownPlayer() {
    // [修复3·v1.0.2 / 修改2c] 深度清理页面上残留的 video/audio（含 Shadow DOM），
    // 但保留当前 ArtPlayer 自己的 video
    // （变量映射：修复说明中的 currentArt → 本脚本的 state.art；
    //   destroyCurrent → 本脚本的 teardownPlayer）
    killAllOtherMedia(state.art ? (state.art.video || state.art._video) : null);

    try {
      if (state.hls) { state.hls.destroy(); state.hls = null; }
    } catch (e) { /* 忽略 */ }
    try {
      if (state.art) { state.art.destroy(); state.art = null; }
    } catch (e) { /* 忽略 */ }
    state.currentQuality = null;
    state.networkRetry = 0;
    const container = document.getElementById('bdhq-player');
    if (container && container.parentNode) container.parentNode.removeChild(container);
  }

  function checkDomState() {
    if (state.initializing) return;

    // 5.4 SPA 路由变化：销毁旧播放器，重新走完整流程
    if (location.href !== state.lastHref) {
      state.lastHref = location.href;
      teardownPlayer();
      if (isPlayPage()) {
        console.log(TAG, '检测到播放页路由变化，准备重新替换播放器');
        // 稍等 Vue 完成渲染 / Pinia 更新，避免读到上一个视频的数据
        setTimeout(() => { main(); }, 800);
      } else {
        console.log(TAG, '已离开播放页，播放器已销毁');
      }
      return;
    }

    // 5.5 百度重新渲染导致原播放器复活：再次替换
    if (!document.getElementById('bdhq-player') && findOriginalPlayer() && state.videoInfo) {
      console.log(TAG, '检测到原播放器重新出现，再次替换');
      // [修复4·v1.0.2 / 修改2d] 重新替换前深度清理所有残留 media（含 audio 与 Shadow DOM），防止双声音
      // （变量映射：修复说明中的 startDomWatcher → 本脚本的 setupObserver/checkDomState）
      killAllOtherMedia(state.art ? (state.art.video || state.art._video) : null);
      main();
    }
  }

  function setupObserver() {
    if (state.observer) return;
    const target = document.querySelector('#app') || document.body;
    let debounceTimer = null;
    state.observer = new MutationObserver(() => {
      clearTimeout(debounceTimer);
      debounceTimer = setTimeout(checkDomState, INTERVAL);
    });
    state.observer.observe(target, { childList: true, subtree: true });
  }

  /* ==========================================================
   * 四、主入口函数
   * ========================================================== */

  async function main() {
    if (state.initializing) {
      console.warn(TAG, '初始化进行中，忽略重复调用');
      return;
    }
    state.initializing = true;
    state.lastHref = location.href;
    console.log(TAG, '脚本启动');

    const abort = (msg) => {
      console.error(TAG, msg);
      state.initializing = false;
    };

    // 1. 等待页面就绪（Vue + Pinia + videoinfo）
    waitFor(
      () => {
        const vueApp = getVueApp();
        if (!vueApp) return false;
        const pinia = vueApp.config.globalProperties.$pinia;
        return !!(pinia && pinia.state.value.videoinfo?.videoinfo);
      },
      async () => {
        try {
          console.log(TAG, '页面数据就绪');

          // 2. 提取视频信息
          const videoInfo = getVideoInfo();
          if (!videoInfo || !videoInfo.path) return abort('无法获取视频信息');
          state.videoInfo = videoInfo;
          console.log(TAG, '视频:', videoInfo.server_filename);
          console.log(TAG, '分辨率:', videoInfo.resolution);

          // 3. 获取 jsToken
          const jsToken = getJsToken();
          if (!jsToken) return abort('无法获取 jsToken（请确认已登录且页面加载完成）');

          // 4. 获取会员等级（如实读取，不伪造）
          const vipLevel = getVipLevel();
          state.vipLevel = vipLevel;
          console.log(TAG, '会员等级:', vipLevel);

          // 5. 获取 adToken
          const adToken = await getAdToken(videoInfo.path, vipLevel);

          // 6. 生成清晰度列表
          const qualities = buildQualityList(videoInfo.resolution, videoInfo.path, adToken, vipLevel);
          state.qualities = qualities;
          console.log(TAG, '可选清晰度:', qualities.map(q => q.html));
          if (qualities.length === 0) return abort('没有可用的清晰度');

          // 7. 等待并替换播放器
          waitForPlayerDOM(() => {
            try {
              // 已有存活实例时不重复初始化
              if (state.art && document.getElementById('bdhq-player')) {
                state.initializing = false;
                return;
              }
              // 清理失去 DOM 的旧实例（例如原播放器被百度重建后）
              if (state.art) teardownPlayer();

              const poster = videoInfo.thumbs
                ? Object.values(videoInfo.thumbs).slice(-1)[0]
                : '';
              const container = replacePlayer(poster);
              if (!container) return abort('找不到原播放器，替换失败');

              // 8. 初始化播放器
              const art = initArtPlayer(container, qualities, poster, videoInfo.path);
              if (!art) return abort('播放器初始化失败');
              state.art = art;
              state.initializing = false;
              console.log(TAG, '播放器初始化完成');

              // 启动路由 / 原播放器重建监控（规格 5.4 / 5.5）
              setupObserver();
            } catch (e) {
              abort('替换/初始化播放器异常: ' + (e && e.message ? e.message : e));
            }
          }, () => abort('等待原播放器 DOM 超时'));
        } catch (e) {
          abort('初始化流程异常: ' + (e && e.message ? e.message : e));
        }
      },
      MAX_WAIT,
      INTERVAL,
      () => abort('等待页面数据超时（Vue/Pinia 未就绪）')
    );
  }

  // 页面卸载时清理资源
  window.addEventListener('pagehide', teardownPlayer);

  // [v1.0.4] document-start 抢先占位：不等 Pinia 就绪，先阻止原播放器创建 <video>
  if (!earlyReplace()) {
    const earlyObserver = new MutationObserver(() => {
      if (earlyReplace()) earlyObserver.disconnect();
    });
    earlyObserver.observe(document, { childList: true, subtree: true });
    setTimeout(() => { earlyObserver.disconnect(); }, MAX_WAIT);
  }

  // 启动（规格书入口逻辑）
  if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', main);
  } else {
    main();
  }
})();