// ==UserScript==
// @name         百度网盘高清播放（个人版）
// @namespace    http://tampermonkey.net/
// @version      1.0.5
// @description  仅个人使用：替换播放器，获取更高清晰度 m3u8 流（v1.0.5 彻底 dispose 原播放器实例消除双声音；全程不干预 playbackRate，兼容 Edge/Global Speed 倍速）
// @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,        // 仅记录用户在内置菜单里选过的值，绝不自动套用
    trackedMedia: [],       // [v1.0.5] 页面脚本创建过的媒体元素（含从未插入 DOM 的）
    originalWraps: [],      // [v1.0.5] 被替换掉的原播放器容器
    destroyStarted: false   // [v1.0.5] 原播放器销毁/压制轮询是否已启动
  };

  /* ==========================================================
   * [v1.0.2 新增] 深度媒体清理模块（修改1）
   * 背景：百度原播放器可能使用独立 <audio>（预加载/广告探测/独立音频通道）；
   * Global Speed 会扫描并接管页面所有媒体元素，持有引用后即使 DOM 移除也不释放；
   * 部分媒体元素可能位于 Shadow DOM 内，document.querySelectorAll 无法穿透。
   * 本函数只定义一次，供多处调用。
   *
   * [v1.0.5 变更] 去掉 m.removeAttribute('src') 与 m.load()：
   * load() 会重置媒体元素并触发 loadstart/emptied，Global Speed 等扩展监听
   * 这些事件后会重新 hook 一次并新建一条音频链路；反复清理 = 反复制造链路。
   * 现在只做 pause / muted / 停止 srcObject 轨道 / 摘除 DOM，不触发重新加载。
   * ========================================================== */
  // 深度清理页面中所有媒体元素（含 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;
            if (m.srcObject) { try { m.srcObject.getTracks().forEach(t => t.stop()); } catch(e) {} m.srcObject = null; }
            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);
  }

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

  /* ==========================================================
   * [v1.0.5] 核心修复模块：彻底销毁百度原播放器实例
   *
   * 双声音 / 暂停后停不下来的真正原因：百度原播放器实例还活着，
   * 它持有的 <video> / <audio> 很多是 detached（被 JS 引用、从未插入 DOM，
   * 或已从 DOM 摘除），document.querySelectorAll 根本找不到，
   * 所以 DOM 清理再勤快也无效；暂停 ArtPlayer 也管不到另一个实例。
   * 必须拿到播放器实例调 dispose()，并持续压制它后续重建的媒体元素。
   *
   * 做法参考能配合浏览器倍速正常工作的脚本：
   * 500ms 轮询、最多 60 次，死等 playerInstance.player 出现后 dispose + 置 false；
   * 同时兜底「旧容器 firstChild.player」与全局 player / videoPlayer 引用。
   * ========================================================== */

  // 1) 在页面脚本创建媒体元素的第一时间就记录下来，包括从未插入 DOM 的
  try {
    const pageDoc = unsafeWindow.document || document;
    const origCreate = pageDoc.createElement;
    pageDoc.createElement = function (tagName, options) {
      const el = origCreate.call(this, tagName, options);
      try {
        if (typeof tagName === 'string' && /^(video|audio)$/i.test(tagName)) {
          if (state.trackedMedia.length < 100) state.trackedMedia.push(el);
        }
      } catch (e) {}
      return el;
    };
  } catch (e) {
    console.warn(TAG, '媒体元素创建跟踪未启用:', e);
  }

  // 2) 销毁单个播放器实例（有 dispose 用 dispose，没有就退化停掉它自己的 video）
  function disposeInstance(p) {
    if (!p) return false;
    try {
      if (typeof p.pause === 'function') p.pause();
      if (typeof p.dispose === 'function') p.dispose();
      else {
        try { p.src = ''; if (typeof p.load === 'function') p.load(); } catch (e) {}
      }
      return true;
    } catch (e) {
      return false;
    }
  }

  // 3) 启动销毁 + 压制轮询。只启动一次，之后所有旧容器都并入同一个轮询。
  function destroyOriginalPlayer(oldWrap) {
    if (oldWrap) state.originalWraps.push(oldWrap);
    if (state.destroyStarted) return;
    state.destroyStarted = true;
    console.log(TAG, '启动原播放器销毁监控');

    // 同步先处理一次全局引用
    try {
      if (unsafeWindow.player) { disposeInstance(unsafeWindow.player); unsafeWindow.player = false; }
      if (unsafeWindow.videoPlayer) { disposeInstance(unsafeWindow.videoPlayer); unsafeWindow.videoPlayer = false; }
    } catch (e) {}

    // 拿百度播放器 context：require.async 可能不回调，再补一次同步 require
    let contextData = null;
    try {
      if (unsafeWindow.require && unsafeWindow.require.async) {
        unsafeWindow.require.async('file-widget-1:videoPlay/context.js', (data) => { contextData = data; });
      }
    } catch (e) {}
    try {
      if (!contextData && unsafeWindow.require) {
        const mod = unsafeWindow.require('file-widget-1:videoPlay/context.js');
        if (mod && typeof mod.getContext === 'function') contextData = mod;
      }
    } catch (e) {}

    let tries = 0;
    setInterval(() => {
      tries += 1;
      const selfV = state.art ? (state.art.video || state.art._video) : null;

      // (a) 旧容器 firstChild.player —— 参考脚本的同步兜底路径
      state.originalWraps.forEach(wrap => {
        try {
          const node = wrap && wrap.firstChild;
          if (node && node.player) {
            disposeInstance(node.player);
            node.player = false;
          }
        } catch (e) {}
      });

      // (b) file-widget-1:videoPlay/context.js 的 playerInstance.player
      try {
        const ctx = contextData && typeof contextData.getContext === 'function'
          ? contextData.getContext() : null;
        if (ctx && ctx.playerInstance && ctx.playerInstance.player) {
          disposeInstance(ctx.playerInstance.player);
          ctx.playerInstance.player = false;
        }
      } catch (e) {}

      // (c) 全局引用（百度可能重新赋值，每次都压一遍）
      try {
        if (unsafeWindow.player) { disposeInstance(unsafeWindow.player); unsafeWindow.player = false; }
        if (unsafeWindow.videoPlayer) { disposeInstance(unsafeWindow.videoPlayer); unsafeWindow.videoPlayer = false; }
      } catch (e) {}

      // (d) 持续压制：DOM 里的 + 跟踪到的 detached 媒体元素
      //     只 pause / muted，绝不调 load()，也不碰 Web Audio / AudioContext
      const silence = (m) => {
        if (!m || m === selfV) return;
        try {
          const holder = document.getElementById('bdhq-player');
          if (holder && (holder === m || holder.contains(m))) return; // 自己的播放器一律跳过
        } catch (e) {}
        try { if (!m.paused) m.pause(); } catch (e) {}
        try { if (!m.muted) m.muted = true; } catch (e) {}
      };
      try { document.querySelectorAll('video, audio').forEach(silence); } catch (e) {}
      try { state.trackedMedia.forEach(silence); } catch (e) {}

      if (tries === 60) console.log(TAG, '原播放器销毁监控持续中（已运行 30 秒）');
    }, 500);
  }

  /* ==========================================================
   * 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.5] 抢先占位：原播放器容器一插入 DOM 就替换，并立刻启动销毁监控
   * 关键：v1.0.4 只换容器、不销毁实例，等于把原播放器留在后台继续出声。
   * ========================================================== */
  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 {
      while (wrap.nextSibling) wrap.parentNode.removeChild(wrap.nextSibling);
      const oldWrap = wrap.parentNode.replaceChild(holder, wrap);
      destroyOriginalPlayer(oldWrap);
      console.log(TAG, '已抢先占位并启动原播放器销毁监控');
      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) {
      // 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;

    // [v1.0.5] 参考可正常倍速的脚本：原播放器可能把独立 <audio>/<video>
    // 挂在 video-wrap 之后，先把这些兄弟节点整个删掉。
    while (oldPlayer.nextSibling) {
      oldPlayer.parentNode.removeChild(oldPlayer.nextSibling);
    }

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

    // 替换，并保存被摘掉的旧节点（销毁轮询要读它的 firstChild.player）
    const oldWrap = oldPlayer.parentNode.replaceChild(container, oldPlayer);

    // [修复2·v1.0.2 / v1.0.5 重写] 彻底销毁原播放器实例及其全局引用
    // 旧版一次性 dispose 三条路径都可能落空，改为 500ms 轮询持续压制。
    destroyOriginalPlayer(oldWrap);

    // [修复1·v1.0.2] 深度清理页面上所有 video/audio（含 Shadow DOM 穿透）
    // v1.0.5：已去掉会触发扩展重建音频链路的 load()
    killAllOtherMedia(null);

    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.5] 倍速策略：脚本绝不主动写 playbackRate
       * v1.0.4 的 applyPlaybackRate() 会在 play / loadeddata 时把
       * Edge 或 Global Speed 设的倍速强行改回 1x，等于把倍速功能废掉。
       * 现在只有用户主动点下面这个菜单时才写一次；之后完全放手，
       * 让浏览器原生倍速 / Global Speed 自由控制，互不打架。
       * ====================================================== */
      settings: [{
        html: '倍速',
        tooltip: '点这里选倍速',
        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
      }
    });

    // 规格 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, '视频加载成功');
      // [v1.0.5] 此处 v1.0.4 会强制套用 playbackRate，已删除，不再干预倍速
    });

    // [v1.0.5] 暂停/播放只记日志，不做任何 AudioContext、media 或 playbackRate 操作。
    // 双声音由 destroyOriginalPlayer() 的持续压制解决，倍速交给浏览器/扩展。
    art.on('pause', () => {
      console.log(TAG, '检测到暂停');
    });

    art.on('play', () => {
      console.log(TAG, '检测到播放');
    });

    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.5] document-start 抢先占位，并立刻启动原播放器销毁监控
  console.log(TAG, 'v1.0.5 启动：高清 m3u8 + 不干预倍速 + 销毁原播放器实例');
  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();
  }
})();