// ==UserScript==
// @name         学习通效率助手(蚌医版)
// @namespace    http://tampermonkey.net/
// @version      2.0
// @description  作业试卷导出Word(图文内嵌/强制A4/去黑点/彻底修复重叠) | 单题/整页搜题：题库海 + DeepSeek 网页版，两边答案逐题对比、按所选答案一键填充 | 一键复制题目给其他 AI | 课程资源下载(PDF/课件/视频, D键下载全部PDF) | 解除限制
// @author       jasminen
// @copyright    2026, jasminen
// @license      CC-BY-NC-ND-4.0
// @match        *://*.chaoxing.com/*
// @match        *://chat.deepseek.com/*
// @grant        GM_addStyle
// @grant        GM_xmlhttpRequest
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_addValueChangeListener
// @grant        GM_removeValueChangeListener
// @grant        GM_openInTab
// @grant        GM_setClipboard
// @grant        GM_addElement
// @grant        unsafeWindow
// @connect      search.tikuhai.com
// @connect      chaoxing.com
// @connect      cldisk.com
// @connect      *
// @run-at       document-start
// ==/UserScript==

/*
 * 学习通效率助手(蚌医版)
 * Copyright (c) 2026 jasminen
 *
 * 本脚本采用「知识共享 署名-非商业性使用-禁止演绎 4.0 国际」许可协议（CC BY-NC-ND 4.0）授权。
 * 协议全文：https://creativecommons.org/licenses/by-nc-nd/4.0/legalcode.zh-hans
 *
 * 简要说明（以协议全文为准）：
 * - 允许：以任何媒介、任何形式复制和分发本脚本的原样版本，例如分享给同学。
 * - 署名：分发时须注明作者 jasminen，附上本许可协议链接，并保留本版权声明。
 * - 非商业性使用：不得用于商业目的，例如出售、收费代装、捆绑销售。
 * - 禁止演绎：不得分发修改、改编或基于本脚本二次开发的版本。
 *
 * 本脚本按「现状」提供，不附带任何形式的保证。
 * 如需二次开发、商业使用等本协议以外的授权，请联系作者。
 */

(function() {
    'use strict';

    // 脚本在 document-start 注入：DeepSeek 页面要赶在它自己的代码之前接管 fetch；
    // 学习通页面要等 DOM 就绪（相当于原来的 document-end）再运行
    if (location.hostname !== 'chat.deepseek.com' && document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', main, { once: true });
    } else {
        main();
    }

    function main() {
    const isTop = window.self === window.top;
    if (isTop && document.getElementById('cx-helper-panel')) return;

    const pageWindow = typeof unsafeWindow !== 'undefined' ? unsafeWindow : window;
    const nativeAlert = window.alert.bind(window);
    const MSG_KEY = 'cxHelper';

    // ========== 通用工具 ==========

    function isTrustedOrigin(origin) {
        try {
            const host = new URL(origin).hostname;
            return host === 'chaoxing.com' || host.endsWith('.chaoxing.com');
        } catch (e) {
            return false;
        }
    }

    function post(target, data, origin = '*') {
        try { target.postMessage({ [MSG_KEY]: true, ...data }, origin); } catch (e) {}
    }

    function escapeHtml(str) {
        return str.replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
    }

    function toBase64(buf) {
        const bytes = new Uint8Array(buf);
        let binary = '';
        for (let i = 0; i < bytes.length; i += 0x8000) binary += String.fromCharCode.apply(null, bytes.subarray(i, i + 0x8000));
        return btoa(binary);
    }

    function delay(ms) {
        return new Promise(resolve => setTimeout(resolve, ms));
    }

    // D 键下载全部 PDF：正在输入或按着组合键时不触发
    function isPdfHotkey(ev) {
        if ((ev.key !== 'd' && ev.key !== 'D') || ev.ctrlKey || ev.metaKey || ev.altKey || ev.repeat) return false;
        const target = ev.target;
        return !(target && (target.isContentEditable || /^(INPUT|TEXTAREA|SELECT)$/.test(target.tagName))) && document.designMode !== 'on';
    }

    // ========== DeepSeek 网页版：在 chat.deepseek.com 标签页里代为提问 ==========
    // 学习通页面把提示词写进 GM 存储并打开 DeepSeek 标签页；这里认领任务，填入输入框发送，
    // 等回答生成完后把回答文字写回存储。两边都是同一个脚本，靠 GM_setValue / GM_addValueChangeListener 通信

    const DS_URL = 'https://chat.deepseek.com/';
    const DS_TASK_KEY = 'dsTask', DS_RESULT_KEY = 'dsResult';
    const DS_TAG = 'cx-helper-';
    const DS_ANSWER_SELECTOR = '.ds-markdown';
    const DS_ANSWER_TIMEOUT = 5 * 60 * 1000;

    // 从回答里取出 JSON 数组（模型常会包一层 ```json 代码块或带几句说明）
    function parseJsonArray(text) {
        const start = text.indexOf('['), end = text.lastIndexOf(']');
        if (start < 0 || end <= start) return null;
        try {
            const value = JSON.parse(text.slice(start, end + 1));
            return Array.isArray(value) ? value : null;
        } catch (e) {
            return null;
        }
    }

    async function waitFor(check, timeout, interval = 500) {
        const end = Date.now() + timeout;
        for (;;) {
            const value = check();
            if (value) return value;
            if (Date.now() > end) return null;
            await delay(interval);
        }
    }

    // 标签页 URL 带着任务 id；万一被站内路由去掉了，就认领 30 秒内新建、还没被认领的任务
    function claimDeepSeekTask() {
        const task = GM_getValue(DS_TASK_KEY, null);
        if (!task || task.status !== 'pending' || !Array.isArray(task.prompts)) return null;
        const nav = performance.getEntriesByType('navigation')[0];
        const urls = location.href + ' ' + (nav ? nav.name : '');
        if (!urls.includes(DS_TAG + task.id) && Date.now() - task.created > 30000) return null;
        GM_setValue(DS_TASK_KEY, { ...task, status: 'claimed' });
        return task;
    }

    function isTaskCancelled(id) {
        const task = GM_getValue(DS_TASK_KEY, null);
        return !task || task.id !== id || task.status === 'cancelled';
    }

    function dsReport(id, data) {
        GM_setValue(DS_RESULT_KEY, { id, time: Date.now(), ...data });
    }

    // DeepSeek 页面是 React，要用原生 setter 改值再触发 input，React 才会认
    function setNativeValue(field, value) {
        Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, 'value').set.call(field, value);
        field.dispatchEvent(new Event('input', { bubbles: true }));
    }

    function pressEnter(field) {
        field.focus();
        const init = { key: 'Enter', code: 'Enter', keyCode: 13, which: 13, bubbles: true, cancelable: true };
        ['keydown', 'keypress', 'keyup'].forEach(type => field.dispatchEvent(new KeyboardEvent(type, init)));
    }

    // 回车没发出去时的后备：输入区里最后一个可用按钮就是发送按钮
    function findSendButton(field) {
        for (let node = field.parentElement, depth = 0; node && depth < 6; node = node.parentElement, depth++) {
            const buttons = [...node.querySelectorAll('button, [role="button"]')]
                .filter(b => !b.disabled && b.getAttribute('aria-disabled') !== 'true');
            if (buttons.length) return buttons[buttons.length - 1];
        }
        return null;
    }

    // 优先取代码块里的内容，避免把代码块标题栏的「复制」「下载」等按钮文字带进来
    function readAnswer(node) {
        const blocks = [...node.querySelectorAll('pre')].map(pre => pre.textContent);
        return blocks.length ? blocks.join('\n') : node.innerText;
    }

    // 从正在生成的回答里取出已经完整的题目对象，不用等整个数组写完就能先显示
    function parseAnswerItems(text) {
        const items = [];
        (text.match(/\{[^{}]*\}/g) || []).forEach(chunk => {
            try {
                const item = JSON.parse(chunk);
                if (item && Number.isInteger(Number(item.no))) items.push(item);
            } catch (e) {}
        });
        return items;
    }

    async function waitForInput() {
        const input = await waitFor(() => (/sign_in|login/.test(location.pathname) ? 'login' : document.querySelector('textarea#chat-input, textarea')), 60000);
        if (input === 'login') throw new Error('DeepSeek 未登录，请先在打开的 DeepSeek 页面登录，然后重试');
        if (!input) throw new Error('没找到 DeepSeek 的输入框，页面可能改版了');
        return input;
    }

    // 输入框下方「深度思考」「智能搜索」这类开关按钮
    const DEEP_THINK_RE = /^(深度思考|DeepThink)/i;
    // 智能搜索是 DeepSeek 新版的叫法，旧版叫联网搜索，两个都认
    const WEB_SEARCH_RE = /^(智能搜索|联网搜索|Smart Search|Search)$/i;
    const CLICKABLE_RE = /button|toggle|switch/i;

    function shortText(node) {
        const text = (node.innerText || '').trim();
        return text.length < 20 ? text : '';
    }

    // 先找文字匹配的最内层元素，再往上找到按钮本身（不一定是 <button>，可能是带 button 类名的 div）
    function findToggle(re) {
        const matches = [...document.querySelectorAll('button, [role="button"], div, span')].filter(node => re.test(shortText(node)));
        const inner = matches.find(node => !matches.some(other => other !== node && node.contains(other)));
        if (!inner) return null;
        let best = inner;
        for (let node = inner; node && node !== document.body && re.test(shortText(node)); node = node.parentElement) {
            const cls = typeof node.className === 'string' ? node.className : '';
            if (node.tagName === 'BUTTON' || node.getAttribute('role') === 'button' || CLICKABLE_RE.test(cls) || getComputedStyle(node).cursor === 'pointer') best = node;
        }
        return best;
    }

    // DeepSeek 开启状态的按钮是蓝色（#4D6BFE 一类），关闭时是灰色
    function isBluish(color) {
        const m = /rgba?\(\s*([\d.]+)[,\s]+([\d.]+)[,\s]+([\d.]+)(?:[,\s/]+([\d.]+))?/.exec(color || '');
        if (!m) return false;
        const [r, g, b] = [m[1], m[2], m[3]].map(Number), alpha = m[4] == null ? 1 : Number(m[4]);
        return alpha > 0.05 && b - r > 60 && b - g > 30;
    }

    // 开关状态：aria 属性 → 按钮自身类名 → 颜色
    function isToggleOn(btn) {
        for (const attr of ['aria-pressed', 'aria-checked', 'aria-selected']) {
            const value = btn.getAttribute(attr);
            if (value === 'true' || value === 'false') return value === 'true';
        }
        const cls = typeof btn.className === 'string' ? btn.className : '';
        if (/(selected|active|checked)\b/i.test(cls)) return true;
        const style = getComputedStyle(btn);
        return [style.color, style.backgroundColor, style.borderTopColor].some(isBluish);
    }

    // 返回一句说明（用于提示使用者），设置成功或本来就是想要的状态时返回空串
    async function setToggle(re, on, name) {
        const btn = findToggle(re);
        if (!btn) return on ? `没找到「${name}」开关，请在 DeepSeek 页面手动开启` : '';
        if (isToggleOn(btn) === on) return '';
        btn.click();
        await delay(400);
        if (isToggleOn(btn) === on) return '';
        return `没能确认「${name}」已${on ? '开启' : '关闭'}，请切到 DeepSeek 页面看一下`;
    }

    // 回答区域：优先取带代码块的那个（深度思考的思考过程也是 .ds-markdown，一般没有代码块）；没有就取最后一个
    function findAnswerNode(before) {
        const nodes = [...document.querySelectorAll(DS_ANSWER_SELECTOR)].filter(n => !before.has(n));
        return [...nodes].reverse().find(n => n.querySelector('pre')) || nodes[nodes.length - 1] || null;
    }

    // ---------- 直接读取 DeepSeek 的回答数据流 ----------
    // 后台标签页里 DeepSeek 页面常常暂停刷新，页面上的文字要等切过去才出现；但网络数据照常接收。
    // 脚本管理器通常把脚本放在隔离环境里运行，改不到页面自己的 fetch，所以往页面里插一段代码（PAGE_HOOK），
    // 在页面环境里接管 fetch，把回答数据流（text/event-stream）原样转发回来，由这里解析。
    const COMPLETION_URL_RE = /\/chat\/(completion|regenerate|resume_stream|continue)/;
    const SSE_EVENT = 'cx-helper-sse';
    const stream = { seen: 0, ended: 0, text: '' }; // seen / ended：已开始 / 已结束的回答请求数；text：当前这次回答的文字
    let streamHooked = false;

    // 运行在页面环境里；和脚本之间只传字符串（隔离环境之间传对象会读不到）。
    // 不替换 fetch 本身（页面可能早就存了一份 fetch 的引用，替换了也拦不到），而是：
    // 1. 拦截 Response 的 body：不管页面用哪个 fetch，只要读取流式回答（text/event-stream），就分出一份给脚本
    // 2. 拦截 XMLHttpRequest：有的网站用它接收流式回答
    function pageHook(eventName, urlSource, marker) {
        if (window.__cxHelperHooked) return;
        window.__cxHelperHooked = true;
        document.documentElement.setAttribute('data-cx-hook', marker);
        const urlRe = new RegExp(urlSource);
        const send = (type, data) => document.dispatchEvent(new CustomEvent(eventName, { detail: JSON.stringify({ type, data }) }));
        const isStream = (type, url) => /event-stream/i.test(type || '') || urlRe.test(url || '');

        // 1. Response.body
        try {
            const desc = Object.getOwnPropertyDescriptor(Response.prototype, 'body');
            const tapped = new WeakMap();
            Object.defineProperty(Response.prototype, 'body', {
                configurable: true,
                enumerable: desc.enumerable,
                get() {
                    if (tapped.has(this)) return tapped.get(this);
                    const body = desc.get.call(this);
                    let type = '';
                    try { type = this.headers.get('content-type'); } catch (e) {}
                    if (!body || !isStream(type, this.url)) return body;
                    const [pageBranch, ours] = body.tee();
                    tapped.set(this, pageBranch);
                    console.log('[学习通助手] 已接管回答数据流（fetch）', this.url);
                    send('start', this.url);
                    const reader = ours.getReader(), decoder = new TextDecoder();
                    const pump = () => reader.read().then(({ done, value }) => {
                        if (done) return send('end', '');
                        send('chunk', decoder.decode(value, { stream: true }));
                        return pump();
                    });
                    pump().catch(() => send('end', ''));
                    return pageBranch;
                }
            });
        } catch (e) {
            console.warn('[学习通助手] 拦截 fetch 回答失败', e);
        }

        // 2. XMLHttpRequest
        try {
            const proto = XMLHttpRequest.prototype, originalOpen = proto.open, originalSend = proto.send;
            proto.open = function(method, url) {
                this.__cxUrl = String(url);
                return originalOpen.apply(this, arguments);
            };
            proto.send = function() {
                const xhr = this;
                let started = false, seen = 0;
                const onData = () => {
                    if (xhr.readyState < 3) return;
                    if (!started) {
                        if (!isStream(xhr.getResponseHeader('content-type'), xhr.__cxUrl)) return;
                        started = true;
                        console.log('[学习通助手] 已接管回答数据流（XHR）', xhr.__cxUrl);
                        send('start', xhr.__cxUrl);
                    }
                    if (!xhr.responseType || xhr.responseType === 'text') {
                        const text = xhr.responseText || '';
                        if (text.length > seen) {
                            send('chunk', text.slice(seen));
                            seen = text.length;
                        }
                    }
                    if (xhr.readyState === 4) send('end', '');
                };
                xhr.addEventListener('readystatechange', onData);
                xhr.addEventListener('progress', onData);
                return originalSend.apply(this, arguments);
            };
        } catch (e) {
            console.warn('[学习通助手] 拦截 XHR 回答失败', e);
        }
    }

    function notifyStream() {
        document.dispatchEvent(new CustomEvent('cx-helper-stream'));
    }

    // 从一条数据里取出新增的文字。DeepSeek 用过几种格式，这里都兼容：
    // 旧格式 choices[0].delta.content；新格式 { p: 路径, o: 操作, v: 值 }，路径省略时沿用上一条的路径
    let streamPath = '', sseBuffer = '';
    function collectContent(value) {
        if (!value || typeof value !== 'object') return '';
        if (Array.isArray(value)) return value.map(collectContent).join('');
        return Object.keys(value).map(key => (key === 'content' && typeof value[key] === 'string' ? value[key] : collectContent(value[key]))).join('');
    }

    function extractDelta(event) {
        const choice = event.choices && event.choices[0];
        if (choice && choice.delta) return typeof choice.delta.content === 'string' ? choice.delta.content : '';
        if (typeof event.p === 'string') streamPath = event.p;
        if (typeof event.v === 'string') return !streamPath || /content/.test(streamPath) ? event.v : '';
        return event.v && typeof event.v === 'object' ? collectContent(event.v) : '';
    }

    function handleSseLine(line) {
        if (!line.startsWith('data:')) return;
        try { stream.text += extractDelta(JSON.parse(line.slice(5).trim())); } catch (e) {}
    }

    function onSseEvent(ev) {
        let msg;
        try { msg = JSON.parse(ev.detail); } catch (e) { return; }
        if (msg.type === 'start') {
            stream.seen++;
            stream.text = sseBuffer = streamPath = '';
        } else if (msg.type === 'chunk') {
            sseBuffer += String(msg.data);
            const lines = sseBuffer.split('\n');
            sseBuffer = lines.pop();
            lines.forEach(handleSseLine);
        } else if (msg.type === 'end') {
            if (sseBuffer) handleSseLine(sseBuffer);
            sseBuffer = '';
            stream.ended++;
        }
        notifyStream();
    }

    // 监听代码是否装进了页面环境：'page' 插入页面的 <script>；'direct' 脚本本身就运行在页面环境；'' 失败
    let hookMode = '';

    function hookCompletionStream() {
        if (streamHooked) return;
        streamHooked = true;
        document.addEventListener(SSE_EVENT, onSseEvent);
        const args = [SSE_EVENT, COMPLETION_URL_RE.source];
        // 脚本管理器让脚本直接跑在页面环境里时（unsafeWindow 就是 window），直接装，不受页面安全策略影响
        if (pageWindow === window) {
            pageHook(...args, 'direct');
            hookMode = 'direct';
        } else {
            const code = `(${pageHook})(${args.map(a => JSON.stringify(a)).join(', ')}, "page");`;
            const parent = document.head || document.documentElement;
            try {
                // GM_addElement 插入的脚本一般不受页面安全策略（CSP）限制；没有这个接口时退回普通 <script>
                const script = typeof GM_addElement === 'function'
                    ? GM_addElement(parent, 'script', { textContent: code })
                    : parent.appendChild(Object.assign(document.createElement('script'), { textContent: code }));
                if (script && script.remove) script.remove();
            } catch (e) {
                console.warn('[学习通助手] 插入监听代码出错', e);
            }
            // 内联脚本插入时同步执行，执行了就会留下标记
            hookMode = document.documentElement.getAttribute('data-cx-hook') || '';
        }
        console.log(hookMode
            ? `[学习通助手] 回答数据流监听已就绪（${hookMode === 'direct' ? '脚本直接运行在页面环境' : '已插入页面'}）`
            : '[学习通助手] 回答数据流监听没能装进页面（可能被页面安全策略拦截），只能读取页面文字');
    }

    // 回答文字里取最后一个 JSON 数组（深度思考时前面是思考过程，里面可能有草稿）
    function lastJsonArray(text) {
        const fence = text.lastIndexOf('```json');
        if (fence >= 0) {
            const value = parseJsonArray(text.slice(fence));
            if (value) return value;
        }
        const end = text.lastIndexOf(']');
        for (let i = text.lastIndexOf('[', end); i >= 0; i = i > 0 ? text.lastIndexOf('[', i - 1) : -1) {
            try {
                const value = JSON.parse(text.slice(i, end + 1));
                if (Array.isArray(value) && value.some(item => item && item.no != null)) return value;
            } catch (e) {}
        }
        return null;
    }

    // 在后台暂停时让 DeepSeek 标签页的标题闪烁，方便使用者在标签栏里找到它；切过来就恢复
    let titleFlashing = false;
    function flashTitle() {
        if (titleFlashing || document.visibilityState === 'visible') return;
        titleFlashing = true;
        const original = document.title, alertTitle = '⚠ 请点我｜DeepSeek 已暂停';
        let on = true;
        document.title = alertTitle;
        const timer = setInterval(() => {
            on = !on;
            document.title = on ? alertTitle : original;
        }, 1000);
        const stop = () => {
            if (document.visibilityState !== 'visible') return;
            clearInterval(timer);
            document.title = original;
            document.removeEventListener('visibilitychange', stop);
            titleFlashing = false;
        };
        document.addEventListener('visibilitychange', stop);
    }

    // expected 是这一批的题数；onItems 在已完成的题目数增加时回调，用来边生成边显示；onHint 用来提示使用者
    async function askDeepSeek(prompt, expected, deepThink, onItems, onHint) {
        const input = await waitForInput();
        const before = new Set(document.querySelectorAll(DS_ANSWER_SELECTOR));
        const seenBefore = stream.seen, endedBefore = stream.ended;
        setNativeValue(input, prompt);
        await delay(200);
        // 新对话发出第一条消息后页面会跳转，输入框可能被重新创建，所以「已脱离页面」也算发送成功
        const sent = () => !input.isConnected || !input.value;
        pressEnter(input);
        if (!await waitFor(sent, 1500, 200)) {
            const button = findSendButton(input);
            if (button && !sent()) button.click();
            if (!await waitFor(sent, 5000, 200)) throw new Error('没能在 DeepSeek 页面发送消息，页面可能改版了');
        }
        const started = Date.now();

        // 何时算答完：
        // A. 读到了回答数据流（首选，后台也不受影响）：数据流结束就解析，解析出题目立即返回
        // B. 读不到数据流时看页面文字：这一批的题全部答到、JSON 数组闭合就返回；
        //    「文字多久没变」只在标签页可见时计时——后台时页面可能暂停刷新，文字不变不代表答完
        return new Promise((resolve, reject) => {
            let last = '', stableFor = 0, lastTick = Date.now(), reported = 0, settled = false, hinted = false;
            const finish = (error, text) => {
                if (settled) return;
                settled = true;
                observer.disconnect();
                document.removeEventListener('cx-helper-stream', check);
                clearInterval(ticker);
                clearTimeout(timer);
                const source = stream.seen > seenBefore ? '数据流'
                    : '页面文字（' + (hookMode ? '监听已就绪，但没看到回答数据流，DeepSeek 的接收方式可能变了' : '监听没能装进页面') + '）';
                console.log(`[学习通助手] DeepSeek 本批用时 ${((Date.now() - started) / 1000).toFixed(1)} 秒，来源：${source}` + (error ? '（' + error.message + '）' : ''));
                error ? reject(error) : resolve(text);
            };
            const report = items => {
                if (items.length > reported) {
                    reported = items.length;
                    onItems(items);
                }
            };
            const check = () => {
                if (settled) return;
                const now = Date.now(), elapsed = now - lastTick;
                lastTick = now;

                // A. 数据流
                if (stream.seen > seenBefore) {
                    const done = stream.ended > endedBefore;
                    // 深度思考时思考过程里可能有草稿，等数据流结束再解析
                    if (!deepThink) report(parseAnswerItems(stream.text));
                    if (done) {
                        const array = lastJsonArray(stream.text);
                        if (array) {
                            report(array);
                            return finish(null, JSON.stringify(array));
                        }
                        // 数据流格式可能变了，解析不出来，改看页面文字
                    }
                }

                // B. 页面文字
                const node = findAnswerNode(before);
                const text = node ? readAnswer(node) : '';
                const visible = document.visibilityState === 'visible';
                if (text !== last) {
                    last = text;
                    stableFor = 0;
                } else if (visible) {
                    stableFor += elapsed;
                }
                const streamDone = stream.ended > endedBefore;
                // 数据流用不上（没读到，或读到了却解析不出来）、页面又在后台没刷新时，提醒使用者切过去看一眼
                const streamUseless = stream.seen === seenBefore ? now - started > 20000 : streamDone;
                if (!hinted && !visible && streamUseless) {
                    hinted = true;
                    flashTitle();
                    onHint('DeepSeek 页面在后台暂停了刷新，切到 DeepSeek 标签页看一眼即可继续');
                }
                if (!text) return;
                const inCode = !!node.querySelector('pre');
                const items = inCode || !deepThink ? parseAnswerItems(text) : [];
                report(items);
                if ((items.length >= expected && parseJsonArray(text))
                    || (streamDone && stableFor >= 500 && items.length)
                    || (items.length && stableFor >= 5000)
                    || stableFor >= 20000) return finish(null, text);

            };
            let scheduled = false;
            const observer = new MutationObserver(() => {
                if (scheduled) return;
                scheduled = true;
                Promise.resolve().then(() => { scheduled = false; check(); });
            });
            observer.observe(document.body, { childList: true, subtree: true, characterData: true });
            document.addEventListener('cx-helper-stream', check);
            const ticker = setInterval(check, 500);
            const timer = setTimeout(() => finish(new Error('DeepSeek 回答超时')), DS_ANSWER_TIMEOUT);
        });
    }

    async function runDeepSeekWorker() {
        const task = claimDeepSeekTask();
        if (!task) return;
        const texts = [], total = task.prompts.length, deepThink = !!task.deepThink;
        try {
            // 深度思考、智能搜索按面板里的开关设置
            await waitForInput();
            await waitFor(() => findToggle(DEEP_THINK_RE) || findToggle(WEB_SEARCH_RE), 3000, 200);
            const notes = [await setToggle(DEEP_THINK_RE, deepThink, '深度思考'), await setToggle(WEB_SEARCH_RE, !!task.webSearch, '智能搜索')].filter(Boolean);
            for (const [i, prompt] of task.prompts.entries()) {
                if (isTaskCancelled(task.id)) return;
                dsReport(task.id, { status: 'running', done: i, total, notes });
                const expected = Array.isArray(task.counts) ? task.counts[i] : 1;
                texts.push(await askDeepSeek(String(prompt), expected, deepThink, items => {
                    if (!isTaskCancelled(task.id)) dsReport(task.id, { status: 'running', done: i, total, partial: items });
                }, hint => {
                    if (!isTaskCancelled(task.id)) dsReport(task.id, { status: 'running', done: i, total, hint });
                }));
            }
            dsReport(task.id, { status: 'done', texts });
        } catch (e) {
            console.error('[学习通助手] DeepSeek 作答失败', e);
            dsReport(task.id, { status: 'error', error: e.message || String(e), texts });
        }
    }

    // 有待处理的任务（学习通页面刚发起的）才接管 DeepSeek 页面，平时自己用 DeepSeek 不受影响
    function hasPendingTask() {
        const task = GM_getValue(DS_TASK_KEY, null);
        return !!task && task.status === 'pending' && Date.now() - task.created < 120000;
    }

    if (location.hostname === 'chat.deepseek.com') {
        // 这里在 document-start 执行：先接管 fetch，再等页面加载好后提问
        if (isTop && hasPendingTask()) {
            hookCompletionStream();
            runDeepSeekWorker();
        }
        return;
    }

    // ========== 题目识别 ==========

    const QUESTION_SELECTOR = '.questionLi, .TiMu';
    const STEM_SELECTORS = ['.qtContent', '.Zy_TItle .fontLabel', '.mark_name', '.Zy_TItle', 'h3'];
    const OPTION_SELECTORS = ['.mark_letter li', '.answerBg .answer_p', '.Zy_ulTop li .after', '.Zy_ulTop li'];
    const OPTION_RE = /^(?:[(（]\s*([A-Ja-j])\s*[)）]|([A-Ja-j])\s*[.．、:：)）])\s*([\s\S]*)$/;
    const JUDGE_OPTION_RE = /^(对|错|正确|错误|√|×)$/;

    // 只取最内层，避免外层容器和题目重复计数
    function findQuestionElements(doc) {
        return [...doc.querySelectorAll(QUESTION_SELECTOR)].filter(q => !q.querySelector(QUESTION_SELECTOR));
    }

    // 精确匹配逐字比对：题干原样保留，只剥「1、」「【单选题】」「(单选题, 2分)」这类前缀
    function stripStemPrefix(stem) {
        let prev;
        do {
            prev = stem;
            stem = stem
                .replace(/^\s*\d+\s*[、.．:：](?!\d)\s*/, '')
                .replace(/^\s*[【\[(（]\s*(?:单选|多选|判断|填空|简答|名词解释|论述|计算|问答|选择|阅读理解|完形填空|排序|连线|其[它他])题?[^】\]）)]*[】\]）)]\s*/, '');
        } while (stem !== prev);
        return stem.trim();
    }

    function stripOptionPrefix(text) {
        const match = OPTION_RE.exec(text.trim());
        return (match ? match[3] : text).trim();
    }

    // 识别页面上的题目：学习通作业/考试（.questionLi）和章节测验（.TiMu）两套结构
    // idx 是题目在 findQuestionElements 中的下标，填答时靠它找回对应元素（题干为空的题会被过滤，不能用数组下标）
    function collectQuestions(doc) {
        return findQuestionElements(doc).map((q, idx) => {
            const stemEl = STEM_SELECTORS.map(sel => q.querySelector(sel)).find(Boolean);
            const optionSel = OPTION_SELECTORS.find(sel => q.querySelector(sel));
            let options = optionSel ? [...q.querySelectorAll(optionSel)].map(o => stripOptionPrefix(o.innerText)).filter(Boolean) : [];
            // 判断题统一传「对/错」
            if (options.length && options.every(o => JUDGE_OPTION_RE.test(o))) options = ['对', '错'];
            const rawStem = stemEl ? stemEl.innerText : '';
            return {
                idx,
                stem: stripStemPrefix(rawStem),
                options,
                // 多选题：选项用复选框，或题干前缀写着「多选题」
                multi: !!q.querySelector('.num_option_dx, input[type="checkbox"]') || /^\s*(?:\d+\s*[、.．:：]\s*)?[【\[(（]\s*多选/.test(rawStem),
                encrypted: !!q.querySelector('.font-cxsecret')
            };
        }).filter(q => q.stem);
    }

    // ========== 自动填答 ==========

    // 可点选的选项：作业/考试是 .answerBg（内含 .num_option 和 .answer_p），章节测验是 li 里的 radio/checkbox
    const CHOICE_SELECTORS = ['.answerBg', '.Zy_ulTop li', '.Zy_ulBottom li'];
    const JUDGE_TRUE_RE = /^(对|正确|√|true|t)$/;
    const JUDGE_FALSE_RE = /^(错|错误|×|false|f)$/;
    const FILLED_BG = 'rgba(52, 199, 89, 0.2)';

    // 比对用：全角转半角、去空白和末尾标点、转小写
    function normalizeText(str) {
        return String(str)
            .replace(/[！-～]/g, c => String.fromCharCode(c.charCodeAt(0) - 0xFEE0))
            .replace(/\s+/g, '')
            .replace(/[.。;,、]+$/, '')
            .toLowerCase();
    }

    function judgeValue(str) {
        const text = normalizeText(str);
        return JUDGE_TRUE_RE.test(text) ? '对' : JUDGE_FALSE_RE.test(text) ? '错' : '';
    }

    // 页面选项的字母优先取 .num_option 的 data 属性，选项顺序被打乱时也不会错位
    function readOption(opt, i) {
        const input = opt.querySelector('input[type="radio"], input[type="checkbox"]');
        const marker = opt.querySelector('.num_option, .num_option_dx');
        const data = (marker && marker.getAttribute('data')) || (input && input.value) || '';
        const text = stripOptionPrefix((opt.querySelector('.answer_p, .after') || opt).innerText || '');
        return {
            el: opt,
            input,
            letter: /^[A-J]$/i.test(data) ? data.toUpperCase() : String.fromCharCode(65 + i),
            text: normalizeText(text),
            judge: /^true$/i.test(data) ? '对' : /^false$/i.test(data) ? '错' : judgeValue(text)
        };
    }

    function isOptionSelected(o) {
        if (o.input) return o.input.checked;
        return o.el.getAttribute('aria-checked') === 'true' || !!o.el.querySelector('.check_answer, .check_answer_dx');
    }

    // 判断题按对/错匹配；其余按选项原文匹配，原文一个都对不上时才退回按字母匹配
    function pickOptions(options, answers) {
        if (options.every(o => o.judge)) {
            const want = answers.map(a => judgeValue(a.text)).find(Boolean);
            if (want) return options.filter(o => o.judge === want);
        }
        const texts = new Set(answers.map(a => normalizeText(a.text)));
        const byText = options.filter(o => texts.has(o.text));
        if (byText.length) return byText;
        const letters = new Set(answers.map(a => a.letter).filter(Boolean));
        return options.filter(o => letters.has(o.letter));
    }

    function fillChoice(options, answers) {
        let targets = pickOptions(options, answers);
        if (!targets.length) return false;
        const multi = options.some(o => (o.input && o.input.type === 'checkbox') || o.el.querySelector('.num_option_dx'));
        if (!multi) targets = targets.slice(0, 1);
        options.forEach(o => {
            const want = targets.includes(o);
            // 多选题点击是切换，先看当前状态：该选的没选就点，不该选的已选就点掉；单选题点目标即可
            if (want !== isOptionSelected(o) && (want || multi)) (o.input || o.el).click();
            if (want) o.el.style.backgroundColor = FILLED_BG;
        });
        return true;
    }

    // 学习通填空/简答用 UEditor，textarea 只是隐藏的底座，要写进编辑器实例才会被保存
    function findEditor(field) {
        const UE = pageWindow.UE;
        if (!UE || !UE.instants || !field.id) return null;
        return Object.values(UE.instants).find(ed => ed && (ed.key === field.id || ed.textarea === field)) || null;
    }

    function setFieldValue(field, value) {
        const editor = findEditor(field);
        if (editor) {
            editor.setContent(escapeHtml(value));
            return;
        }
        field.value = value;
        field.dispatchEvent(new Event('input', { bubbles: true }));
        field.dispatchEvent(new Event('change', { bubbles: true }));
        field.style.backgroundColor = FILLED_BG;
    }

    // 多个空按顺序对应；只有一个输入框（简答题）时把所有答案放一起
    function fillBlanks(fields, answers) {
        const values = answers.map(a => a.text).filter(Boolean);
        if (!values.length) return false;
        const list = fields.length === 1 ? [values.join('；')] : values;
        fields.forEach((field, i) => { if (list[i] != null) setFieldValue(field, list[i]); });
        return true;
    }

    function showAnswerHint(q, display) {
        const existing = q.querySelector('.cx-auto-answer-hint');
        if (existing) existing.remove();
        const hint = document.createElement('div');
        hint.className = 'cx-auto-answer-hint';
        hint.style.cssText = 'margin-top:8px;padding:8px 12px;background:rgba(201,100,66,0.08);border-left:3px solid #c96442;border-radius:6px;color:#141413;font-weight:500;font-size:13px;';
        hint.textContent = '答案：' + display;
        q.appendChild(hint);
    }

    // 把答案填进页面上的题目：选择/判断题点选项，填空/简答题写输入框；填不进去就在题目下方显示答案
    // answers 是 [{ text: 选项原文或填空答案, letter: 题库里的字母 }]，display 是给人看的答案文字
    function fillQuestion(q, { answers, display }) {
        if (!q || !Array.isArray(answers)) return false;
        answers = answers.filter(a => a && typeof a.text === 'string');
        if (!answers.length) return false;
        const optionSel = CHOICE_SELECTORS.find(sel => q.querySelector(sel));
        if (optionSel) {
            if (fillChoice([...q.querySelectorAll(optionSel)].map(readOption), answers)) return true;
        } else {
            const fields = [...q.querySelectorAll('input[type="text"], textarea')].filter(f => !f.disabled && !f.readOnly);
            if (fields.length && fillBlanks(fields, answers)) return true;
        }
        if (typeof display === 'string' && display) showAnswerHint(q, display);
        return false;
    }

    // ========== 资源识别 ==========

    // 学习通章节页中，每个附件/视频/PDF 都通过带有 objectid 属性的 iframe 嵌入
    function collectObjectIds(doc) {
        let frames = doc.querySelectorAll('.ans-attach-ct iframe[objectid], .ans-cc iframe[objectid]');
        if (!frames.length) frames = doc.querySelectorAll('iframe[objectid]');
        return [...new Set([...frames].map(f => f.getAttribute('objectid')).filter(Boolean))];
    }

    // ========== 解除复制粘贴限制 ==========

    const UNLOCK_CSS = `* { user-select: text !important; -webkit-user-select: text !important; -moz-user-select: text !important; -ms-user-select: text !important; }`;
    const BLOCKED_EVENTS = ['selectstart', 'copy', 'cut', 'paste', 'contextmenu', 'dragstart'];
    const unlockedDocs = new WeakSet();
    const watchedFrames = new WeakSet();
    let copyUnlocked = false;

    function stopEvent(ev) { ev.stopImmediatePropagation(); }

    // 只拦截复制粘贴相关快捷键，其它按键照常交给页面处理
    function stopCopyShortcut(ev) {
        if ((ev.ctrlKey || ev.metaKey) && ['a', 'c', 'v', 'x'].includes((ev.key || '').toLowerCase())) ev.stopImmediatePropagation();
    }

    function watchFrame(frame) {
        if (watchedFrames.has(frame)) return;
        watchedFrames.add(frame);
        const tryUnlock = () => { try { unlockDocument(frame.contentDocument); } catch (e) {} };
        tryUnlock();
        frame.addEventListener('load', tryUnlock);
    }

    function unlockDocument(doc) {
        if (!doc || !doc.documentElement || unlockedDocs.has(doc)) return;
        const win = doc === document ? pageWindow : doc.defaultView;
        if (!win) return;
        unlockedDocs.add(doc);

        const style = doc.createElement('style');
        style.textContent = UNLOCK_CSS;
        (doc.head || doc.documentElement).appendChild(style);

        [doc, doc.documentElement, doc.body].forEach(target => {
            if (!target) return;
            BLOCKED_EVENTS.forEach(evt => {
                target['on' + evt] = null;
                if (target.removeAttribute) target.removeAttribute('on' + evt);
            });
        });
        // 在 window 捕获阶段拦截，页面上任何元素的限制处理器都收不到这些事件
        BLOCKED_EVENTS.forEach(evt => win.addEventListener(evt, stopEvent, true));
        win.addEventListener('keydown', stopCopyShortcut, true);

        // 屏蔽"禁止粘贴"之类的弹窗
        try { win.alert = typeof exportFunction === 'function' ? exportFunction(function() {}, win) : function() {}; } catch (e) {}

        // 同源 iframe 直接处理；跨域 iframe 由其中运行的脚本实例处理
        doc.querySelectorAll('iframe, frame').forEach(watchFrame);
        new MutationObserver(mutations => mutations.forEach(m => m.addedNodes.forEach(node => {
            if (node.nodeType !== 1) return;
            if (node.matches('iframe, frame')) watchFrame(node);
            node.querySelectorAll('iframe, frame').forEach(watchFrame);
        }))).observe(doc.documentElement, { childList: true, subtree: true });
    }

    function enableCopyUnlock() {
        copyUnlocked = true;
        unlockDocument(document);
    }

    // ========== 内容提取 ==========

    const MHT_BASE = 'file:///C:/cx_helper/';
    const MAX_IMAGE_WIDTH = 553; // A4 版心宽度 595.3pt - 2×90pt ≈ 415pt ≈ 553px
    const WORD_IMAGE_TYPES = ['image/png', 'image/jpeg', 'image/gif', 'image/bmp'];

    function scoreDocument(doc) {
        if (!doc || !doc.body) return 0;
        return (doc.querySelector('.mark_table') ? 1000 : 0) + findQuestionElements(doc).length;
    }

    function findContentContainer(doc) {
        const table = doc.querySelector('.mark_table');
        if (table) return table;
        const questions = findQuestionElements(doc);
        if (questions.length === 1) return questions[0];
        if (questions.length > 1) {
            let ancestor = questions[0].parentElement;
            while (ancestor && !questions.every(q => ancestor.contains(q))) ancestor = ancestor.parentElement;
            if (ancestor) return ancestor;
        }
        return doc.body;
    }

    function getTitle(doc) {
        const titleEl = doc.querySelector('h2') || doc.querySelector('.mark_title') || doc.querySelector('.mark_name');
        const title = ((titleEl ? titleEl.innerText : '') || doc.title || '').replace(/\s+/g, ' ').trim();
        return (!title || title === '学习通') ? '学习通题库' : title;
    }

    // 去黑点：把 ul/ol/li 换成 div。倒序处理，先换内层再换外层，嵌套列表也能处理干净
    function flattenLists(root) {
        [...root.querySelectorAll('ul, ol, li')].reverse().forEach(el => {
            const div = root.ownerDocument.createElement('div');
            div.className = el.className;
            if (el.tagName === 'LI') {
                div.style.marginLeft = '20px';
                div.style.marginBottom = '5px';
            }
            while (el.firstChild) div.appendChild(el.firstChild);
            el.replaceWith(div);
        });
    }

    function gmFetch(url) {
        return new Promise(resolve => {
            GM_xmlhttpRequest({
                method: 'GET', url, responseType: 'arraybuffer', timeout: 20000,
                headers: { Referer: location.href },
                onload: res => resolve(res.status >= 200 && res.status < 300 ? res : null),
                onerror: () => resolve(null), ontimeout: () => resolve(null), onabort: () => resolve(null)
            });
        });
    }

    function sniffImageType(buf) {
        const head = String.fromCharCode.apply(null, new Uint8Array(buf, 0, Math.min(12, buf.byteLength)));
        if (head.startsWith('\x89PNG')) return 'image/png';
        if (head.startsWith('\xFF\xD8')) return 'image/jpeg';
        if (head.startsWith('GIF8')) return 'image/gif';
        if (head.startsWith('BM')) return 'image/bmp';
        if (head.startsWith('RIFF') && head.slice(8, 12) === 'WEBP') return 'image/webp';
        return null;
    }

    // 下载图片并转成 Word 支持的格式，失败返回 null
    async function loadImage(url) {
        let buf, mime;
        if (url.startsWith('data:')) {
            const comma = url.indexOf(',');
            const meta = url.slice(5, comma), body = url.slice(comma + 1);
            mime = meta.split(';')[0];
            buf = (/;base64$/i.test(meta) ? Uint8Array.from(atob(body), c => c.charCodeAt(0)) : new TextEncoder().encode(decodeURIComponent(body))).buffer;
        } else {
            const res = await gmFetch(url);
            if (!res || !res.response) return null;
            buf = res.response;
            mime = (/content-type:\s*([^;\r\n]+)/i.exec(res.responseHeaders || '') || [])[1];
        }
        mime = (sniffImageType(buf) || mime || '').trim().toLowerCase();
        if (!mime.startsWith('image/')) return null;

        let bitmap = null;
        try { bitmap = await createImageBitmap(new Blob([buf], { type: mime })); } catch (e) {}

        let base64;
        if (WORD_IMAGE_TYPES.includes(mime)) {
            base64 = toBase64(buf);
        } else {
            // webp 等 Word 不认识的格式转成 png
            if (!bitmap) return null;
            const canvas = document.createElement('canvas');
            canvas.width = bitmap.width;
            canvas.height = bitmap.height;
            canvas.getContext('2d').drawImage(bitmap, 0, 0);
            base64 = canvas.toDataURL('image/png').split(',')[1];
            mime = 'image/png';
        }
        const image = { mime, ext: mime.split('/')[1].replace('jpeg', 'jpg'), base64, width: bitmap ? bitmap.width : 0, height: bitmap ? bitmap.height : 0 };
        if (bitmap) bitmap.close();
        return image;
    }

    // 图片打包进 MHT：img 的 src 指向对应的 Content-Location
    async function embedImages(root, doc) {
        const images = [], byUrl = new Map();
        await Promise.all([...root.querySelectorAll('img')].map(async img => {
            const raw = img.getAttribute('data-original') || img.getAttribute('data-src') || img.getAttribute('src');
            if (!raw) return;
            let url;
            try { url = new URL(raw, doc.baseURI).href; } catch (e) { return; }

            if (!byUrl.has(url)) byUrl.set(url, loadImage(url).catch(() => null));
            const data = await byUrl.get(url);
            if (!data) {
                img.setAttribute('src', url);
                return;
            }
            if (!data.location) {
                data.location = `${MHT_BASE}image${String(images.length + 1).padStart(3, '0')}.${data.ext}`;
                images.push(data);
            }
            img.setAttribute('src', data.location);
            ['data-original', 'data-src', 'srcset'].forEach(attr => img.removeAttribute(attr));
            if (data.width > MAX_IMAGE_WIDTH) {
                img.setAttribute('width', MAX_IMAGE_WIDTH);
                img.setAttribute('height', Math.round(data.height * MAX_IMAGE_WIDTH / data.width));
                img.style.width = img.style.height = '';
            }
        }));
        return images.map(({ location, mime, base64 }) => ({ location, mime, base64 }));
    }

    // 提取并清洗内容
    async function extractContent(doc) {
        const clone = findContentContainer(doc).cloneNode(true);
        clone.querySelectorAll('script, .hidden, #cx-helper-panel, .cx-auto-answer-hint').forEach(el => el.remove());
        clone.querySelectorAll('[style]').forEach(el => {
            if (/display\s*:\s*none/i.test(el.getAttribute('style'))) el.remove();
        });
        flattenLists(clone);
        const images = await embedImages(clone, doc);
        return { title: getTitle(doc), html: clone.innerHTML, images };
    }

    // ========== iframe 内：响应顶层页面的请求 ==========

    if (!isTop) {
        window.addEventListener('message', async ev => {
            const data = ev.data;
            // 脚本猫/篡改猴的沙箱会包装 window 对象，不能用 ev.source === window.top 判断，只校验来源域名
            if (!data || data[MSG_KEY] !== true || !isTrustedOrigin(ev.origin)) return;
            if (data.type === 'probe') {
                post(ev.source, { type: 'probe-result', id: data.id, score: scoreDocument(document) }, ev.origin);
            } else if (data.type === 'extract') {
                let result;
                try { result = await extractContent(document); } catch (e) { result = { error: e.message || String(e) }; }
                post(ev.source, { type: 'extract-result', id: data.id, result }, ev.origin);
            } else if (data.type === 'questions') {
                post(ev.source, { type: 'questions-result', id: data.id, questions: collectQuestions(document) }, ev.origin);
            } else if (data.type === 'resources') {
                post(ev.source, { type: 'resources-result', id: data.id, objectids: collectObjectIds(document), origin: location.origin }, ev.origin);
            } else if (data.type === 'fill') {
                let ok = false;
                try { ok = fillQuestion(findQuestionElements(document)[data.idx], data.fill || {}); } catch (e) { console.error('[学习通助手] 填答失败', e); }
                post(ev.source, { type: 'fill-result', id: data.id, ok }, ev.origin);
            } else if (data.type === 'unlock') {
                enableCopyUnlock();
            }
        });
        // 焦点在 iframe 里时按 D 键，转交顶层页面处理
        document.addEventListener('keydown', ev => { if (isPdfHotkey(ev)) post(window.top, { type: 'hotkey-pdf' }); });
        // 告知顶层页面：如果已解除限制，新加载的 iframe 也需要解除
        post(window.top, { type: 'hello' });
        return;
    }

    // ========== 顶层页面：面板 ==========

    const exportCounts = { doc: {} };

    // CSS
    GM_addStyle(`
        /* 配色：暖白底 + 陶土橙强调色，跟随系统深色模式 */
        #cx-helper-panel, .cx-helper-modal-overlay {
            --cx-bg: #faf9f5;
            --cx-surface: #ffffff;
            --cx-muted: #f0eee6;
            --cx-border: #e5e3d9;
            --cx-border-strong: #d1cfc5;
            --cx-text: #141413;
            --cx-text-2: #5e5d59;
            --cx-text-3: #8f8d86;
            --cx-accent: #c96442;
            --cx-accent-hover: #b5573a;
            --cx-accent-soft: rgba(201, 100, 66, 0.1);
            --cx-success: #3f7d58;
            --cx-success-soft: rgba(63, 125, 88, 0.1);
            --cx-warn: #9a6a1c;
            --cx-warn-soft: rgba(196, 140, 40, 0.12);
            --cx-danger: #b53333;
            --cx-danger-soft: rgba(181, 51, 51, 0.08);
            --cx-ds: #4d6bfe;
            --cx-ds-soft: rgba(77, 107, 254, 0.1);
            --cx-shadow: 0 1px 2px rgba(20, 20, 19, 0.04), 0 8px 28px rgba(20, 20, 19, 0.08);
            --cx-serif: "Tiempos Text", Georgia, "Songti SC", "Noto Serif SC", "Source Han Serif SC", serif;
            --cx-sans: -apple-system, BlinkMacSystemFont, "Segoe UI", "PingFang SC", "Hiragino Sans GB", "Microsoft YaHei", sans-serif;
        }
        @media (prefers-color-scheme: dark) {
            #cx-helper-panel, .cx-helper-modal-overlay {
                --cx-bg: #262624;
                --cx-surface: #30302e;
                --cx-muted: #1f1e1d;
                --cx-border: #3e3e3a;
                --cx-border-strong: #52514c;
                --cx-text: #faf9f5;
                --cx-text-2: #c2c0b6;
                --cx-text-3: #8f8d86;
                --cx-accent: #d97757;
                --cx-accent-hover: #e08a6d;
                --cx-accent-soft: rgba(217, 119, 87, 0.16);
                --cx-success: #7fbf95;
                --cx-success-soft: rgba(127, 191, 149, 0.14);
                --cx-warn: #e0b060;
                --cx-warn-soft: rgba(224, 176, 96, 0.14);
                --cx-danger: #e57373;
                --cx-danger-soft: rgba(229, 115, 115, 0.12);
                --cx-ds: #8fa3ff;
                --cx-ds-soft: rgba(143, 163, 255, 0.16);
                --cx-shadow: 0 1px 2px rgba(0, 0, 0, 0.3), 0 8px 28px rgba(0, 0, 0, 0.35);
            }
        }

        /* 主面板 */
        #cx-helper-panel {
            position: fixed; top: 120px; right: 30px; width: 340px;
            background: var(--cx-bg); color: var(--cx-text);
            border: 1px solid var(--cx-border); border-radius: 16px;
            box-shadow: var(--cx-shadow);
            z-index: 999999; font-family: var(--cx-sans);
            font-size: 14px; line-height: 1.5; overflow: hidden;
            -webkit-font-smoothing: antialiased;
            display: flex; flex-direction: column; max-height: calc(100vh - 140px);
        }
        #cx-helper-panel *, #cx-helper-panel *::before, #cx-helper-panel *::after { box-sizing: border-box; }
        /* 解除复制限制后，面板本身仍不可选中，避免拖拽时选中文字 */
        #cx-helper-panel, #cx-helper-panel * { user-select: none !important; -webkit-user-select: none !important; }
        #cx-helper-panel input, #cx-helper-panel textarea, #cx-helper-panel .cx-search-result *, #cx-helper-panel .cx-compare-list * { user-select: text !important; -webkit-user-select: text !important; }

        /* 头部拖拽区 */
        #cx-helper-header {
            display: flex; align-items: center; gap: 10px;
            padding: 14px 16px 4px; cursor: grab;
            font-family: var(--cx-serif); font-size: 17px; font-weight: 500;
            letter-spacing: 0.01em; color: var(--cx-text);
        }
        #cx-helper-header:active { cursor: grabbing; }

        /* Tabs */
        .cx-tabs {
            display: flex; gap: 2px; margin: 10px 16px 14px; padding: 3px;
            background: var(--cx-muted); border-radius: 10px;
        }
        .cx-tab-btn {
            flex: 1; padding: 6px 0; margin: 0; border: 1px solid transparent; background: transparent;
            cursor: pointer; color: var(--cx-text-2); font-family: inherit; font-weight: 500; font-size: 12px;
            border-radius: 8px; transition: background-color 0.15s ease, color 0.15s ease;
        }
        .cx-tab-btn:hover { color: var(--cx-text); }
        .cx-tab-btn.active {
            background: var(--cx-surface); color: var(--cx-text);
            border-color: var(--cx-border); box-shadow: 0 1px 2px rgba(20, 20, 19, 0.05);
        }

        /* 内容区 */
        .cx-tab-content { display: none; padding: 0 16px 16px; animation: cxFadeIn 0.2s ease; }
        .cx-tab-content.active { display: block; min-height: 0; overflow-y: auto; overscroll-behavior: contain; }
        @keyframes cxFadeIn { from { opacity: 0; } to { opacity: 1; } }

        /* 按钮 */
        .cx-btn-primary {
            display: block; width: 100%; padding: 9px 12px; margin-top: 8px;
            background: var(--cx-accent); color: #fff;
            border: 1px solid transparent; border-radius: 10px;
            font-family: inherit; font-size: 14px; font-weight: 500;
            cursor: pointer; transition: background-color 0.15s ease, border-color 0.15s ease;
        }
        .cx-btn-primary:hover { background: var(--cx-accent-hover); }
        .cx-btn-primary:focus-visible, .cx-tab-btn:focus-visible { outline: 2px solid var(--cx-accent); outline-offset: 2px; }
        .cx-btn-primary[hidden] { display: none; }
        .cx-btn-primary:disabled { background: var(--cx-muted); color: var(--cx-text-3); cursor: not-allowed; }
        .cx-btn-secondary { background: var(--cx-surface); color: var(--cx-text); border-color: var(--cx-border-strong); }
        .cx-btn-secondary:hover { background: var(--cx-muted); }

        /* 开关组件 */
        .cx-switch-wrap {
            display: flex; justify-content: space-between; align-items: center;
            padding: 12px 14px; background: var(--cx-surface); border-radius: 12px;
            border: 1px solid var(--cx-border);
        }
        .cx-switch-label { font-weight: 500; color: var(--cx-text); font-size: 13px; }
        .cx-switch { position: relative; display: inline-block; width: 36px; height: 20px; margin: 0; }
        .cx-switch input { opacity: 0; width: 0; height: 0; }
        .cx-slider {
            position: absolute; cursor: pointer; inset: 0;
            background-color: var(--cx-border-strong); transition: background-color 0.2s; border-radius: 20px;
        }
        .cx-slider:before {
            position: absolute; content: ""; height: 16px; width: 16px; left: 2px; bottom: 2px;
            background-color: #fff; transition: transform 0.2s; border-radius: 50%;
            box-shadow: 0 1px 2px rgba(0,0,0,0.2);
        }
        input:checked + .cx-slider { background-color: var(--cx-accent); }
        input:checked + .cx-slider:before { transform: translateX(16px); }

        /* 搜题 */
        .cx-input {
            display: block; width: 100%; margin-top: 8px; padding: 8px 10px;
            border: 1px solid var(--cx-border-strong); border-radius: 10px; background: var(--cx-surface);
            font-size: 13px; font-family: inherit; color: var(--cx-text); outline: none; resize: vertical;
            transition: border-color 0.15s ease, box-shadow 0.15s ease;
        }
        .cx-tab-content > :first-child { margin-top: 0; }
        .cx-input::placeholder { color: var(--cx-text-3); }
        .cx-input:focus { border-color: var(--cx-accent); box-shadow: 0 0 0 3px var(--cx-accent-soft); }
        .cx-search-result { margin-top: 12px; max-height: min(320px, 40vh); overflow-y: auto; font-size: 13px; color: var(--cx-text); line-height: 1.6; }
        .cx-search-result:empty { display: none; }
        .cx-result-card { background: var(--cx-surface); border: 1px solid var(--cx-border); border-radius: 12px; padding: 10px 12px; margin-bottom: 8px; }
        .cx-result-passage { color: var(--cx-text-2); white-space: pre-wrap; word-break: break-word; margin-bottom: 6px; }
        .cx-result-stem { font-family: var(--cx-serif); font-weight: 500; font-size: 14px; white-space: pre-wrap; word-break: break-word; margin-bottom: 6px; }
        .cx-result-option { padding: 2px 6px; border-radius: 6px; word-break: break-word; color: var(--cx-text-2); }
        .cx-result-option.correct { background: var(--cx-success-soft); color: var(--cx-success); font-weight: 500; }
        .cx-result-answer { margin-top: 6px; font-weight: 600; color: var(--cx-accent); word-break: break-word; }
        .cx-result-expl { margin-top: 6px; color: var(--cx-text-2); white-space: pre-wrap; word-break: break-word; }
        .cx-result-meta { font-size: 12px; color: var(--cx-text-3); margin-top: 4px; word-break: break-all; }
        .cx-result-notice { padding: 8px 10px; border-radius: 10px; background: var(--cx-warn-soft); color: var(--cx-warn); margin-bottom: 8px; word-break: break-word; }
        .cx-result-notice.error { background: var(--cx-danger-soft); color: var(--cx-danger); }
        .cx-result-notice a { color: inherit; text-decoration: underline; margin-left: 4px; }
        .cx-batch-title { font-family: var(--cx-serif); font-weight: 600; color: var(--cx-text); margin: 12px 0 2px; }
        .cx-batch-query { font-size: 12px; color: var(--cx-text-3); margin-bottom: 6px; word-break: break-word; }
        .cx-fill-status {
            display: inline-block; margin-left: 8px; padding: 0 6px; border-radius: 6px;
            font-family: var(--cx-sans); font-size: 11px; font-weight: 500;
            background: var(--cx-success-soft); color: var(--cx-success);
        }
        .cx-fill-status.fail { background: var(--cx-danger-soft); color: var(--cx-danger); }
        .cx-result-notice.success { background: var(--cx-success-soft); color: var(--cx-success); }

        /* DeepSeek 暂停时需要使用者操作的醒目提醒 */
        .cx-alert {
            margin-top: 10px; padding: 10px 12px; border-radius: 10px;
            border: 1.5px solid var(--cx-accent); background: var(--cx-accent-soft);
            animation: cxPulse 1.6s ease-in-out infinite;
        }
        .cx-alert-title { font-size: 13.5px; font-weight: 700; color: var(--cx-accent); }
        .cx-alert-body { margin-top: 4px; font-size: 12.5px; line-height: 1.6; color: var(--cx-text); }
        .cx-alert-body b { color: var(--cx-accent); }
        @keyframes cxPulse { 0%, 100% { box-shadow: 0 0 0 0 var(--cx-accent-soft); } 50% { box-shadow: 0 0 0 5px var(--cx-accent-soft); } }
        @media (prefers-reduced-motion: reduce) { .cx-alert { animation: none; } }

        /* 本页全部题目：两边答案对比 */
        .cx-section-title {
            margin-top: 18px; padding-top: 14px; border-top: 1px solid var(--cx-border);
            font-family: var(--cx-serif); font-size: 15px; font-weight: 500; color: var(--cx-text);
        }
        /* 可收起的分区标题 */
        .cx-fold {
            display: flex; align-items: center; justify-content: space-between; width: 100%;
            padding: 14px 2px 2px; background: none; border: none; border-top: 1px solid var(--cx-border);
            text-align: left; cursor: pointer; line-height: 1.5;
        }
        .cx-fold:hover { color: var(--cx-accent); }
        .cx-fold:focus-visible { outline: 2px solid var(--cx-accent); outline-offset: 2px; border-radius: 4px; }
        .cx-chevron {
            flex: none; width: 7px; height: 7px; margin: 0 6px 4px 0;
            border-right: 1.5px solid currentColor; border-bottom: 1.5px solid currentColor;
            transform: rotate(45deg); transition: transform 0.2s ease; opacity: 0.7;
        }
        .cx-fold[aria-expanded="false"] .cx-chevron { transform: rotate(-45deg); margin-bottom: 0; }
        .cx-fold-body[hidden] { display: none; }
        .cx-btn-row { display: flex; gap: 8px; }
        .cx-btn-row > .cx-btn-primary { flex: 1; min-width: 0; padding-left: 6px; padding-right: 6px; font-size: 13px; }
        #cx-compare-notices:not(:empty) { margin-top: 10px; }
        #cx-tk-status:empty, #cx-ds-status:empty { display: none; }
        .cx-compare-list { margin-top: 4px; font-size: 13px; color: var(--cx-text); line-height: 1.6; }
        .cx-badge {
            display: inline-block; margin-left: 8px; padding: 0 6px; border-radius: 6px;
            font-family: var(--cx-sans); font-size: 11px; font-weight: 500;
        }
        .cx-badge.same { background: var(--cx-success-soft); color: var(--cx-success); }
        .cx-badge.diff { background: var(--cx-warn-soft); color: var(--cx-warn); }
        .cx-badge.text, .cx-badge.neutral { background: var(--cx-muted); color: var(--cx-text-2); }

        /* 汇总卡片 */
        #cx-compare-summary:not(:empty) { margin-top: 10px; }
        .cx-summary { background: var(--cx-surface); border: 1px solid var(--cx-border); border-radius: 12px; padding: 10px 12px; font-size: 13px; line-height: 1.7; }
        .cx-summary-title { font-family: var(--cx-serif); font-size: 14px; font-weight: 600; margin-bottom: 4px; }
        .cx-summary-line { margin-top: 4px; word-break: break-word; }
        .cx-summary-line .cx-badge { margin-left: 0; }
        .cx-summary-count { margin-left: 6px; font-weight: 600; }
        .cx-summary-nums { margin-left: 6px; color: var(--cx-text-2); }
        .cx-summary-hint { margin-top: 6px; font-size: 12px; color: var(--cx-text-3); line-height: 1.6; }
        .cx-jump { color: var(--cx-accent); cursor: pointer; text-decoration: underline; text-underline-offset: 2px; }
        .cx-jump:hover { color: var(--cx-accent-hover); }

        /* 每题的分歧说明和答案选择 */
        .cx-diff { margin-top: 8px; padding: 6px 10px; border-radius: 8px; background: var(--cx-warn-soft); color: var(--cx-warn); font-size: 12.5px; word-break: break-word; }
        .cx-diff.text { background: var(--cx-muted); color: var(--cx-text-2); }
        .cx-choice-row { display: flex; align-items: center; flex-wrap: wrap; gap: 6px; margin-top: 10px; padding-top: 8px; border-top: 1px solid var(--cx-border); }
        .cx-choice-label { font-size: 12px; color: var(--cx-text-2); }
        .cx-choice {
            margin: 0; padding: 2px 10px; border: 1px solid var(--cx-border-strong); border-radius: 999px;
            background: var(--cx-surface); color: var(--cx-text-2);
            font-family: inherit; font-size: 12px; line-height: 1.6; cursor: pointer;
            transition: background-color 0.15s ease, color 0.15s ease;
        }
        .cx-choice:hover { background: var(--cx-muted); color: var(--cx-text); }
        .cx-choice.active { background: var(--cx-accent); border-color: var(--cx-accent); color: #fff; }
        .cx-fill-bar[hidden] { display: none; }
        /* DeepSeek 按钮旁的深度思考开关 */
        .cx-ds-row { align-items: stretch; }
        .cx-ds-opts { flex: none; display: flex; flex-direction: column; gap: 6px; margin-top: 8px; }
        .cx-think {
            flex: 1; display: flex; align-items: center; gap: 6px; padding: 4px 10px;
            border: 1px solid var(--cx-border-strong); border-radius: 10px; background: var(--cx-surface);
            font-size: 12px; color: var(--cx-text-2); cursor: pointer; white-space: nowrap;
        }
        .cx-think:hover { background: var(--cx-muted); }
        .cx-switch-sm { width: 28px; height: 16px; }
        .cx-switch-sm .cx-slider:before { width: 12px; height: 12px; }
        .cx-switch-sm input:checked + .cx-slider:before { transform: translateX(12px); }
        .cx-compare-item { border-radius: 12px; }
        .cx-flash { animation: cxFlash 1.4s ease; }
        @keyframes cxFlash { 0%, 50% { background: var(--cx-accent-soft); } 100% { background: transparent; } }
        .cx-src-tag {
            display: inline-block; margin-left: 6px; padding: 0 5px; border-radius: 5px;
            font-family: var(--cx-sans); font-size: 11px; font-weight: 500; line-height: 1.7; white-space: nowrap;
        }
        .cx-src-tag.tk { background: var(--cx-accent-soft); color: var(--cx-accent); }
        .cx-src-tag.ds { background: var(--cx-ds-soft); color: var(--cx-ds); }
        .cx-src-row { margin-top: 8px; padding-top: 8px; border-top: 1px dashed var(--cx-border); word-break: break-word; }
        .cx-src-row > .cx-src-tag { margin: 0 6px 0 0; }
        .cx-src-answer { font-weight: 600; color: var(--cx-text); }
        .cx-src-muted { color: var(--cx-text-3); }

        /* 资源下载 */
        .cx-hint { margin-top: 8px; font-size: 12px; color: var(--cx-text-3); text-align: center; line-height: 1.6; }
        .cx-hint a { color: var(--cx-accent); text-decoration: underline; }
        .cx-res-status { margin-top: 12px; font-size: 12px; color: var(--cx-text-2); line-height: 1.6; word-break: break-all; }
        .cx-res-status:empty { display: none; }
        .cx-res-status .error { color: var(--cx-danger); }
        .cx-res-status .success { color: var(--cx-success); }
        .cx-res-status progress { display: block; width: 100%; height: 6px; margin-top: 6px; accent-color: var(--cx-accent); }
        .cx-res-size { color: var(--cx-text-3); font-size: 11px; }

        /* 资源选择弹窗 */
        .cx-helper-modal-overlay {
            position: fixed; inset: 0; background: rgba(20, 20, 19, 0.4); z-index: 1000000;
            display: flex; justify-content: center; align-items: center;
            font-family: var(--cx-sans); -webkit-font-smoothing: antialiased;
        }
        .cx-helper-modal {
            background: var(--cx-bg); color: var(--cx-text);
            border: 1px solid var(--cx-border); border-radius: 16px; box-shadow: var(--cx-shadow);
            width: 90%; max-width: 600px; max-height: 80vh; padding: 20px; box-sizing: border-box;
            display: flex; flex-direction: column;
        }
        .cx-helper-modal-head { display: flex; justify-content: space-between; align-items: center; padding-bottom: 12px; border-bottom: 1px solid var(--cx-border); }
        .cx-helper-modal-title { font-family: var(--cx-serif); font-size: 18px; font-weight: 500; color: var(--cx-text); }
        .cx-helper-modal-selectall { font-size: 13px; color: var(--cx-text-2); cursor: pointer; display: flex; align-items: center; gap: 6px; }
        .cx-helper-modal-list { overflow-y: auto; flex: 1; margin: 8px 0; }
        .cx-helper-modal-item {
            display: flex; align-items: center; gap: 10px; padding: 9px 8px; border-radius: 8px;
            cursor: pointer; font-size: 14px; color: var(--cx-text);
        }
        .cx-helper-modal-item:hover { background: var(--cx-muted); }
        .cx-helper-modal-item input, .cx-helper-modal-selectall input { flex-shrink: 0; width: 16px; height: 16px; margin: 0; accent-color: var(--cx-accent); }
        .cx-helper-modal-name { flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
        .cx-helper-modal-type { font-size: 11px; color: var(--cx-text-2); background: var(--cx-muted); border: 1px solid var(--cx-border); padding: 1px 6px; border-radius: 6px; flex-shrink: 0; }
        .cx-helper-modal-note { font-size: 12px; color: var(--cx-danger); margin-bottom: 8px; }
        .cx-helper-modal-actions { display: flex; justify-content: flex-end; gap: 8px; padding-top: 12px; border-top: 1px solid var(--cx-border); }
        .cx-helper-modal-btn {
            padding: 8px 16px; border: 1px solid var(--cx-border-strong); border-radius: 10px; cursor: pointer;
            font-family: inherit; font-size: 14px; font-weight: 500;
            background: var(--cx-surface); color: var(--cx-text); transition: background-color 0.15s ease;
        }
        .cx-helper-modal-btn:hover { background: var(--cx-muted); }
        .cx-helper-modal-btn.primary { background: var(--cx-accent); border-color: transparent; color: #fff; }
        .cx-helper-modal-btn.primary:hover { background: var(--cx-accent-hover); }
    `);

    // HTML结构
    const panelHTML = `
        <div id="cx-helper-panel">
            <div id="cx-helper-header">学习通效率助手(蚌医版)</div>
            <div class="cx-tabs">
                <button class="cx-tab-btn active" data-target="cx-tab-export">文档导出</button>
                <button class="cx-tab-btn" data-target="cx-tab-search">题库搜题</button>
                <button class="cx-tab-btn" data-target="cx-tab-download">资源下载</button>
                <button class="cx-tab-btn" data-target="cx-tab-unlock">限制解除</button>
            </div>

            <div id="cx-tab-export" class="cx-tab-content active">
                <button class="cx-btn-primary" id="cx-export-word">导出 Word</button>
            </div>

            <div id="cx-tab-search" class="cx-tab-content">
                <input type="password" id="cx-tikuhai-token" class="cx-input" placeholder="题库海 API Key 或卡密" autocomplete="off">
                <div class="cx-hint" id="cx-token-hint">
                    还没有密钥？<a href="https://search.tikuhai.com/" target="_blank" rel="noopener noreferrer">前往题库海购买</a><br>
                    本脚本与题库海无任何合作关系，提供链接仅为方便使用
                </div>

                <button type="button" class="cx-section-title cx-fold" data-fold="single" aria-expanded="true">单题搜索<span class="cx-chevron"></span></button>
                <div class="cx-fold-body" id="cx-fold-single">
                <textarea id="cx-search-input" class="cx-input" rows="5" placeholder="粘贴题目，选项每行一个，例如：&#10;1. (单选题) 中国的首都是？&#10;A. 北京&#10;B. 上海"></textarea>
                <button class="cx-btn-primary" id="cx-search-btn">题库海搜索</button>
                <div class="cx-btn-row cx-ds-row">
                    <button class="cx-btn-primary cx-btn-secondary" id="cx-single-ds">DeepSeek 搜索</button>
                    <div class="cx-ds-opts">
                        <label class="cx-think" title="开启后更准，但会慢几十秒到几分钟">
                            <span class="cx-switch cx-switch-sm"><input type="checkbox" id="cx-single-think"><span class="cx-slider"></span></span>
                            深度思考
                        </label>
                        <label class="cx-think" title="开启后会先上网查资料，更慢，适合时事类题目">
                            <span class="cx-switch cx-switch-sm"><input type="checkbox" id="cx-single-search"><span class="cx-slider"></span></span>
                            智能搜索
                        </label>
                    </div>
                </div>
                <div id="cx-search-result" class="cx-search-result"></div>
                </div>

                <button type="button" class="cx-section-title cx-fold" data-fold="page" aria-expanded="true">本页全部题目<span class="cx-chevron"></span></button>
                <div class="cx-fold-body" id="cx-fold-page">
                <button class="cx-btn-primary cx-btn-secondary" id="cx-tk-batch">题库海搜索</button>
                <div class="cx-btn-row cx-ds-row">
                    <button class="cx-btn-primary cx-btn-secondary" id="cx-ds-btn">DeepSeek 搜索</button>
                    <div class="cx-ds-opts">
                        <label class="cx-think" title="开启后更准，但每批会慢几十秒到几分钟">
                            <span class="cx-switch cx-switch-sm"><input type="checkbox" id="cx-ds-think"><span class="cx-slider"></span></span>
                            深度思考
                        </label>
                        <label class="cx-think" title="开启后会先上网查资料，更慢，适合时事类题目">
                            <span class="cx-switch cx-switch-sm"><input type="checkbox" id="cx-ds-search"><span class="cx-slider"></span></span>
                            智能搜索
                        </label>
                    </div>
                </div>
                <button class="cx-btn-primary cx-btn-secondary" id="cx-copy-btn">一键复制全部题目（发给其他 AI）</button>
                <div class="cx-hint">两边答案分开保存、逐题对比<br>DeepSeek 使用已登录的网页版，无需 API Key</div>
                <div id="cx-compare-notices"></div>
                <div class="cx-result-meta" id="cx-tk-status"></div>
                <div class="cx-result-meta" id="cx-ds-status"></div>
                <div id="cx-compare-summary"></div>
                <div id="cx-fill-bar" class="cx-fill-bar" hidden>
                    <div class="cx-btn-row">
                        <button class="cx-btn-primary cx-btn-secondary" id="cx-pick-tk">全部采用题库海</button>
                        <button class="cx-btn-primary cx-btn-secondary" id="cx-pick-ds">全部采用 DeepSeek</button>
                    </div>
                    <button class="cx-btn-primary" id="cx-fill-btn">按所选答案填充</button>
                </div>
                <div id="cx-compare-list" class="cx-compare-list"></div>
                </div>
            </div>

            <div id="cx-tab-download" class="cx-tab-content">
                <button class="cx-btn-primary" id="cx-res-select">选择资源下载</button>
                <button class="cx-btn-primary cx-btn-secondary" id="cx-res-pdf">下载全部 PDF</button>
                <div class="cx-hint">在课程章节页按 D 键也可直接下载全部 PDF</div>
                <div id="cx-res-status" class="cx-res-status"></div>
            </div>

            <div id="cx-tab-unlock" class="cx-tab-content">
                <div class="cx-switch-wrap">
                    <span class="cx-switch-label">允许复制与粘贴</span>
                    <label class="cx-switch">
                        <input type="checkbox" id="cx-toggle-copy">
                        <span class="cx-slider"></span>
                    </label>
                </div>
            </div>
        </div>
    `;

    const wrapper = document.createElement('div');
    wrapper.innerHTML = panelHTML;
    document.body.appendChild(wrapper);

    // 面板拖拽
    const panel = document.getElementById('cx-helper-panel'), header = document.getElementById('cx-helper-header');
    let isDragging = false, offsetX = 0, offsetY = 0;
    header.addEventListener('mousedown', e => { isDragging = true; offsetX = e.clientX - panel.offsetLeft; offsetY = e.clientY - panel.offsetTop; header.style.cursor = 'grabbing'; });
    document.addEventListener('mousemove', e => {
        if (!isDragging) return;
        const top = Math.max(0, Math.min(e.clientY - offsetY, window.innerHeight - 120));
        panel.style.right = 'auto';
        panel.style.left = Math.max(0, Math.min(e.clientX - offsetX, window.innerWidth - panel.offsetWidth)) + 'px';
        panel.style.top = top + 'px';
        // 面板太高时内容区滚动，拖到哪里都不超出窗口底部
        panel.style.maxHeight = (window.innerHeight - top - 20) + 'px';
    });
    document.addEventListener('mouseup', () => { isDragging = false; header.style.cursor = ''; });

    // 「单题搜索」「本页全部题目」可收起，收起状态会记住
    document.querySelectorAll('.cx-fold').forEach(btn => {
        const body = document.getElementById('cx-fold-' + btn.dataset.fold);
        const key = 'fold_' + btn.dataset.fold;
        const apply = open => {
            btn.setAttribute('aria-expanded', String(open));
            body.hidden = !open;
        };
        apply(!GM_getValue(key, false));
        btn.addEventListener('click', () => {
            const open = body.hidden;
            apply(open);
            GM_setValue(key, !open);
        });
    });

    // Tab切换
    function activateTab(target) {
        document.querySelectorAll('.cx-tab-btn').forEach(b => b.classList.toggle('active', b.dataset.target === target));
        document.querySelectorAll('.cx-tab-content').forEach(c => c.classList.toggle('active', c.id === target));
    }
    document.querySelectorAll('.cx-tab-btn').forEach(btn => btn.addEventListener('click', () => activateTab(btn.dataset.target)));

    function getFileName(baseTitle, ext) {
        if (!exportCounts[ext][baseTitle]) exportCounts[ext][baseTitle] = 0;
        let suffix = exportCounts[ext][baseTitle] > 0 ? `_${exportCounts[ext][baseTitle]}` : '';
        exportCounts[ext][baseTitle]++;
        return `${baseTitle}${suffix}.${ext}`;
    }

    function toFileName(title) {
        return title.replace(/[\/\\:\*\?"<>\|\x00-\x1f]/g, '').trim().slice(0, 100) || '学习通题库';
    }

    // ========== 顶层页面：与 iframe 通信 ==========

    const pending = new Map();

    window.addEventListener('message', ev => {
        const data = ev.data;
        if (!data || data[MSG_KEY] !== true || !isTrustedOrigin(ev.origin)) return;
        if (data.type === 'hello') {
            if (copyUnlocked) post(ev.source, { type: 'unlock' }, ev.origin);
            return;
        }
        if (data.type === 'hotkey-pdf') {
            handlePdfHotkey();
            return;
        }
        const handler = pending.get(data.id);
        if (handler) handler(data, ev.source);
    });

    function newId() {
        return Math.random().toString(36).slice(2) + Date.now().toString(36);
    }

    // 跨域的 window 也可以访问 length 和下标，能遍历到所有层级的 iframe
    function collectFrames(win, list = []) {
        for (let i = 0; i < win.length; i++) {
            let frame;
            try { frame = win[i]; } catch (e) { continue; }
            list.push(frame);
            collectFrames(frame, list);
        }
        return list;
    }

    // 向所有 iframe 广播请求，收集一段时间内的回复（没运行脚本的 iframe 不会回复）
    function queryFrames(type, timeout = 800) {
        const frames = collectFrames(pageWindow);
        if (!frames.length) return Promise.resolve([]);
        return new Promise(resolve => {
            const id = newId(), results = [];
            pending.set(id, (data, source) => { if (data.type === type + '-result') results.push({ source, data }); });
            frames.forEach(frame => post(frame, { type, id }));
            setTimeout(() => { pending.delete(id); resolve(results); }, timeout);
        });
    }

    // 向单个 iframe 发请求并等待回复，超时返回 null
    function requestFrame(frame, type, payload, timeout) {
        return new Promise(resolve => {
            const id = newId();
            const timer = setTimeout(() => { pending.delete(id); resolve(null); }, timeout);
            pending.set(id, data => {
                if (data.type !== type + '-result') return;
                clearTimeout(timer);
                pending.delete(id);
                resolve(data);
            });
            post(frame, { type, id, ...payload });
        });
    }

    async function requestExtract(frame) {
        const data = await requestFrame(frame, 'extract', {}, 120000);
        if (!data) throw new Error('读取题目内容超时');
        if (data.result.error) throw new Error(data.result.error);
        return data.result;
    }

    // ========== 生成 Word 文档（MHT 格式，图片作为独立部分内嵌） ==========

    // CSS修复：解决文字重叠与分页截断问题
    const commonFixCSS = `
        /* 答案区域浮动和绝对定位修复 */
        .answerBg, .myAnswer, .correctAnswer, .answerBg span, .answerBg div {
            display: block !important;
            position: relative !important;
            float: none !important;
            height: auto !important;
            line-height: 1.8 !important;
            margin-bottom: 8px !important;
            left: 0 !important; top: 0 !important; right: auto !important; bottom: auto !important;
            clear: both !important;
        }
        .answerBg img { display: inline-block !important; position: static !important; vertical-align: middle !important; margin-left: 5px !important; }

        /* 题目防分页截断 */
        .TiMu, .questionLi, .mark_item, .ul_li {
            margin-bottom: 30px !important;
            page-break-inside: avoid !important;
            break-inside: avoid !important;
        }

        .fontLabel { font-weight: bold !important; margin-bottom: 8px !important; display: block !important; }
        img { max-width: 100% !important; height: auto !important; display: inline-block; }
    `;

    function buildWordHtml(title, content) {
        const safeTitle = escapeHtml(title);
        return `
            <html xmlns:o='urn:schemas-microsoft-com:office:office' xmlns:w='urn:schemas-microsoft-com:office:word' xmlns='http://www.w3.org/TR/REC-html40'>
            <head>
                <meta http-equiv='Content-Type' content='text/html; charset=utf-8'>
                <title>${safeTitle}</title>
                <!--[if gte mso 9]>
                <xml><w:WordDocument><w:View>Print</w:View><w:Zoom>100</w:Zoom><w:DoNotOptimizeForBrowser/></w:WordDocument></xml>
                <![endif]-->
                <style>
                    @page WordSection1 { size: 595.3pt 841.9pt; margin: 72.0pt 90.0pt; mso-header-margin: 36.0pt; mso-footer-margin: 36.0pt; }
                    div.WordSection1 { page: WordSection1; }
                    body, div, p, span { font-family: 'KaiTi_GB2312', 'KaiTi', '楷体', 'Times New Roman', serif !important; font-size: 12pt; line-height: 1.5; color: #000; }
                    .mark_title { text-align: center !important; font-size: 16pt !important; font-weight: bold !important; margin-bottom: 20px !important; font-family: 'SimHei', '黑体', sans-serif !important; }
                    ${commonFixCSS}
                </style>
            </head>
            <body><div class="WordSection1">
                <div class="mark_title">${safeTitle}</div>
                ${content}
            </div></body></html>`;
    }

    function toQuotedPrintable(text) {
        const encoder = new TextEncoder();
        return text.split(/\r?\n/).map(line => {
            const bytes = encoder.encode(line);
            let out = '', lineLen = 0;
            bytes.forEach((b, i) => {
                const literal = (b >= 33 && b <= 126 && b !== 61) || (b === 32 && i < bytes.length - 1);
                const token = literal ? String.fromCharCode(b) : '=' + b.toString(16).toUpperCase().padStart(2, '0');
                if (lineLen + token.length > 75) { out += '=\r\n'; lineLen = 0; }
                out += token;
                lineLen += token.length;
            });
            return out;
        }).join('\r\n');
    }

    function buildMht(html, images) {
        const boundary = '----=_NextPart_CxHelper_' + Date.now().toString(36);
        const parts = [
            'MIME-Version: 1.0',
            `Content-Type: multipart/related; boundary="${boundary}"; type="text/html"`,
            '',
            '--' + boundary,
            'Content-Type: text/html; charset="utf-8"',
            'Content-Transfer-Encoding: quoted-printable',
            `Content-Location: ${MHT_BASE}index.htm`,
            '',
            toQuotedPrintable(html)
        ];
        images.forEach(img => parts.push(
            '',
            '--' + boundary,
            `Content-Type: ${img.mime}`,
            'Content-Transfer-Encoding: base64',
            `Content-Location: ${img.location}`,
            '',
            img.base64.replace(/.{76}/g, '$&\r\n')
        ));
        parts.push('', `--${boundary}--`, '');
        return parts.join('\r\n');
    }

    function saveBlob(blob, fileName) {
        const url = URL.createObjectURL(blob);
        const link = document.createElement('a');
        link.href = url;
        link.download = fileName;
        document.body.appendChild(link);
        link.click();
        link.remove();
        // 立即释放在部分浏览器上会中断下载
        setTimeout(() => URL.revokeObjectURL(url), 60000);
    }

    function downloadDoc({ title, html, images }) {
        const mht = buildMht(buildWordHtml(title, html), images);
        saveBlob(new Blob([mht], { type: 'application/msword' }), getFileName(toFileName(title), 'doc'));
    }

    // 导出 Word
    document.getElementById('cx-export-word').addEventListener('click', async function() {
        const btn = this;
        btn.disabled = true;
        btn.innerText = "查找题目中...";
        try {
            // 在当前页面和所有 iframe（含跨域）中找题目最多的那个
            const probes = (await queryFrames('probe')).map(r => ({ source: r.source, score: r.data.score }));
            const candidates = [{ source: null, score: scoreDocument(document) }, ...probes];
            const best = candidates.reduce((a, b) => (b.score > a.score ? b : a));

            btn.innerText = "转换图片中...";
            const result = best.source ? await requestExtract(best.source) : await extractContent(document);
            downloadDoc(result);
        } catch (e) {
            console.error('[学习通助手] 导出失败', e);
            nativeAlert('导出失败：' + (e.message || e));
        } finally {
            btn.innerText = "导出 Word";
            btn.disabled = false;
        }
    });

    // ========== 题库海搜题 ==========

    const TIKUHAI_API = 'https://search.tikuhai.com/api/open/v1/search/exact';
    const TIKUHAI_SITE = 'https://search.tikuhai.com/';
    const TOKEN_KEY = 'tikuhaiToken';
    const SEARCH_ERRORS = {
        INVALID_INPUT: '题干为空或格式有误',
        UNAUTHORIZED_CONSUMER: 'API Key / 卡密无效、过期或未填写，请整串重新复制',
        UNAUTHORIZED_CHANNEL: '渠道未识别，请联系题库海客服',
        SCENE_NOT_ALLOWED: '当前渠道未开通精确搜题',
        ENDPOINT_BLOCKED: '接口被临时关闭，请联系题库海客服',
        RATE_LIMITED: '请求过于频繁，请稍后再试'
    };
    const BILLING_TEXT = {
        dedup: '7 天内重复搜索，未扣费',
        member: '会员，未扣费',
        unlimited: '不限量额度，未扣费',
        exhausted: '积分不足，未扣费',
        free: '免费'
    };

    // 粘贴的整道题 → 题干 + 去掉字母标号的选项；选项之后的其它行（我的答案、得分等）忽略
    function parseQuestion(text) {
        const lines = text.split(/\r?\n/).map(line => line.trim()).filter(Boolean);
        const stemLines = [], options = [];
        for (let i = 0; i < lines.length; i++) {
            const line = lines[i];
            const match = i > 0 && OPTION_RE.exec(line);
            if (i > 0 && /^[A-J]$/.test(line) && i + 1 < lines.length) {
                // 学习通复制出来常是「A」单独一行、正文在下一行
                options.push(lines[++i]);
            } else if (match) {
                const optionText = match[3] || (i + 1 < lines.length ? lines[++i] : '');
                if (optionText) options.push(optionText);
            } else if (!options.length) {
                stemLines.push(line);
            }
        }
        // 判断题的「对/错」通常没有字母标号
        if (!options.length && stemLines.length > 1 && stemLines.slice(1).every(line => JUDGE_OPTION_RE.test(line))) {
            options.push(...stemLines.splice(1));
        }
        return { stem: stripStemPrefix(stemLines.join('\n')), options };
    }

    function searchTikuhai(token, stem, options) {
        return new Promise((resolve, reject) => {
            GM_xmlhttpRequest({
                method: 'POST', url: TIKUHAI_API, timeout: 20000,
                headers: { 'Content-Type': 'application/json', 'X-Consumer-Token': token },
                data: JSON.stringify(options.length ? { stem, options } : { stem }),
                onload: res => {
                    try { resolve(JSON.parse(res.responseText)); } catch (e) { reject(new Error(`服务器返回异常（HTTP ${res.status}）`)); }
                },
                onerror: () => reject(new Error('网络错误，无法连接题库海')),
                ontimeout: () => reject(new Error('请求超时，请稍后再试'))
            });
        });
    }

    function el(tag, className, text) {
        const node = document.createElement(tag);
        if (className) node.className = className;
        if (text != null) node.textContent = text;
        return node;
    }

    // 错误 message 里带少量 HTML，只取纯文本；购买链接单独从 purchase_url 取
    function stripTags(html) {
        return html ? new DOMParser().parseFromString(html, 'text/html').body.textContent.trim() : '';
    }

    function showNotice(box, text, type, purchaseUrl) {
        const notice = el('div', 'cx-result-notice' + (type ? ' ' + type : ''), text);
        if (purchaseUrl && /^https:\/\//.test(purchaseUrl)) {
            const link = el('a', '', '前往购买');
            link.href = purchaseUrl;
            link.target = '_blank';
            link.rel = 'noopener noreferrer';
            notice.appendChild(link);
        }
        box.appendChild(notice);
    }

    function formatAnswer(answer, letters) {
        if (!answer || !answer.values || !answer.values.length) return '';
        return answer.values.map(v => {
            if (typeof v === 'string') return letters.has(v) ? `${letters.get(v)}. ${v}` : v;
            if (typeof v === 'boolean') return v ? '对' : '错';
            return typeof v === 'object' ? JSON.stringify(v) : String(v);
        }).join('；');
    }

    function sortedOptions(item) {
        return [...(item.options || [])].sort((a, b) => a.order_no - b.order_no);
    }

    // answer.values 里是选项原文，按 order_no 排序后给普通选项编上 A/B/C 字母
    function choiceLetters(item) {
        const letters = new Map();
        sortedOptions(item).filter(opt => opt.role === 'choice').forEach((opt, i) => letters.set(opt.text, String.fromCharCode(65 + i)));
        return letters;
    }

    // 搜题结果里的答案（纯文本），没有答案时返回空串
    function resultAnswerText(res) {
        if (!res || !res.success || !res.data) return '';
        return (res.data.items || []).map(item => formatAnswer(item.answer, choiceLetters(item))).filter(Boolean).join('；');
    }

    // 搜题结果里的答案（填答用）：[{ text: 选项原文或填空答案, letter: 题库里的选项字母 }]
    function resultAnswers(res) {
        if (!res || !res.success || !res.data) return [];
        return (res.data.items || []).flatMap(item => {
            if (!item.answer || !Array.isArray(item.answer.values)) return [];
            const letters = choiceLetters(item);
            return item.answer.values.map(v => {
                if (typeof v === 'boolean') return { text: v ? '对' : '错', letter: '' };
                if (typeof v === 'string') return { text: v, letter: letters.get(v) || '' };
                return null;
            }).filter(Boolean);
        });
    }

    function renderItem(item) {
        const card = el('div', 'cx-result-card');
        if (item.passage) card.appendChild(el('div', 'cx-result-passage', item.passage));
        if (item.stem) card.appendChild(el('div', 'cx-result-stem', item.stem));
        const letters = choiceLetters(item);
        sortedOptions(item).forEach(opt => {
            const label = opt.role === 'choice' ? letters.get(opt.text) : '';
            const text = (label ? `${label}. ` : '') + opt.text + (opt.is_correct ? ' ✓' : '');
            card.appendChild(el('div', 'cx-result-option' + (opt.is_correct ? ' correct' : ''), text));
        });
        const answer = formatAnswer(item.answer, letters);
        if (answer) card.appendChild(el('div', 'cx-result-answer', '答案：' + answer));
        if (item.explanation) card.appendChild(el('div', 'cx-result-expl', '解析：' + item.explanation));
        return card;
    }

    function renderSearchResult(box, res) {
        if (!res.success) {
            const error = res.error || {};
            showNotice(box, SEARCH_ERRORS[error.code] || stripTags(error.message) || '搜索失败', 'error', error.details && error.details.purchase_url);
            return;
        }
        const meta = res.meta || {}, data = res.data;
        // 三态按文档顺序判断：未收录 → 余额耗尽 → 答案待补录
        if (!data) {
            showNotice(box, '题库未收录这道题（未扣费）。可检查题干、选项是否与原题逐字一致。');
        } else {
            if (meta.billing_result === 'exhausted') showNotice(box, '积分不足，答案未返回。', 'error', meta.purchase_url);
            else if (data.answer_status === 'missing') showNotice(box, '题目已收录，但答案待补录。');
            if (data.ai_generated) showNotice(box, 'AI 作答（题库无此题）：' + (data.disclaimer || '仅供参考'));
            [...(data.items || [])].sort((a, b) => a.sort_order - b.sort_order).forEach(item => box.appendChild(renderItem(item)));
        }
        box.appendChild(el('div', 'cx-result-meta', billingText(meta)));
    }

    function billingText(meta) {
        const billing = meta.billing_result === 'charged'
            ? `扣除 ${meta.cost} 积分` + (meta.credit_remaining != null ? `，剩余 ${meta.credit_remaining}` : '')
            : BILLING_TEXT[meta.billing_result] || '';
        return [billing, meta.request_id && `请求 ID：${meta.request_id}`].filter(Boolean).join(' · ');
    }

    const tokenInput = document.getElementById('cx-tikuhai-token');
    const searchInput = document.getElementById('cx-search-input');
    const searchBtn = document.getElementById('cx-search-btn');
    const searchResult = document.getElementById('cx-search-result');
    const tkBatchBtn = document.getElementById('cx-tk-batch');
    const dsBtn = document.getElementById('cx-ds-btn');
    const copyBtn = document.getElementById('cx-copy-btn');
    const compareSummary = document.getElementById('cx-compare-summary');
    const fillBar = document.getElementById('cx-fill-bar');
    const pickTkBtn = document.getElementById('cx-pick-tk');
    const pickDsBtn = document.getElementById('cx-pick-ds');
    const fillBtn = document.getElementById('cx-fill-btn');
    const compareNotices = document.getElementById('cx-compare-notices');
    const tkStatus = document.getElementById('cx-tk-status');
    const dsStatus = document.getElementById('cx-ds-status');
    const compareList = document.getElementById('cx-compare-list');
    tokenInput.value = GM_getValue(TOKEN_KEY, '');
    tokenInput.addEventListener('change', () => GM_setValue(TOKEN_KEY, tokenInput.value.trim()));

    // 没填密钥时显示购买入口
    const tokenHint = document.getElementById('cx-token-hint');
    const updateTokenHint = () => { tokenHint.style.display = tokenInput.value.trim() ? 'none' : ''; };
    tokenInput.addEventListener('input', updateTokenHint);
    updateTokenHint();

    const MISSING_TOKEN_TEXT = '还没有填写题库海密钥，请先购买 API Key 或卡密后填入上方输入框。本脚本与题库海无任何合作关系，提供链接仅为方便使用。';

    function showMissingToken(box) {
        showNotice(box, MISSING_TOKEN_TEXT, 'error', TIKUHAI_SITE);
    }

    // ---------- 单题搜索：题库海、DeepSeek 各搜各的，同一道题两边都搜过时对比 ----------

    const singleDsBtn = document.getElementById('cx-single-ds');
    // 单题搜索自己的深度思考、智能搜索开关，和整页搜索的互不影响
    const singleThinkBox = bindSwitch('cx-single-think', 'singleDeepThink');
    const singleSearchBox = bindSwitch('cx-single-search', 'singleWebSearch');

    function bindSwitch(id, key) {
        const box = document.getElementById(id);
        box.checked = GM_getValue(key, false);
        box.addEventListener('change', () => GM_setValue(key, box.checked));
        return box;
    }
    const SINGLE_TK_LABEL = '题库海搜索', SINGLE_DS_LABEL = 'DeepSeek 搜索';
    // 当前这道题：tk 为 { loading } | { res } | { error }，ds 为 { loading, text } | { rec } | { error }
    let single = null;

    // 粘贴的题目 → 和页面识别出来的题目同样的结构；换了一道题就清掉上一题的结果
    function readSingleQuestion() {
        const { stem, options } = parseQuestion(searchInput.value);
        if (!stem) return null;
        const judge = options.length && options.every(o => JUDGE_OPTION_RE.test(o));
        const q = { stem, options: judge ? ['对', '错'] : options, multi: /多选/.test(searchInput.value.split('\n')[0]) };
        const key = questionKey(q);
        if (!single || single.key !== key) single = { q, key, rawOptions: options, tk: null, ds: null, notes: [] };
        return single;
    }

    function renderSingle() {
        searchResult.replaceChildren();
        if (!single) return;
        const { q, tk, ds } = single;
        searchResult.appendChild(el('div', 'cx-result-meta', `已识别：题干 ${q.stem.length} 字，选项 ${q.options.length} 个`));

        // 转成和整页对比相同的记录格式
        const tkRec = !tk || tk.loading ? null : tk.error ? { status: 'error', text: tk.error } : tikuhaiRecord(tk.res);
        const dsRec = !ds || ds.loading ? null : ds.error ? { answer: '', reason: '', error: ds.error } : ds.rec;
        const info = analyzeRecords(q, tkRec, dsRec, single.key);

        // 需要链接或较长说明的提示（没填密钥、积分不足、智能搜索开关没切换成功等）放在卡片上方
        if (tk && tk.error && tk.purchaseUrl) showNotice(searchResult, tk.error, 'error', tk.purchaseUrl);
        if (tk && tk.res) {
            const meta = tk.res.meta || {};
            if (tk.res.success && meta.billing_result === 'exhausted') showNotice(searchResult, '题库海积分不足，答案未返回。', 'error', meta.purchase_url);
            if (!tk.res.success && tk.res.error && tk.res.error.details && tk.res.error.details.purchase_url) showNotice(searchResult, tkRec.text, 'error', tk.res.error.details.purchase_url);
        }
        if (single.paused) searchResult.appendChild(pauseAlert());
        single.notes.forEach(note => showNotice(searchResult, note, 'error'));

        const title = compareTitle('对比结果', info);
        if (single.mark) title.appendChild(el('span', 'cx-fill-status' + (single.mark.ok ? '' : ' fail'), single.mark.text));
        const card = buildCompareCard(q, info, tk && tk.loading ? '搜索中...' : '未搜索', ds && ds.loading ? ds.text : '未搜索');
        const choice = effectiveChoice(info, single.choice);
        if (info.hasTk || info.hasDs) {
            card.appendChild(choiceRow(info, choice, value => {
                single.choice = value;
                renderSingle();
            }));
            const btn = el('button', 'cx-btn-primary', single.filling ? '填入中...' : choice === 'none' ? '已选择不填' : `把${choice === 'tk' ? '题库海' : ' DeepSeek '}答案填入页面`);
            btn.type = 'button';
            btn.disabled = choice === 'none' || !!single.filling;
            btn.addEventListener('click', () => fillSingleToPage(single, info, choice));
            card.appendChild(btn);
        }
        searchResult.append(title, card);
        if (tk && tk.res && tk.res.meta) searchResult.appendChild(el('div', 'cx-result-meta', '题库海：' + billingText(tk.res.meta)));
    }

    // 用粘贴的题目在本页找同一道题：题干完全一致优先，其次题干互相包含；候选有多道时看选项重合最多的。返回下标，找不到返回 -1
    function findPageMatch(q, questions) {
        const stem = normalizeText(q.stem), options = new Set(q.options.map(normalizeText));
        let best = -1, bestScore = 0;
        questions.forEach((p, i) => {
            const pageStem = normalizeText(p.stem);
            const stemScore = pageStem === stem ? 2
                : Math.min(pageStem.length, stem.length) >= 6 && (pageStem.includes(stem) || stem.includes(pageStem)) ? 1 : 0;
            if (!stemScore) return;
            const score = stemScore * 100 + p.options.filter(o => options.has(normalizeText(o))).length;
            if (score > bestScore) {
                bestScore = score;
                best = i;
            }
        });
        return best;
    }

    async function fillSingleToPage(cur, info, choice) {
        if (cur.filling || choice === 'none') return;
        cur.filling = true;
        cur.mark = null;
        renderSingle();
        let mark;
        try {
            const questions = await collectPageQuestions();
            const i = findPageMatch(cur.q, questions);
            if (i < 0) {
                mark = { ok: false, text: '本页没有找到这道题' };
            } else {
                // DeepSeek 的字母对应的是粘贴的选项顺序，先换成选项原文，再按原文在页面上找选项
                const fill = choice === 'tk' ? { answers: info.tk.answers, display: info.tk.display } : deepSeekFill(cur.q, info.ds.answer);
                const name = choice === 'tk' ? '题库海' : 'DeepSeek';
                const ok = await fillPageQuestion(questions[i], fill);
                mark = ok ? { ok, text: `已把${name}答案填入本页第 ${i + 1} 题` } : { ok, text: `找到本页第 ${i + 1} 题，但没能填入` };
            }
        } catch (e) {
            console.error('[学习通助手] 填答失败', e);
            mark = { ok: false, text: '填入失败：' + (e.message || e) };
        }
        cur.filling = false;
        cur.mark = mark;
        if (single === cur) renderSingle();
    }

    function noSingleQuestion() {
        single = null;
        renderSingle();
        showNotice(searchResult, '请先粘贴题目', 'error');
    }

    async function runSearch() {
        if (searchBtn.disabled) return;
        const cur = readSingleQuestion();
        if (!cur) return noSingleQuestion();
        const token = tokenInput.value.trim();
        if (!token) {
            cur.tk = { error: MISSING_TOKEN_TEXT, purchaseUrl: TIKUHAI_SITE };
            return renderSingle();
        }

        GM_setValue(TOKEN_KEY, token);
        searchBtn.disabled = true;
        searchBtn.innerText = '搜索中...';
        cur.tk = { loading: true };
        renderSingle();
        try {
            cur.tk = { res: await searchTikuhai(token, cur.q.stem, cur.rawOptions) };
        } catch (e) {
            cur.tk = { error: e.message };
        } finally {
            searchBtn.disabled = false;
            searchBtn.innerText = SINGLE_TK_LABEL;
        }
        if (single === cur) renderSingle();
    }

    async function runSingleDeepSeek() {
        if (dsRun) {
            if (dsRun.single) dsRun.finish({ status: 'stopped' });
            return;
        }
        const cur = readSingleQuestion();
        if (!cur) return noSingleQuestion();

        cur.ds = { loading: true, text: '正在打开 DeepSeek 网页版...' };
        cur.notes = [];
        renderSingle();
        dsBtn.disabled = true;
        singleDsBtn.innerText = '停止';
        let result;
        try {
            const pending = askDeepSeekInTab([buildDeepSeekPrompt([cur.q], 0)], [1], { deepThink: singleThinkBox.checked, webSearch: singleSearchBox.checked }, ({ notes, hint, partial }) => {
                if (Array.isArray(notes)) cur.notes = notes.map(String);
                if (hint) cur.paused = true;
                if (Array.isArray(partial)) cur.paused = false;
                if (cur.ds && cur.ds.loading) cur.ds.text = cur.paused ? '已暂停，等待你切到 DeepSeek 标签页' : 'DeepSeek 正在作答...';
                if (single === cur) renderSingle();
            });
            if (dsRun) dsRun.single = true;
            result = await pending;
        } finally {
            dsBtn.disabled = false;
            singleDsBtn.innerText = SINGLE_DS_LABEL;
            cur.paused = false;
        }

        const text = (Array.isArray(result.texts) ? result.texts : []).map(String).join('\n');
        const item = (parseJsonArray(text) || parseAnswerItems(text))[0];
        if (item) {
            cur.ds = { rec: { answer: deepSeekAnswerText(item), reason: item.reason != null ? String(item.reason) : '' } };
            if (result.tab) result.tab.close();
        } else {
            cur.ds = { error: result.status === 'stopped' ? '已停止' : result.error || '没能解析 DeepSeek 的回答，可以切到 DeepSeek 标签页直接查看。' };
        }
        if (single === cur) renderSingle();
    }

    searchBtn.addEventListener('click', runSearch);
    singleDsBtn.addEventListener('click', runSingleDeepSeek);
    searchInput.addEventListener('keydown', e => {
        if (e.key === 'Enter' && (e.ctrlKey || e.metaKey)) {
            e.preventDefault();
            runSearch();
        }
    });

    // ---------- 本页全部题目：题库海、DeepSeek 各自作答，答案逐题对比 ----------

    const NO_QUESTION_TEXT = '本页没有识别到题目，请在作业、考试或章节测验页面使用。';
    let pageQuestions = [];      // 最近一次识别到的题目
    const tkAnswers = new Map(); // 题目 → 题库海结果 { status: 'ok' | 'miss' | 'error', answers, display, explanation, ai, text }
    const dsAnswers = new Map(); // 题目 → DeepSeek 结果 { answer, reason }
    const fillMarks = new Map(); // 题目 → 填充结果 { source, ok }
    const choices = new Map();   // 题目 → 使用者选择填入哪一边 'tk' | 'ds' | 'none'

    // 题干 + 选项作为题目的身份：两边分开搜、重新识别后，答案仍能对上同一道题
    function questionKey(q) {
        return [q.stem, ...q.options].join('\u0000');
    }

    function optionLetter(i) {
        return String.fromCharCode(65 + i);
    }

    function isJudgeQuestion(q) {
        return q.options.length === 2 && q.options[0] === '对' && q.options[1] === '错';
    }

    // 当前页面 + 所有 iframe 里的题目，按出现顺序去重；source 记录题目所在的 iframe（当前页面为 null），填答时用
    async function collectPageQuestions() {
        const local = collectQuestions(document).map(q => ({ ...q, source: null }));
        const frameQs = (await queryFrames('questions')).map(r =>
            Array.isArray(r.data.questions) ? r.data.questions.map(q => ({ ...q, source: r.source })) : []);
        const seen = new Set();
        return [local, ...frameQs].flat().filter(q => {
            if (typeof q.stem !== 'string' || !Array.isArray(q.options)) return false;
            const key = questionKey(q);
            if (seen.has(key)) return false;
            seen.add(key);
            return true;
        });
    }

    async function recognizeQuestions(btn, label) {
        btn.disabled = true;
        btn.innerText = '识别题目中...';
        try {
            return await collectPageQuestions();
        } finally {
            btn.disabled = false;
            btn.innerText = label;
        }
    }

    // 换了一页题就丢掉不属于本页的旧答案；同一页的答案保留，两边可以先后分开搜
    function setPageQuestions(questions) {
        pageQuestions = questions;
        const keys = new Set(questions.map(questionKey));
        [tkAnswers, dsAnswers, fillMarks, choices].forEach(map => [...map.keys()].forEach(key => { if (!keys.has(key)) map.delete(key); }));
        renderCompare();
    }

    function clearNotices() {
        compareNotices.replaceChildren();
    }

    // 当前页面的题直接填；iframe 里的题交给 iframe 中的脚本实例填
    async function fillPageQuestion(q, fill) {
        if (!q.source) return fillQuestion(findQuestionElements(document)[q.idx], fill);
        const data = await requestFrame(q.source, 'fill', { idx: q.idx, fill }, 5000);
        return !!(data && data.ok === true);
    }

    // 题目列表（发给 DeepSeek 和一键复制共用），题号全局连续
    function formatQuestions(questions, offset) {
        return questions.map((q, i) => {
            const type = isJudgeQuestion(q) ? '（判断题）' : q.multi ? '（多选题）' : q.options.length ? '（单选题）' : '';
            const options = isJudgeQuestion(q) ? [] : q.options.map((o, j) => `${optionLetter(j)}. ${o}`);
            return [`【第 ${offset + i + 1} 题】${type}`, q.stem, ...options].join('\n');
        }).join('\n\n');
    }

    // ---------- 答案对比 ----------

    // 某个来源的答案落在哪些选项上：选择题返回 { picked: 选项下标集合 }，判断题返回 { judge: '对' | '错' }，填空/简答返回 null
    function tikuhaiChoice(q, rec) {
        if (!rec || rec.status !== 'ok') return null;
        const judge = rec.answers.map(a => judgeValue(a.text)).find(Boolean);
        if (isJudgeQuestion(q)) return judge ? { judge } : null;
        if (!q.options.length) return null;
        // 按选项原文对应到页面上的选项（题库里的选项顺序可能和页面不同）
        const texts = q.options.map(normalizeText);
        const picked = new Set(rec.answers.map(a => texts.indexOf(normalizeText(a.text))).filter(i => i >= 0));
        return picked.size ? { picked } : null;
    }

    function deepSeekChoice(q, rec) {
        if (!rec || !rec.answer) return null;
        if (isJudgeQuestion(q)) {
            const judge = judgeValue(rec.answer) || (/^[AB]$/i.test(rec.answer) ? q.options[rec.answer.toUpperCase() === 'A' ? 0 : 1] : '');
            return judge ? { judge } : null;
        }
        const letters = deepSeekLetters(q, rec.answer);
        return letters.size ? { picked: new Set([...letters].map(l => l.charCodeAt(0) - 65)) } : null;
    }

    // 逐题分析两边答案：verdict 为
    //   same 一致 / diff 不一致 / text 需自行比较（都有答案但没法自动判断）/ tk-only、ds-only 只有一边有答案 / none 暂无答案
    // detail 是写给使用者看的分歧说明
    function analyze(q) {
        const key = questionKey(q);
        return analyzeRecords(q, tkAnswers.get(key), dsAnswers.get(key), key);
    }

    function analyzeRecords(q, tk, ds, key) {
        const hasTk = !!(tk && tk.status === 'ok'), hasDs = !!(ds && ds.answer);
        const info = { key, tk, ds, hasTk, hasDs, verdict: '', detail: '' };
        if (!hasTk || !hasDs) {
            info.verdict = hasTk ? 'tk-only' : hasDs ? 'ds-only' : 'none';
            return info;
        }
        const setVerdict = (same, detail) => {
            info.verdict = same ? 'same' : 'diff';
            info.detail = same ? '' : detail;
        };
        const a = tikuhaiChoice(q, tk), b = deepSeekChoice(q, ds);
        if (a && b && (a.judge || b.judge)) {
            setVerdict(a.judge === b.judge, `题库海判「${a.judge}」，DeepSeek 判「${b.judge}」`);
        } else if (a && b) {
            const letters = indexes => indexes.sort((x, y) => x - y).map(optionLetter).join('');
            const onlyTk = [...a.picked].filter(i => !b.picked.has(i)), onlyDs = [...b.picked].filter(i => !a.picked.has(i));
            const parts = [`题库海选 ${letters([...a.picked])}，DeepSeek 选 ${letters([...b.picked])}`];
            if (onlyTk.length) parts.push(`${onlyTk.map(optionLetter).join('、')} 只有题库海选了`);
            if (onlyDs.length) parts.push(`${onlyDs.map(optionLetter).join('、')} 只有 DeepSeek 选了`);
            setVerdict(!onlyTk.length && !onlyDs.length, parts.join('；'));
        } else if (!q.options.length) {
            const tkText = tk.answers.map(x => x.text).join('；');
            const judgeA = judgeValue(tkText), judgeB = judgeValue(ds.answer);
            if (judgeA && judgeB) {
                setVerdict(judgeA === judgeB, `题库海答「${judgeA}」，DeepSeek 答「${judgeB}」`);
            } else if (normalizeText(tkText) === normalizeText(ds.answer)) {
                setVerdict(true);
            } else {
                // 文字答案措辞常不同，不硬判对错，交给使用者比较
                info.verdict = 'text';
                info.detail = '文字答案，两边说法不同，请自行比较';
            }
        } else {
            info.verdict = 'text';
            info.detail = a ? 'DeepSeek 的回答没能对应到选项，请自行比较' : '题库海的答案没能对应到页面上的选项，请自行比较';
        }
        return info;
    }

    // 每题填哪一边：使用者选过就按选的；否则一致或只有一边有答案时自动选，不一致的默认不填
    function effectiveChoice(info, picked = choices.get(info.key)) {
        if (picked === 'none' || (picked === 'tk' && info.hasTk) || (picked === 'ds' && info.hasDs)) return picked;
        if (info.verdict === 'same' || info.verdict === 'tk-only') return 'tk';
        if (info.verdict === 'ds-only') return 'ds';
        return 'none';
    }

    // 题库海答案用页面上的选项字母显示，和 DeepSeek 的字母对得上
    function tikuhaiDisplay(q, rec) {
        const choice = tikuhaiChoice(q, rec);
        if (choice && choice.picked) return [...choice.picked].sort((a, b) => a - b).map(i => `${optionLetter(i)}. ${q.options[i]}`).join('；');
        if (choice && choice.judge) return choice.judge;
        return rec.display;
    }

    function sourceRow(label, cls, text, detail, muted) {
        const row = el('div', 'cx-src-row');
        row.append(el('span', 'cx-src-tag ' + cls, label), el('span', muted ? 'cx-src-muted' : 'cx-src-answer', text));
        if (detail) row.appendChild(el('div', 'cx-result-expl', detail));
        return row;
    }

    const VERDICT_BADGES = { same: ['same', '一致'], diff: ['diff', '不一致'], text: ['text', '需自行比较'] };

    // 标题：题号 + 一致/不一致标记
    function compareTitle(text, info) {
        const title = el('div', 'cx-batch-title', text);
        if (VERDICT_BADGES[info.verdict]) title.appendChild(el('span', 'cx-badge ' + VERDICT_BADGES[info.verdict][0], VERDICT_BADGES[info.verdict][1]));
        return title;
    }

    // 两边答案的对比卡片（整页和单题共用）：选项上标出各自选了哪个、分歧说明、两边各自的答案和解析
    // tkEmpty / dsEmpty 是这一边还没有结果时显示的文字
    function buildCompareCard(q, info, tkEmpty, dsEmpty) {
        const { tk, ds } = info;
        const card = el('div', 'cx-result-card');
        card.appendChild(el('div', 'cx-result-stem', q.stem));
        const judge = isJudgeQuestion(q), a = tikuhaiChoice(q, tk), b = deepSeekChoice(q, ds);
        const chosen = (choice, j) => !!choice && (judge ? choice.judge === q.options[j] : !!choice.picked && choice.picked.has(j));
        q.options.forEach((o, j) => {
            const byTk = chosen(a, j), byDs = chosen(b, j);
            const row = el('div', 'cx-result-option' + (byTk && byDs ? ' correct' : ''), judge ? o : `${optionLetter(j)}. ${o}`);
            if (byTk) row.appendChild(el('span', 'cx-src-tag tk', '题库海'));
            if (byDs) row.appendChild(el('span', 'cx-src-tag ds', 'DeepSeek'));
            card.appendChild(row);
        });
        if (info.detail) card.appendChild(el('div', 'cx-diff' + (info.verdict === 'text' ? ' text' : ''), (info.verdict === 'diff' ? '分歧：' : '') + info.detail));

        if (!tk) card.appendChild(sourceRow('题库海', 'tk', tkEmpty, '', true));
        else if (tk.status !== 'ok') card.appendChild(sourceRow('题库海', 'tk', tk.text, '', true));
        else card.appendChild(sourceRow('题库海', 'tk', tikuhaiDisplay(q, tk) + (tk.ai ? '（题库无此题，AI 作答）' : ''), tk.explanation && '解析：' + tk.explanation));

        if (!ds) card.appendChild(sourceRow('DeepSeek', 'ds', dsEmpty, '', true));
        else if (ds.error) card.appendChild(sourceRow('DeepSeek', 'ds', ds.error, '', true));
        else if (!ds.answer) card.appendChild(sourceRow('DeepSeek', 'ds', 'DeepSeek 没有回答这道题', '', true));
        else card.appendChild(sourceRow('DeepSeek', 'ds', ds.answer, ds.reason && '解析：' + ds.reason));
        return card;
    }

    function renderCompareItem(q, i, info) {
        const block = el('div', 'cx-compare-item');
        const title = compareTitle(`第 ${i + 1} 题`, info);
        const mark = fillMarks.get(info.key);
        if (mark) title.appendChild(el('span', 'cx-fill-status' + (mark.ok ? '' : ' fail'), mark.ok ? `已填入${mark.source}答案` : `${mark.source}答案未能填入`));
        const card = buildCompareCard(q, info, tkRunning ? '等待搜索' : '未搜索', dsRun ? '作答中...' : '未搜索');

        // 每题单独选择填入哪一边的答案
        if (info.hasTk || info.hasDs) card.appendChild(choiceRow(info, effectiveChoice(info), value => {
            choices.set(info.key, value);
            renderCompare();
        }));

        block.append(title, card);
        return block;
    }

    // 「填入：题库海 / DeepSeek / 不填」，只列出有答案的一边
    function choiceRow(info, current, onPick) {
        const row = el('div', 'cx-choice-row');
        row.appendChild(el('span', 'cx-choice-label', '填入：'));
        [['tk', '题库海', info.hasTk], ['ds', 'DeepSeek', info.hasDs], ['none', '不填', true]].forEach(([value, label, available]) => {
            if (!available) return;
            const btn = el('button', 'cx-choice' + (current === value ? ' active' : ''), label);
            btn.type = 'button';
            btn.addEventListener('click', () => onPick(value));
            row.appendChild(btn);
        });
        return row;
    }

    // 点汇总里的题号，滚动到对应题目并闪一下
    function jumpTo(i) {
        const block = compareList.children[i];
        const scroller = compareList.closest('.cx-tab-content');
        if (!block || !scroller) return;
        scroller.scrollTop += block.getBoundingClientRect().top - scroller.getBoundingClientRect().top - 8;
        block.classList.remove('cx-flash');
        void block.offsetWidth;
        block.classList.add('cx-flash');
    }

    const SUMMARY_GROUPS = [
        ['same', '一致', 'same'],
        ['diff', '不一致', 'diff'],
        ['text', '需自行比较', 'text'],
        ['tk-only', '只有题库海有答案', 'neutral'],
        ['ds-only', '只有 DeepSeek 有答案', 'neutral'],
        ['none', '暂无答案', 'neutral']
    ];

    function renderSummary(infos) {
        compareSummary.replaceChildren();
        const tkSearched = infos.some(info => info.tk), dsSearched = infos.some(info => info.ds);
        if (!tkSearched && !dsSearched) return;
        const box = el('div', 'cx-summary');
        box.appendChild(el('div', 'cx-summary-title', `对比结果 · 共 ${infos.length} 题`));
        SUMMARY_GROUPS.forEach(([verdict, label, cls]) => {
            const indexes = infos.map((info, i) => (info.verdict === verdict ? i : -1)).filter(i => i >= 0);
            if (!indexes.length) return;
            const line = el('div', 'cx-summary-line');
            line.append(el('span', 'cx-badge ' + cls, label), el('span', 'cx-summary-count', `${indexes.length} 题`));
            // 一致的题通常很多，只列数量；其余列出题号，点击可跳转
            if (verdict !== 'same') {
                const nums = el('span', 'cx-summary-nums', '第 ');
                indexes.forEach((i, k) => {
                    if (k) nums.append('、');
                    const jump = el('span', 'cx-jump', String(i + 1));
                    jump.addEventListener('click', () => jumpTo(i));
                    nums.appendChild(jump);
                });
                nums.append(' 题');
                line.appendChild(nums);
            }
            box.appendChild(line);
        });
        const hints = [];
        if (!tkSearched) hints.push('题库海还没搜索，搜索后可以逐题对比。');
        if (!dsSearched) hints.push('DeepSeek 还没搜索，搜索后可以逐题对比。');
        if (infos.some(info => info.verdict === 'diff' || info.verdict === 'text')) hints.push('不一致、需自行比较的题默认不填，请在题目下方选择采用哪一边的答案。');
        hints.forEach(hint => box.appendChild(el('div', 'cx-summary-hint', hint)));
        compareSummary.appendChild(box);
    }

    function renderCompare() {
        const infos = pageQuestions.map(analyze);
        renderSummary(infos);
        compareList.replaceChildren(...pageQuestions.map((q, i) => renderCompareItem(q, i, infos[i])));
        updateFillBar(infos);
    }

    // ---------- 按每题所选的答案填入页面 ----------

    let filling = false;

    function chosenFills() {
        return pageQuestions.map(q => {
            const info = analyze(q), choice = effectiveChoice(info);
            if (choice === 'tk') return { q, key: info.key, name: '题库海', fill: { answers: info.tk.answers, display: info.tk.display } };
            if (choice === 'ds') return { q, key: info.key, name: 'DeepSeek', fill: deepSeekFill(q, info.ds.answer) };
            return null;
        }).filter(Boolean);
    }

    function updateFillBar(infos) {
        const hasTk = infos.some(info => info.hasTk), hasDs = infos.some(info => info.hasDs);
        fillBar.hidden = !hasTk && !hasDs;
        pickTkBtn.hidden = !hasTk;
        pickDsBtn.hidden = !hasDs;
        if (filling) return;
        const count = infos.filter(info => effectiveChoice(info) !== 'none').length;
        fillBtn.disabled = !count;
        fillBtn.innerText = count ? `按所选答案填充 · ${count} 题` : '还没有选择要填入的答案';
    }

    // 「全部采用某一边」：那一边有答案的题都改选它，没有答案的题保持原来的选择
    function pickAll(source) {
        pageQuestions.map(analyze).forEach(info => {
            if (source === 'tk' ? info.hasTk : info.hasDs) choices.set(info.key, source);
        });
        renderCompare();
    }

    async function fillChosen() {
        const items = chosenFills();
        if (!items.length || filling) return;
        filling = true;
        fillBtn.disabled = true;
        fillBtn.innerText = '填充中...';
        let filled = 0;
        for (const item of items) {
            let ok = false;
            try { ok = await fillPageQuestion(item.q, item.fill); } catch (e) { console.error('[学习通助手] 填答失败', e); }
            if (ok) filled++;
            fillMarks.set(item.key, { source: item.name, ok });
        }
        filling = false;
        clearNotices();
        const fromTk = items.filter(item => item.name === '题库海').length;
        showNotice(compareNotices, `已填入 ${filled} / ${items.length} 题（题库海 ${fromTk} 题，DeepSeek ${items.length - fromTk} 题），提交前请核对。`, filled ? 'success' : 'error');
        renderCompare();
    }

    pickTkBtn.addEventListener('click', () => pickAll('tk'));
    pickDsBtn.addEventListener('click', () => pickAll('ds'));
    fillBtn.addEventListener('click', fillChosen);

    // ---------- 题库海：逐题串行请求 ----------

    const TK_BATCH_LABEL = '题库海搜索';
    const STOP_BATCH_CODES = ['UNAUTHORIZED_CONSUMER', 'UNAUTHORIZED_CHANNEL', 'SCENE_NOT_ALLOWED', 'ENDPOINT_BLOCKED'];
    let tkRunning = false, tkStopped = false;

    async function searchWithRetry(token, q) {
        for (let attempt = 0; ; attempt++) {
            const res = await searchTikuhai(token, q.stem, q.options);
            if (res.error && res.error.code === 'RATE_LIMITED' && attempt < 3) {
                await delay(2000 * 2 ** attempt);
                continue;
            }
            return res;
        }
    }

    // 三态按文档顺序判断：未收录 → 余额耗尽 → 答案待补录
    function tikuhaiRecord(res) {
        if (!res.success) {
            const error = res.error || {};
            return { status: 'error', text: SEARCH_ERRORS[error.code] || stripTags(error.message) || '搜索失败' };
        }
        const data = res.data, meta = res.meta || {};
        if (!data) return { status: 'miss', text: '题库未收录' };
        if (meta.billing_result === 'exhausted') return { status: 'error', text: '积分不足，答案未返回' };
        const answers = resultAnswers(res);
        if (!answers.length) return { status: 'miss', text: data.answer_status === 'missing' ? '已收录，答案待补录' : '没有答案' };
        const explanation = (data.items || []).map(item => item.explanation).filter(Boolean).join('\n');
        return { status: 'ok', answers, display: resultAnswerText(res), explanation, ai: !!data.ai_generated };
    }

    async function runTikuhaiBatch() {
        if (tkRunning) {
            tkStopped = true;
            tkBatchBtn.innerText = '正在停止...';
            return;
        }
        clearNotices();
        const token = tokenInput.value.trim();
        if (!token) return showMissingToken(compareNotices);
        const questions = await recognizeQuestions(tkBatchBtn, TK_BATCH_LABEL);
        if (!questions.length) return showNotice(compareNotices, NO_QUESTION_TEXT, 'error');

        const encrypted = questions.filter(q => q.encrypted).length;
        const confirmText = `识别到 ${questions.length} 道题，将逐题在题库海搜索。\n每道命中的题最多扣 1 积分（未收录不扣费，7 天内重复搜同一题不重复扣费）。`
            + (encrypted ? `\n\n注意：其中 ${encrypted} 道题的文字被学习通字体加密，识别出的题干可能是乱码，大概率搜不到。` : '')
            + '\n\n是否继续？';
        if (!window.confirm(confirmText)) return;

        GM_setValue(TOKEN_KEY, token);
        tkRunning = true;
        tkStopped = false;
        tkBatchBtn.innerText = '停止';
        setPageQuestions(questions);
        let done = 0, hit = 0, miss = 0, failed = 0, credit = null;
        try {
            for (const [i, q] of questions.entries()) {
                if (tkStopped) break;
                tkStatus.textContent = `题库海：正在搜索第 ${i + 1} / ${questions.length} 题...`;
                let res = null, rec;
                try {
                    res = await searchWithRetry(token, q);
                    rec = tikuhaiRecord(res);
                } catch (e) {
                    rec = { status: 'error', text: e.message };
                }
                done++;
                tkAnswers.set(questionKey(q), rec);
                renderCompare();

                const meta = (res && res.meta) || {};
                if (meta.credit_remaining != null) credit = meta.credit_remaining;
                if (rec.status === 'ok') hit++;
                else if (rec.status === 'miss') miss++;
                else failed++;
                if (res && !res.success && STOP_BATCH_CODES.includes(res.error && res.error.code)) {
                    showNotice(compareNotices, rec.text, 'error', res.error.details && res.error.details.purchase_url);
                    break;
                }
                if (res && res.success && meta.billing_result === 'exhausted') {
                    showNotice(compareNotices, '题库海积分不足，已停止搜索。', 'error', meta.purchase_url);
                    break;
                }
                await delay(300);
            }
        } finally {
            const status = tkStopped ? '已停止' : done < questions.length ? '已中止' : '搜索完成';
            tkStatus.textContent = `题库海${status}：已搜 ${done} / ${questions.length} 题，命中 ${hit}，未收录 ${miss}`
                + (failed ? `，失败 ${failed}` : '') + (credit != null ? `，剩余积分 ${credit}` : '');
            tkRunning = false;
            tkBatchBtn.innerText = TK_BATCH_LABEL;
            renderCompare();
        }
    }

    tkBatchBtn.addEventListener('click', runTikuhaiBatch);

    // ---------- DeepSeek 网页版作答 ----------

    const DS_LABEL = 'DeepSeek 搜索';
    const DS_BATCH_SIZE = 30; // 每条消息最多放多少道题：批次少，来回等待就少；太多时模型容易漏答
    const DS_TIMEOUT = 15 * 60 * 1000;
    let dsRun = null; // 进行中的任务：{ finish }
    const dsThinkBox = bindSwitch('cx-ds-think', 'dsDeepThink');
    const dsSearchBox = bindSwitch('cx-ds-search', 'dsWebSearch');

    function buildDeepSeekPrompt(questions, offset) {
        return [
            '请回答下面的题目。只输出一个 JSON 数组，放在 ```json 代码块里，不要输出其它内容。',
            '数组每项格式：{"no": 题号, "answer": "答案", "reason": "解析，一句话，不超过 30 字"}',
            'answer 的写法：选择题写选项字母（多选连写，如 "ACD"）；判断题写 "对" 或 "错"；填空题各空之间用 "；" 分隔；简答题写简要答案。',
            '',
            formatQuestions(questions, offset)
        ].join('\n');
    }

    function deepSeekAnswerText(item) {
        return item && item.answer != null ? String(item.answer).trim() : '';
    }

    // 选择题的答案字母（只认纯字母的回答），不是选择题或回答不是字母时返回空集合
    function deepSeekLetters(q, answer) {
        if (isJudgeQuestion(q) || !q.options.length || !/^[A-J\s,，、;；]+$/i.test(answer)) return new Set();
        return new Set(answer.toUpperCase().match(/[A-J]/g).filter(l => q.options[l.charCodeAt(0) - 65]));
    }

    // DeepSeek 的回答 → fillQuestion 需要的格式
    function deepSeekFill(q, answer) {
        const letters = deepSeekLetters(q, answer);
        let answers;
        if (letters.size) {
            answers = [...letters].map(l => ({ text: q.options[l.charCodeAt(0) - 65], letter: l }));
        } else if (isJudgeQuestion(q) && /^[AB]$/i.test(answer)) {
            answers = [{ text: q.options[answer.toUpperCase() === 'A' ? 0 : 1], letter: '' }];
        } else {
            // 填空题各空用「；」分隔；只有一个输入框（简答题）时 fillBlanks 会再拼回去
            const texts = q.options.length ? [answer] : answer.split(/[；;]/).map(t => t.trim()).filter(Boolean);
            answers = texts.map(text => ({ text, letter: '' }));
        }
        return { answers, display: answer };
    }

    // DeepSeek 标签页在后台暂停刷新、需要使用者切过去时的醒目提醒
    function pauseAlert() {
        const box = el('div', 'cx-alert');
        const body = el('div', 'cx-alert-body');
        body.append('请切换到 DeepSeek 标签页看一眼（标签标题在闪', el('b', '', '「⚠ 请点我」'), '），不用点任何按钮，答案就会继续返回。');
        box.append(el('div', 'cx-alert-title', '⚠ 需要你操作：DeepSeek 页面暂停了'), body);
        return box;
    }

    // 打开 DeepSeek 标签页并等待结果；返回 { status: 'done' | 'error' | 'stopped', texts, error, tab }
    // counts 是每批的题数，DeepSeek 页面据此判断一批是否答完
    // options 是 { deepThink, webSearch }，单题和整页各用各的开关
    function askDeepSeekInTab(prompts, counts, options, onProgress) {
        return new Promise(resolve => {
            const id = newId();
            GM_setValue(DS_TASK_KEY, { id, prompts, counts, deepThink: !!options.deepThink, webSearch: !!options.webSearch, status: 'pending', created: Date.now() });
            let tab = null;
            const listener = GM_addValueChangeListener(DS_RESULT_KEY, (key, oldValue, value) => {
                if (!value || value.id !== id) return;
                if (value.status === 'running') onProgress(value);
                else finish(value);
            });
            const timer = setTimeout(() => finish({ status: 'error', error: '等待 DeepSeek 超时' }), DS_TIMEOUT);
            function finish(value) {
                clearTimeout(timer);
                GM_removeValueChangeListener(listener);
                // 没正常答完就把任务标记为取消，DeepSeek 页面发下一批之前会检查
                if (value.status !== 'done') GM_setValue(DS_TASK_KEY, { id, status: 'cancelled' });
                dsRun = null;
                resolve({ ...value, tab });
            }
            dsRun = { finish };
            // 在后台打开，不打断当前页面；想看 DeepSeek 的思考过程可以切过去
            try {
                tab = GM_openInTab(DS_URL + '#' + DS_TAG + id, { active: false, insert: true, setParent: true });
            } catch (e) {
                finish({ status: 'error', error: '无法打开 DeepSeek 标签页：' + (e.message || e) });
            }
        });
    }

    async function runDeepSeek() {
        if (dsRun) {
            dsRun.finish({ status: 'stopped' });
            return;
        }
        clearNotices();
        const questions = await recognizeQuestions(dsBtn, DS_LABEL);
        if (!questions.length) return showNotice(compareNotices, NO_QUESTION_TEXT, 'error');

        const encrypted = questions.filter(q => q.encrypted).length;
        const confirmText = `识别到 ${questions.length} 道题，将在后台打开 DeepSeek 网页版（需已登录）自动提问，每 ${DS_BATCH_SIZE} 道题发一条消息。`
            + '\n作答期间请不要在那个标签页里操作。'
            + (encrypted ? `\n\n注意：其中 ${encrypted} 道题的文字被学习通字体加密，识别出的题干可能是乱码，AI 无法正确作答。` : '')
            + '\n\n是否继续？';
        if (!window.confirm(confirmText)) return;

        const prompts = [], counts = [];
        for (let i = 0; i < questions.length; i += DS_BATCH_SIZE) {
            const batch = questions.slice(i, i + DS_BATCH_SIZE);
            prompts.push(buildDeepSeekPrompt(batch, i));
            counts.push(batch.length);
        }

        // 题号 → DeepSeek 的回答；生成过程中答完一题就先显示一题
        const answers = new Map();
        const addItems = items => items.forEach(item => {
            const no = Number(item && item.no);
            if (!Number.isInteger(no) || no < 1 || no > questions.length) return;
            answers.set(no, item);
            dsAnswers.set(questionKey(questions[no - 1]), { answer: deepSeekAnswerText(item), reason: item.reason != null ? String(item.reason) : '' });
        });

        dsStatus.textContent = 'DeepSeek：正在打开网页版...';
        dsBtn.innerText = '停止';
        singleDsBtn.disabled = true;
        let result, pauseEl = null;
        try {
            const pending = askDeepSeekInTab(prompts, counts, { deepThink: dsThinkBox.checked, webSearch: dsSearchBox.checked }, ({ done, total, partial, notes, hint }) => {
                if (Array.isArray(notes) && notes.length && !compareNotices.textContent.includes(notes[0])) notes.forEach(note => showNotice(compareNotices, String(note), 'error'));
                if (Array.isArray(partial)) addItems(partial);
                // 暂停提醒紧跟在 DeepSeek 按钮下面；答案开始返回就收起
                if (hint && !pauseEl) dsBtn.closest('.cx-ds-row').after(pauseEl = pauseAlert());
                if (Array.isArray(partial) && pauseEl) {
                    pauseEl.remove();
                    pauseEl = null;
                }
                dsStatus.textContent = 'DeepSeek：' + (pauseEl ? '已暂停，等待你切到 DeepSeek 标签页' : '正在作答')
                    + (total > 1 ? `（第 ${done + 1} / ${total} 批）` : '') + (answers.size ? `，已答 ${answers.size} / ${questions.length} 题` : '') + '...';
                if (Array.isArray(partial)) renderCompare();
            });
            setPageQuestions(questions);
            result = await pending;
        } finally {
            dsBtn.innerText = DS_LABEL;
            singleDsBtn.disabled = false;
            if (pauseEl) pauseEl.remove();
        }

        (Array.isArray(result.texts) ? result.texts : []).forEach(text => addItems(parseJsonArray(String(text)) || parseAnswerItems(String(text))));
        // 正常答完时，没答到的题也记下来（显示「没有回答」）
        if (result.status === 'done') questions.forEach((q, i) => {
            if (!answers.has(i + 1)) dsAnswers.set(questionKey(q), { answer: '', reason: '' });
        });

        if (result.status === 'stopped') {
            dsStatus.textContent = `DeepSeek 已停止：作答 ${answers.size} / ${questions.length} 题（DeepSeek 页面里正在生成的回答不会自动中断）`;
        } else if (result.status === 'error') {
            dsStatus.textContent = `DeepSeek 出错：作答 ${answers.size} / ${questions.length} 题`;
            showNotice(compareNotices, result.error || 'DeepSeek 作答失败', 'error');
        } else if (!answers.size) {
            dsStatus.textContent = 'DeepSeek 作答完成，但没能解析回答';
            showNotice(compareNotices, '没能解析 DeepSeek 的回答，可以切到 DeepSeek 标签页直接查看。', 'error');
        } else {
            dsStatus.textContent = `DeepSeek 作答完成：${answers.size} / ${questions.length} 题（AI 作答，仅供参考）`;
            // 全部解析成功才关掉 DeepSeek 标签页，否则留着方便查看原始回答
            if (answers.size >= questions.length && result.tab) result.tab.close();
        }
        renderCompare();
    }

    dsBtn.addEventListener('click', runDeepSeek);

    // ---------- 一键复制：题目 + 提示词，拿去其他 AI 提问 ----------

    const COPY_LABEL = '一键复制全部题目（发给其他 AI）';

    function buildCopyPrompt(questions) {
        return [
            `下面共 ${questions.length} 道题，请逐题作答，每道题都给出答案和解析。`,
            '请按这个格式回答：',
            '第 1 题',
            '答案：选择题写选项字母（多选写全部字母，如 ACD）；判断题写「对」或「错」；填空题各空之间用「；」分隔；简答题写要点',
            '解析：简要说明理由',
            '',
            formatQuestions(questions, 0)
        ].join('\n');
    }

    function copyText(text) {
        if (typeof GM_setClipboard === 'function') {
            GM_setClipboard(text, 'text');
            return Promise.resolve();
        }
        return navigator.clipboard.writeText(text);
    }

    async function copyAllQuestions() {
        clearNotices();
        const questions = await recognizeQuestions(copyBtn, COPY_LABEL);
        if (!questions.length) return showNotice(compareNotices, NO_QUESTION_TEXT, 'error');
        setPageQuestions(questions);
        try {
            await copyText(buildCopyPrompt(questions));
            const encrypted = questions.filter(q => q.encrypted).length;
            showNotice(compareNotices, `已复制 ${questions.length} 道题和提示词，粘贴到其他 AI 里即可提问。`
                + (encrypted ? `其中 ${encrypted} 道题的文字被学习通字体加密，可能是乱码。` : ''), 'success');
        } catch (e) {
            showNotice(compareNotices, '复制失败：' + (e.message || e), 'error');
        }
    }

    copyBtn.addEventListener('click', copyAllQuestions);

    // ========== 课程资源下载 ==========
    // 以下资源下载逻辑基于对学习通页面结构及网络接口的独立分析实现。
    // 核心思路：
    // 1. 学习通章节页中，每个附件/视频/PDF 都通过带有 objectid 属性的 iframe 嵌入。
    // 2. 通过请求 /ananas/status/{objectid}?flag=normal 接口，可获取资源的真实下载地址、文件名及类型。
    // 3. 根据返回的 mimetype 和文件名后缀，区分 PDF、视频、PPT 等类型，并分别处理下载或新标签页打开。

    const RESOURCE_PAGE_RE = /mycourse\/(studentstudy|teacherstudy)|nodedetailcontroller/i;
    const FILE_TYPES = [[/^pptx?$/i, 'PPT'], [/^docx?$/i, '文档'], [/^xlsx?$/i, '表格'], [/^(zip|rar|7z)$/i, '压缩包']];
    const resSelectBtn = document.getElementById('cx-res-select');
    const resPdfBtn = document.getElementById('cx-res-pdf');
    const resStatus = document.getElementById('cx-res-status');
    let resBusy = false;
    let resModal = null;

    function setResStatus(text, type) {
        resStatus.replaceChildren(el('div', type || '', text));
    }

    function cleanFilename(name) {
        return name.replace(/[\/\\?%*:|"<>\x00-\x1f]/g, '-').replace(/\s+/g, ' ').trim();
    }

    function formatMB(bytes) {
        return ((bytes || 0) / 1024 / 1024).toFixed(2);
    }

    function gmGetJson(url) {
        return new Promise((resolve, reject) => {
            GM_xmlhttpRequest({
                method: 'GET', url, timeout: 20000,
                headers: { Referer: location.href },
                onload: res => {
                    if (res.status !== 200) return reject(new Error(`HTTP ${res.status}`));
                    try { resolve(JSON.parse(res.responseText)); } catch (e) { reject(new Error('返回内容无法解析')); }
                },
                onerror: () => reject(new Error('网络错误')),
                ontimeout: () => reject(new Error('请求超时'))
            });
        });
    }

    function getChapterTitle() {
        const titleEl = document.querySelector('.prev_title') || document.querySelector('.tab_highlight');
        return (titleEl && titleEl.textContent.trim()) || document.title.split(/[ \-_]/)[0] || '课程文件';
    }

    // 调用学习通 /ananas/status/{objectid} 接口，解析资源元数据，提取真实下载地址
    async function fetchResourceDetails(objectid, origin, chapterTitle) {
        const resource = { objectid, filename: `未知资源_${objectid}`, type: '未知', downloadUrl: null, openDirectly: false, error: null };
        try {
            const json = await gmGetJson(`${origin}/ananas/status/${encodeURIComponent(objectid)}?flag=normal`);
            const name = json.filename || `资源_${objectid}`;
            const lower = name.toLowerCase();
            let ext = name.includes('.') ? name.split('.').pop() : '';
            let url = null;

            // 接口返回的字段中，pdf 字段对应 PDF 预览/下载地址；http 字段通常对应视频流或通用资源地址；download 字段对应附件直链
            if (json.pdf) {
                resource.type = 'PDF';
                url = json.pdf;
                ext = 'pdf';
            } else if (json.http && (lower.endsWith('.mp4') || json.http.includes('.mp4') || String(json.mimetype || '').includes('video'))) {
                resource.type = '视频';
                url = json.http;
                ext = ext || 'mp4';
            } else if (lower.includes('.ppt') && json.download) {
                // PPT 课件通常需要在新标签页由学习通自身播放器打开，直接下载往往得到的是播放页而非文件
                resource.type = 'PPT';
                url = json.download;
                resource.openDirectly = true;
            } else if (json.download) {
                resource.type = (FILE_TYPES.find(([re]) => re.test(ext)) || [null, '文件'])[1];
                url = json.download;
            } else if (json.http) {
                resource.type = '链接/其他';
                url = json.http;
            }
            if (!url) throw new Error('没有下载地址');
            resource.downloadUrl = /^https?:/i.test(url) ? url : (url.startsWith('//') ? 'https:' : 'https://') + url;
            resource.filename = cleanFilename(`${chapterTitle}_${name.replace(/\.[^.]+$/, '')}.${ext || 'bin'}`);
        } catch (e) {
            console.error(`[学习通助手] 获取资源 ${objectid} 信息失败`, e);
            resource.error = e.message;
        }
        return resource;
    }

    // 聚合当前页面及所有子 iframe 中发现的资源，按 objectid 去重后统一查询详情
    async function findResources() {
        const chapterTitle = getChapterTitle();
        const groups = [{ objectids: collectObjectIds(document), origin: location.origin }, ...(await queryFrames('resources')).map(r => r.data)];
        const seen = new Set(), tasks = [];
        groups.forEach(({ objectids, origin }) => {
            if (!Array.isArray(objectids)) return;
            const base = isTrustedOrigin(origin) ? origin : 'https://mooc1.chaoxing.com';
            objectids.forEach(id => {
                if (typeof id !== 'string' || seen.has(id)) return;
                seen.add(id);
                tasks.push(fetchResourceDetails(id, base, chapterTitle));
            });
        });
        return Promise.all(tasks);
    }

    function openInTab(url, active) {
        window.open(url, '_blank', 'noopener');
    }

    // 通过 GM_xmlhttpRequest 下载单个资源，实时显示进度条，下载完成后触发浏览器保存
    function downloadResource(res, prefix) {
        return new Promise(resolve => {
            const bar = el('progress');
            bar.max = 100;
            bar.value = 0;
            const size = el('div', 'cx-res-size', '计算中...');
            resStatus.replaceChildren(el('div', '', `${prefix}正在下载：${res.filename}`), bar, size);
            GM_xmlhttpRequest({
                method: 'GET', url: res.downloadUrl, responseType: 'blob',
                headers: { Referer: location.href },
                onprogress: e => {
                    if (e.total > 0) {
                        bar.value = e.loaded / e.total * 100;
                        size.textContent = `${formatMB(e.loaded)} / ${formatMB(e.total)} MB`;
                    } else {
                        bar.removeAttribute('value');
                        size.textContent = `${formatMB(e.loaded)} MB`;
                    }
                },
                onload: r => {
                    if (r.status !== 200 || !r.response) return resolve(`HTTP ${r.status}`);
                    let name = res.filename;
                    // 若服务端返回的 MIME 类型表明是 PDF，但文件名后缀不对，则自动修正为 .pdf
                    if (r.response.type === 'application/pdf' && !/\.pdf$/i.test(name)) name = name.replace(/\.[^.]+$/, '') + '.pdf';
                    saveBlob(r.response, name);
                    resolve(null);
                },
                onerror: () => resolve('网络错误'),
                ontimeout: () => resolve('超时'),
                onabort: () => resolve('已取消')
            });
        });
    }

    // 对资源列表分类处理：PPT 课件类直接在新标签页打开（学习通课件需要其自身解析器），其余文件串行下载
    async function downloadResources(list) {
        const toOpen = list.filter(r => r.openDirectly), toDownload = list.filter(r => !r.openDirectly);
        toOpen.forEach(r => openInTab(r.downloadUrl, list.length === 1));
        const failures = [];
        for (const [i, res] of toDownload.entries()) {
            const error = await downloadResource(res, toDownload.length > 1 ? `(${i + 1}/${toDownload.length}) ` : '');
            if (error) failures.push(`${res.filename}（${error}）`);
        }
        const parts = [];
        if (toDownload.length) parts.push(`已下载 ${toDownload.length - failures.length}/${toDownload.length} 个文件`);
        if (toOpen.length) parts.push(`已在新标签页打开 ${toOpen.length} 个课件`);
        resStatus.replaceChildren(el('div', failures.length ? 'error' : 'success', parts.join('，')));
        failures.forEach(f => resStatus.appendChild(el('div', 'error', '下载失败：' + f)));
    }

    async function runResourceTask(task) {
        if (resBusy) return;
        resBusy = resSelectBtn.disabled = resPdfBtn.disabled = true;
        activateTab('cx-tab-download');
        try {
            await task();
        } catch (e) {
            console.error('[学习通助手] 资源下载出错', e);
            setResStatus('出错了：' + (e.message || e), 'error');
        } finally {
            resBusy = resSelectBtn.disabled = resPdfBtn.disabled = false;
        }
    }

    function getResModal() {
        if (resModal) return resModal;
        const overlay = el('div', 'cx-helper-modal-overlay');
        const box = el('div', 'cx-helper-modal');
        const head = el('div', 'cx-helper-modal-head');
        const selectAllLabel = el('label', 'cx-helper-modal-selectall');
        const selectAll = el('input');
        selectAll.type = 'checkbox';
        selectAllLabel.append(selectAll, '全选');
        head.append(el('div', 'cx-helper-modal-title', '选择要下载的资源'), selectAllLabel);
        const note = el('div', 'cx-helper-modal-note');
        const list = el('div', 'cx-helper-modal-list');
        const actions = el('div', 'cx-helper-modal-actions');
        const cancelBtn = el('button', 'cx-helper-modal-btn', '取消');
        const confirmBtn = el('button', 'cx-helper-modal-btn primary', '下载选中');
        actions.append(cancelBtn, confirmBtn);
        box.append(head, note, list, actions);
        overlay.appendChild(box);
        overlay.style.display = 'none';
        document.body.appendChild(overlay);

        const close = () => { overlay.style.display = 'none'; };
        cancelBtn.addEventListener('click', close);
        overlay.addEventListener('click', e => { if (e.target === overlay) close(); });
        document.addEventListener('keydown', e => { if (e.key === 'Escape' && overlay.style.display !== 'none') close(); });
        selectAll.addEventListener('change', () => list.querySelectorAll('input').forEach(cb => { cb.checked = selectAll.checked; }));
        confirmBtn.addEventListener('click', () => {
            const selected = [...list.querySelectorAll('input:checked')].map(cb => resModal.resources[Number(cb.value)]);
            if (!selected.length) return nativeAlert('请至少选择一个要下载的资源。');
            close();
            runResourceTask(() => downloadResources(selected));
        });

        resModal = { overlay, list, note, selectAll, resources: [], isOpen: () => overlay.style.display !== 'none' };
        return resModal;
    }

    function showResourceModal(resources, failedCount) {
        const modal = getResModal();
        modal.resources = resources;
        modal.selectAll.checked = false;
        modal.note.textContent = failedCount ? `另有 ${failedCount} 个资源没能获取到下载地址，未列出。` : '';
        modal.note.style.display = failedCount ? '' : 'none';
        modal.list.replaceChildren(...resources.map((res, i) => {
            const item = el('label', 'cx-helper-modal-item');
            const checkbox = el('input');
            checkbox.type = 'checkbox';
            checkbox.value = i;
            const name = el('span', 'cx-helper-modal-name', res.filename);
            name.title = res.filename;
            item.append(checkbox, name, el('span', 'cx-helper-modal-type', res.type));
            return item;
        }));
        modal.overlay.style.display = 'flex';
    }

    resSelectBtn.addEventListener('click', () => runResourceTask(async () => {
        setResStatus('正在查找资源列表...');
        const resources = await findResources();
        const valid = resources.filter(r => !r.error);
        if (!resources.length) return setResStatus('未找到任何资源，请在课程章节学习页面使用。', 'error');
        if (!valid.length) return setResStatus(`找到 ${resources.length} 个资源，但都没能获取到下载地址。`, 'error');
        resStatus.replaceChildren();
        showResourceModal(valid, resources.length - valid.length);
    }));

    function downloadAllPdfs() {
        return runResourceTask(async () => {
            setResStatus('正在查找 PDF...');
            const pdfs = (await findResources()).filter(r => r.type === 'PDF' && !r.error);
            if (!pdfs.length) return setResStatus('未找到可下载的 PDF。', 'error');
            await downloadResources(pdfs);
        });
    }

    resPdfBtn.addEventListener('click', downloadAllPdfs);

    // D 键：只在课程章节页生效；iframe 里按下的由 iframe 转发过来
    function handlePdfHotkey() {
        if (!RESOURCE_PAGE_RE.test(location.href) || (resModal && resModal.isOpen())) return;
        downloadAllPdfs();
    }

    document.addEventListener('keydown', ev => {
        if (!isPdfHotkey(ev) || !RESOURCE_PAGE_RE.test(location.href)) return;
        ev.preventDefault();
        handlePdfHotkey();
    });

    // 解除复制粘贴右键限制
    const copyToggle = document.getElementById('cx-toggle-copy');
    copyToggle.addEventListener('change', () => {
        if (copyToggle.checked) {
            enableCopyUnlock();
            collectFrames(pageWindow).forEach(frame => post(frame, { type: 'unlock' }));
        } else {
            // 已注入的解除逻辑无法撤销，开关保持开启状态以反映实际情况
            copyToggle.checked = true;
            nativeAlert("刷新页面即可恢复默认限制。");
        }
    });

    }
})();