// ==UserScript==
// @name         超星通用题目提取器
// @namespace    http://tampermonkey.net/
// @version      1.0
// @description  从超星“查看已批阅作业”或类似考试回顾页面提取题目。支持自动提取和手动提取，带自定义提示。
// @author       毫厘
// @match        *://*.chaoxing.com/exam-ans/exam/test/reVersionPaperMarkContentNew*
// @match        *://*.chaoxing.com/mooc-ans/work/selectWorkQuestionYiPiYue*
// @grant        GM_setClipboard
// @grant        GM_addStyle
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_registerMenuCommand
// ==/UserScript==

(function() { // 使用立即执行函数表达式 (IIFE) 封装代码，避免污染全局作用域
    'use strict'; // 启用严格模式，有助于捕获常见错误

    // 用于存储自动提取设置的键名，确保版本更新后键名唯一性以避免冲突
    const AUTO_EXTRACT_KEY = 'chaoxingUniversalQuizAutoExtractEnabled_v3.0';

    // --- 辅助函数 (Combined and refined) ---

    /**
     * 规范化文本：移除多余空格，并将所有空白符（包括换行、制表符等）替换为单个空格，最后去除首尾空格。
     * @param {string} text - 待处理的原始文本。
     * @returns {string} 规范化后的文本。如果输入不是字符串，则返回空字符串。
     */
    function normalizeText(text) {
        if (typeof text !== 'string') return "";
        return text.replace(/\s+/g, ' ').trim();
    }

    /**
     * 规范化题目文本：
     * 1. 移除题目前缀，如 "【单选题】"。
     * 2. 移除题目末尾的分数提示，如 "（2.0 分）" 或 "(2 分)"。
     * 3. 标准化空括号，如将 "( )" 或 "（ ）" 统一为 "( )" 或 "（ ）"。
     * 4. 进行基础的 normalizeText 处理。
     * @param {string} rawText - 原始的题目文本。
     * @returns {string} 规范化后的题目文本。
     */
    function normalizeQuestionText(rawText) {
        if (!rawText) return "";
        // 移除题型前缀，例如 "【单选题】 "
        let text = rawText.replace(/^【.*?题】\s*/, '').trim();
        // 移除题干末尾的分数部分，例如 "（ 2.0 分 ）" 或 "( 2 分 )"
        text = text.replace(/\s*（\s*\d+(\.\d+)?\s*分\s*）\s*$/, '').trim();
        text = text.replace(/\s*\(\s*\d+(\.\d+)?\s*分\s*\)\s*$/, '').trim();
        // 将内容为空或只有空格/ 的括号标准化
        text = text.replace(/\(\s*( |\s)*\)/g, '( )'); // 半角括号
        text = text.replace(/（\s*( |\s)*）/g, '（ ）'); // 全角括号
        // 再次确保完全空的括号被标准化
        text = text.replace(/\(\s*\)/g, '( )').replace(/（\s*）/g, '（ ）');
        return normalizeText(text); // 最后进行通用文本规范化
    }

    /**
     * 从 DOM 元素中提取纯文本内容。
     * 该函数会克隆元素，移除其中的 <script> 和 <style> 标签，
     * 将 <p> 和 <br> 标签转换为空格（后续由 normalizeText 处理）或换行，
     * 然后获取其 textContent 或 innerText，并进行规范化处理。
     * @param {HTMLElement} element - 需要提取文本的 DOM 元素。
     * @returns {string} 清理和规范化后的纯文本内容。
     */
    function getCleanTextFromElement(element) {
        if (!element) return "";
        const clone = element.cloneNode(true); // 克隆节点以避免修改原始DOM

        // 移除脚本和样式标签，它们不应出现在题目内容中
        const scriptsAndStyles = clone.querySelectorAll('script, style');
        scriptsAndStyles.forEach(el => el.remove());

        // 将 <p> 和 <br> 标签转换成换行符，以保留段落结构和换行
        // 注意：innerHTML 操作可能引入XSS风险，但这里是处理已知页面，且是克隆节点
        let html = clone.innerHTML;
        html = html.replace(/<p[^>]*>/gi, '\n').replace(/<\/p>/gi, '\n').replace(/<br[^>]*>/gi, '\n');

        // 使用临时div来解析HTML并获取文本内容
        const tempDiv = document.createElement('div');
        tempDiv.innerHTML = html;

        // 获取文本，优先使用 textContent
        let text = normalizeText(tempDiv.textContent || tempDiv.innerText || "");
        // 移除连续的换行符，只保留一个
        return text.replace(/\n\s*\n/g, '\n').trim();
    }

    // --- 自定义悬浮通知 (from Homework Script) ---
    let notificationElement = null; // 存储通知DOM元素的引用，避免重复创建
    /**
     * 显示一个自定义的悬浮通知。
     * @param {string} message - 要显示的消息内容。
     * @param {boolean} [isError=false] - 是否为错误消息（影响背景颜色）。
     */
    function showCustomNotification(message, isError = false) {
        // 如果通知元素尚未创建，则创建并添加到body
        if (!notificationElement) {
            notificationElement = document.createElement('div');
            notificationElement.id = 'customNotificationGM'; // 用于CSS选择器
            document.body.appendChild(notificationElement);
        }
        notificationElement.textContent = message;
        notificationElement.style.backgroundColor = isError ? '#dc3545' : '#28a745'; // 红色表示错误，绿色表示成功

        // 实现简单的淡入淡出效果
        notificationElement.style.display = 'block';
        notificationElement.style.opacity = '0';
        let opacity = 0;
        const fadeInInterval = setInterval(function() {
            if (opacity < 0.95) {
                opacity += 0.1;
                notificationElement.style.opacity = opacity;
            } else {
                clearInterval(fadeInInterval);
                // 2.5秒后自动开始淡出
                setTimeout(() => {
                    let opacityOut = 0.95;
                    const fadeOutInterval = setInterval(function() {
                        if (opacityOut > 0) {
                            opacityOut -= 0.1;
                            notificationElement.style.opacity = opacityOut;
                        } else {
                            clearInterval(fadeOutInterval);
                            notificationElement.style.display = 'none';
                        }
                    }, 50); // 淡出动画的间隔
                }, 2500); // 通知显示持续时间
            }
        }, 50); // 淡入动画的间隔
    }

    // --- 主要提取逻辑 (Combined and generalized) ---
    /**
     * 提取并格式化页面上的所有题目。
     * @param {boolean} [isManualTrigger=false] - 是否为手动触发（影响通知内容）。
     * @returns {string|null} 提取并格式化后的题目字符串，如果未找到容器或题目则返回null。
     */
    function extractAndFormatQuestions(isManualTrigger = false) {
        let output = ""; // 用于累积提取结果的字符串
        // #ZyBottom 是超星题目区域的主要容器ID
        const mainQuizContainer = document.querySelector('#ZyBottom');

        if (!mainQuizContainer) {
            const msg = '错误：未能找到主要的题目容器 (ID: ZyBottom)。脚本可能无法在此页面工作。';
            if (isManualTrigger) showCustomNotification(msg, true);
            else console.warn(`油猴脚本：${msg}`);
            return null;
        }

        let currentQuestionTypeName = "未知题型"; // 默认题型名称
        let questionTypeHeaderFoundOverall = false; // 标记是否已找到并处理过题型标题
        const topLevelChildren = Array.from(mainQuizContainer.children); // 获取主容器下的所有直接子元素

        // 遍历主容器的直接子元素以识别题型标题和题目块
        for (const element of topLevelChildren) {
            // 1. 处理题型标题 (例如："一、单选题")
            if (element.classList.contains('Cy_TItle1')) { // 题型标题通常使用此class
                questionTypeHeaderFoundOverall = true;
                const headerH2 = element.querySelector('h2');
                if (headerH2) {
                    let rawHeaderText = "";
                    // 提取h2中所有文本节点，直到遇到<em>标签（通常包含分数信息）
                    for (const node of headerH2.childNodes) {
                        if (node.nodeName.toUpperCase() === "EM") break;
                        rawHeaderText += node.textContent;
                    }
                    // 清理标题文本，移除序号和多余空格，例如 "一、 单选题" -> "单选题"
                    rawHeaderText = normalizeText(rawHeaderText).replace(/^一?[、.]\s*/, '').trim();

                    // 根据关键词判断题型
                    if (rawHeaderText.includes("单选题")) currentQuestionTypeName = "单选题";
                    else if (rawHeaderText.includes("多选题")) currentQuestionTypeName = "多选题";
                    else if (rawHeaderText.includes("判断题")) currentQuestionTypeName = "判断题";
                    else if (rawHeaderText.includes("填空题")) currentQuestionTypeName = "填空题";
                    else if (rawHeaderText.includes("简答题")) currentQuestionTypeName = "简答题";
                    else if (rawHeaderText.includes("资料题") || rawHeaderText.includes("材料题")) currentQuestionTypeName = "资料题";
                    else currentQuestionTypeName = rawHeaderText || "未知题型"; // 若无匹配，则使用原始文本

                    // 添加题型标题到输出，确保格式正确且不重复添加
                    if (output === "" || (output.length > 0 && !output.endsWith("\n\n") && output.lastIndexOf("## ") !== (output.length - `## ${currentQuestionTypeName}\n`.length))) {
                         if(output !== "" && !output.endsWith("\n")) output += "\n"; // 确保在新题型前有空行
                    }
                    if (!output.endsWith(`## ${currentQuestionTypeName}\n`)) { // 避免连续相同的题型标题
                        output += `## ${currentQuestionTypeName}\n`;
                    }
                }
            }
            // 2. 处理包含多个题目的区块 (常见于考试回顾页面)
            else if (element.classList.contains('CyBottom') && element.classList.contains('ans-cc')) {
                const questionsInBlock = element.querySelectorAll('.TiMu'); // .TiMu 是单个题目的通用class
                questionsInBlock.forEach(questionElementNode => {
                    let questionOutput = processSingleQuestion(questionElementNode, currentQuestionTypeName);
                    if (questionOutput) output += questionOutput;
                });
            }
            // 3. 处理直接作为子元素的单个题目
            else if (element.classList.contains('TiMu')) {
                // 如果到目前为止还没有输出过题型标题，并且输出为空或未包含 "## "
                if (!questionTypeHeaderFoundOverall && output.indexOf("## ") === -1) {
                    output += `## ${currentQuestionTypeName}\n`; // 使用当前（或默认）的题型标题
                    questionTypeHeaderFoundOverall = true; // 标记已处理过题型标题
                }
                let questionOutput = processSingleQuestion(element, currentQuestionTypeName);
                if (questionOutput) output += questionOutput;
            }
            // 4. 兼容处理：某些页面题目可能嵌套在其他类型的子元素中 (作业回顾页面常见)
            else {
                const nestedQuestions = element.querySelectorAll('.TiMu');
                 if (nestedQuestions.length > 0) {
                    if (!questionTypeHeaderFoundOverall && output.indexOf("## ") === -1) {
                         output += `## ${currentQuestionTypeName}\n`;
                         questionTypeHeaderFoundOverall = true;
                    }
                    nestedQuestions.forEach(qEl => {
                        let questionOutput = processSingleQuestion(qEl, currentQuestionTypeName);
                        if (questionOutput) output += questionOutput;
                    });
                }
            }
        }
         // 最终检查：如果整个过程中没有找到显式的题型标题，但提取到了题目，
         // 且输出中尚未包含任何 "## " 格式的题型标题，则尝试从第一个题目推断并添加。
        if (!questionTypeHeaderFoundOverall && mainQuizContainer.querySelector('.TiMu') && output.indexOf("## ") === -1) {
            // 尝试从第一个题目的题干中推断题型
            const firstQuestionTextDiv = mainQuizContainer.querySelector('.TiMu .Cy_TItle div.clearfix, .TiMu .Zy_TItle div.clearfix');
            if (firstQuestionTextDiv) {
                const firstQuestionRawText = getCleanTextFromElement(firstQuestionTextDiv);
                if (firstQuestionRawText.startsWith("【单选题】")) currentQuestionTypeName = "单选题";
                // 可在此处添加更多题型推断逻辑
            }
            output = `## ${currentQuestionTypeName}\n` + output; // 将推断的题型标题加在最前面
        }


        // 处理最终输出
        if (output) {
            GM_setClipboard(output); // 复制到剪贴板
            showCustomNotification(`题目已${isManualTrigger ? '手动' : '自动'}提取并成功复制到剪贴板！`);
            displayOutput(output); // 在页面上显示提取的内容
        } else {
            const msg = '未能找到或处理任何题目。请检查页面结构或在浏览器控制台查看错误信息。';
            if (isManualTrigger) showCustomNotification(msg, true);
            else console.warn(`油猴脚本：${msg}`);
        }
        return output;
    }

    /**
     * 处理单个题目元素，提取题号、题干、选项、答案和解析。
     * @param {HTMLElement} questionElement - 代表单个题目的 DOM 元素 (通常是 .TiMu)。
     * @param {string} questionTypeName - 当前题目的类型名称 (例如 "单选题")。
     * @returns {string} 格式化后的单个题目字符串，如果处理出错则返回错误提示。
     */
    function processSingleQuestion(questionElement, questionTypeName) {
        let qOutput = ""; // 用于累积单个题目的输出
        try {
            // --- 提取题号和题干 ---
            // 题目标题容器，可能是 .Cy_TItle (考试) 或 .Zy_TItle (作业)
            const questionTitleDiv = questionElement.querySelector('.Cy_TItle, .Zy_TItle');
            let questionNumberElement = null; // 题号元素
            let questionTextElement = null;   // 题干元素
            let questionNumber = "?.";        // 默认题号格式，统一使用 "." 结尾

            if (questionTitleDiv) { // 优先处理带有明确标题容器的结构
                questionNumberElement = questionTitleDiv.querySelector('i.fl'); // 题号通常在 i.fl 标签内
                if (questionNumberElement) {
                    questionNumber = normalizeText(questionNumberElement.textContent) + ".";
                    // 题干通常是题号元素的下一个兄弟元素，且class为clearfix
                    if (questionNumberElement.nextElementSibling && questionNumberElement.nextElementSibling.classList.contains('clearfix')) {
                        questionTextElement = questionNumberElement.nextElementSibling;
                    }
                }
                // 如果未能通过nextElementSibling找到题干，则尝试更复杂的查找逻辑（来自考试脚本）
                if (!questionTextElement) {
                    const potentialStems = questionTitleDiv.querySelectorAll('div.clearfix'); // 查找所有clearfix的div
                    if (potentialStems.length > 0) {
                        // 从后向前遍历，找到第一个不包含题号的clearfix div作为题干
                        for(let i = potentialStems.length - 1; i >= 0; i--) {
                            if(!potentialStems[i].querySelector('i.fl')) { // 确保不是另一个题号元素
                                questionTextElement = potentialStems[i];
                                break;
                            }
                        }
                        // 如果上述逻辑未找到，则默认使用第一个clearfix div
                        if(!questionTextElement && potentialStems.length > 0) questionTextElement = potentialStems[0];
                    }
                }
            } else { // 备用逻辑：如果题目元素下没有 .Cy_TItle 或 .Zy_TItle 容器
                //直接在 questionElement 下查找题号
                questionNumberElement = questionElement.querySelector(':scope > i.fl'); // :scope确保是直接子元素
                if (questionNumberElement) {
                    questionNumber = normalizeText(questionNumberElement.textContent) + ".";
                    if (questionNumberElement.nextElementSibling && questionNumberElement.nextElementSibling.classList.contains('clearfix')) {
                        questionTextElement = questionNumberElement.nextElementSibling;
                    }
                }
                // 如果题干仍未找到，则在 questionElement 的直接子元素中查找合适的 div.clearfix
                if (!questionTextElement) {
                     const potentialStems = questionElement.querySelectorAll(':scope > div.clearfix');
                     for (let div of potentialStems) {
                         // 确保这个div不是选项列表、答案区域，并且有足够的文本内容
                         if (!div.querySelector('.Cy_ulTop, .Zy_ulTop') && !div.querySelector('.Py_answer') && (div.textContent || "").trim().length > 5) {
                             questionTextElement = div;
                             break;
                         }
                     }
                }
            }

            let questionText = "题干未能提取"; // 默认题干文本
            if (questionTextElement) {
                let rawText = getCleanTextFromElement(questionTextElement);
                questionText = normalizeQuestionText(rawText); // 使用增强的题干清理函数
            }
            qOutput += questionNumber + " " + questionText + "\n"; // 输出: 题号. 题干

            // --- 提取选项 (选择题) ---
            // 选项列表容器，可能是 .Cy_ulTop li (考试) 或 .Zy_ulTop li (作业)
            let options = questionElement.querySelectorAll('.Cy_ulTop li');
            if (options.length === 0) { // 如果未找到 .Cy_ulTop li，则尝试 .Zy_ulTop li
                options = questionElement.querySelectorAll('.Zy_ulTop li');
            }

            let optionDetails = []; // 存储选项标签和文本，用于后续答案匹配
            if (options.length > 0) {
                options.forEach(optionLi => {
                    const optionLabelElement = optionLi.querySelector('i.fl'); // 例如: A, B, C
                    const rawOptionLabel = optionLabelElement ? normalizeText(optionLabelElement.textContent) : ""; // 获取原始标签文本

                    // 选项文本通常在 <a> 标签内，有时嵌套在 <p> 标签中
                    const optionTextAnchor = optionLi.querySelector('a'); // 优先查找a标签
                    let optText = "";
                    if (optionTextAnchor) {
                        const pInA = optionTextAnchor.querySelector('p');
                        optText = pInA ? normalizeText(pInA.textContent) : normalizeText(optionTextAnchor.textContent);
                    } else { // 如果没有a标签，尝试直接从li中获取文本 (排除标签部分)
                        let tempOptClone = optionLi.cloneNode(true);
                        if(tempOptClone.querySelector('i.fl')) tempOptClone.querySelector('i.fl').remove(); // 移除标签部分
                        optText = normalizeText(tempOptClone.textContent);
                    }
                    // 存储清理后的选项标签和文本
                    optionDetails.push({ label: rawOptionLabel.replace(/[:、.]\s*$/, ''), text: optText });
                    qOutput += rawOptionLabel + " " + optText + "\n"; // 输出: A. 选项内容
                });
            }

            // --- 提取正确答案 (根据题型进行不同处理) ---
            let finalCorrectAnswer = "未能提取"; // 默认答案
            // 尝试获取隐藏的答案元素（通常包含更准确的答案信息）
            const correctAnswerPElement = questionElement.querySelector('.Py_answer span.element-invisible-hidden p'); // 隐藏的答案文本
            const correctAnswerIconElement = questionElement.querySelector('.Py_answer span.element-invisible-hidden i.font20'); // 隐藏的答案图标 (判断题√×)
            // 填空题、简答题的答案通常在特定div中显示
            const revealedAnswerDiv = questionElement.querySelector(".Py_tk div[id^='div']"); // id以div开头的答案显示区

            if (questionTypeName === "单选题" || questionTypeName === "多选题") {
                if (correctAnswerPElement) { // 优先使用隐藏的答案文本
                    let correctAnswerTextFromHidden = normalizeText(correctAnswerPElement.textContent);
                    let foundMatch = false;
                    // 尝试将隐藏的答案文本与选项文本匹配，以获取选项标签 (A, B)
                    for (const opt of optionDetails) {
                        if (typeof opt.text === 'string' && typeof correctAnswerTextFromHidden === 'string' && opt.text === correctAnswerTextFromHidden) {
                            finalCorrectAnswer = opt.label;
                            foundMatch = true;
                            break;
                        }
                    }
                    // 如果文本不匹配，但隐藏文本本身是合法的选项标签 (如 "A", "ABC")
                    if (!foundMatch && /^[A-Z]+$/.test(correctAnswerTextFromHidden) && optionDetails.some(opt => opt.label === correctAnswerTextFromHidden)) {
                        finalCorrectAnswer = correctAnswerTextFromHidden;
                    } else if (!foundMatch) { // 如果都未匹配，直接使用隐藏的文本内容
                        finalCorrectAnswer = correctAnswerTextFromHidden;
                    }
                } else { // 如果没有隐藏的答案文本，尝试从可见的 "正确答案：" 提示中提取
                    const answerSpans = questionElement.querySelectorAll('.Py_answer span');
                    for (const span of answerSpans) {
                        const spanText = normalizeText(span.textContent);
                        if (spanText.startsWith('正确答案：')) {
                            let visibleAnswerText = spanText.replace('正确答案：', '').trim();
                            let foundVisibleMatch = false;
                            // 尝试将可见答案文本与选项标签或选项文本匹配
                            for (const opt of optionDetails) {
                                if (opt.label === visibleAnswerText) { finalCorrectAnswer = opt.label; foundVisibleMatch = true; break; }
                                else if (opt.text === visibleAnswerText) { finalCorrectAnswer = opt.label; foundVisibleMatch = true; break; }
                            }
                            if (!foundVisibleMatch) finalCorrectAnswer = visibleAnswerText; // 若无匹配，使用原始可见文本
                            break;
                        }
                    }
                }
            } else if (questionTypeName === "判断题") {
                if (correctAnswerIconElement) { // 优先使用隐藏的图标 (√, ×)
                    let symbol = correctAnswerIconElement.textContent.trim();
                    if (symbol === "√") finalCorrectAnswer = "对";
                    else if (symbol === "×") finalCorrectAnswer = "错";
                    else finalCorrectAnswer = symbol; // 如果不是标准符号，直接使用
                } else if (correctAnswerPElement) { // 备用：使用隐藏的文本 ("对", "错")
                    let textAns = normalizeText(correctAnswerPElement.textContent);
                     if (textAns === "对" || textAns.toLowerCase() === "true") finalCorrectAnswer = "对";
                     else if (textAns === "错" || textAns.toLowerCase() === "false") finalCorrectAnswer = "错";
                     else finalCorrectAnswer = textAns;
                } else { // 最后尝试可见的 "正确答案：" 提示
                    const answerSpans = questionElement.querySelectorAll('.Py_answer span');
                    for (const span of answerSpans) {
                        const spanText = normalizeText(span.textContent);
                        if (spanText.startsWith('正确答案：')) {
                            let textAnswer = spanText.replace('正确答案：', '').trim();
                            // 检查可见提示中是否直接包含图标
                            const iconInSpan = span.querySelector('i.font20');
                            if (iconInSpan) textAnswer = iconInSpan.textContent.trim();

                            if (textAnswer === "√" || textAnswer.toLowerCase() === "true" || textAnswer === "对") finalCorrectAnswer = "对";
                            else if (textAnswer === "×" || textAnswer.toLowerCase() === "false" || textAnswer === "错") finalCorrectAnswer = "错";
                            else finalCorrectAnswer = textAnswer;
                            break;
                        }
                    }
                }
            } else if (revealedAnswerDiv && (questionTypeName === "填空题" || questionTypeName === "简答题" || questionTypeName === "资料题")) {
                // 处理填空题、简答题、资料题的答案
                if (questionTypeName === "填空题") {
                    const parts = []; // 存储填空的各个部分
                    // 填空答案通常在 .font14 或直接子span中
                    revealedAnswerDiv.querySelectorAll("span.font14, div > span").forEach(span => {
                        const labelElement = span.querySelector('i.fb.red'); // 例如 "空1："
                        if (labelElement && labelElement.textContent.includes("空：")) { // 带标签的填空
                            let clone = span.cloneNode(true);
                            clone.querySelector('i.fb.red').remove(); // 移除标签本身，只留答案
                            parts.push(normalizeText(clone.textContent));
                        }
                        // 不带标签，但也不是“查看答案”之类的链接
                        else if (!labelElement && span.textContent.trim() !== "" && !span.querySelector('a[onclick*="hideAndShow"]')) {
                             parts.push(normalizeText(span.textContent));
                        }
                    });
                    finalCorrectAnswer = parts.join('; '); // 用分号连接多个填空答案
                } else if (questionTypeName === "资料题") { // 资料题的答案可能包含多个子部分
                    const subAnswers = [];
                    // 资料题的答案结构可能更复杂
                    revealedAnswerDiv.querySelectorAll("span.font14, div.clearfix > span, div > span").forEach(span => {
                        const labelElement = span.querySelector('i.fb.red'); // 子题目的标签，如 "空1：" 或 "1:"
                        let partText = "";
                        if (labelElement && (labelElement.textContent.includes("空：") || labelElement.textContent.match(/\d+[:：]/))) {
                            let label = normalizeText(labelElement.textContent).replace(/[:：]\s*(&nbsp;)?/, ''); // 清理标签文本
                            let clone = span.cloneNode(true);
                            labelElement.remove(); // 移除标签
                            partText = `${label}: ${getCleanTextFromElement(clone)}`; // 输出 "标签: 答案"
                        } else {
                             if (!span.querySelector('a[onclick*="hideAndShow"]')) { // 避免“查看答案”链接
                                partText = getCleanTextFromElement(span);
                             }
                        }
                        if(partText && partText.trim()) subAnswers.push(partText.trim());
                    });
                    // 如果有子答案，则换行连接；否则使用整个div的文本
                    finalCorrectAnswer = subAnswers.length > 0 ? "\n" + subAnswers.join("\n\n") : getCleanTextFromElement(revealedAnswerDiv);
                } else { // 简答题
                    // 简答题答案通常在 revealedAnswerDiv 的 .clearfix 子div 或其本身
                    const ansContentDiv = revealedAnswerDiv.querySelector("div.clearfix") || revealedAnswerDiv;
                    finalCorrectAnswer = getCleanTextFromElement(ansContentDiv);
                }
            }

            // 针对选择题和判断题的最后一道防线：如果以上所有方法都未能提取到答案，
            // 再次检查 .Py_answer span 中是否有 "正确答案："
            if (finalCorrectAnswer === "未能提取" && (questionTypeName === "单选题" || questionTypeName === "多选题" || questionTypeName === "判断题")) {
                 const answerSpans = questionElement.querySelectorAll('.Py_answer span');
                 for(let span of answerSpans){
                     const textContent = normalizeText(span.textContent);
                     if(textContent.startsWith('正确答案：')){
                         let visibleAnswerText = textContent.replace('正确答案：', '').trim();
                         // 针对选择题，如果答案是字母且选项中有此字母
                         if ((questionTypeName === "单选题" || questionTypeName === "多选题") && /^[A-Z]+$/.test(visibleAnswerText) && optionDetails.some(opt => opt.label === visibleAnswerText)) {
                             finalCorrectAnswer = visibleAnswerText;
                         // 针对判断题
                         } else if (questionTypeName === "判断题") {
                             if (visibleAnswerText === "√" || visibleAnswerText.toLowerCase() === "true" || visibleAnswerText === "对") finalCorrectAnswer = "对";
                             else if (visibleAnswerText === "×" || visibleAnswerText.toLowerCase() === "false" || visibleAnswerText === "错") finalCorrectAnswer = "错";
                             else finalCorrectAnswer = visibleAnswerText;
                         // 针对选择题，如果答案不是字母，尝试匹配选项文本
                         } else if (questionTypeName === "单选题" || questionTypeName === "多选题") {
                             let matched = false;
                             for (const opt of optionDetails) { if (opt.text === visibleAnswerText) { finalCorrectAnswer = opt.label; matched = true; break; } }
                             if (!matched) finalCorrectAnswer = visibleAnswerText; // 若无匹配，使用原始文本
                         } else {
                             finalCorrectAnswer = visibleAnswerText;
                         }
                         break; // 找到后即跳出循环
                     }
                 }
            }

            qOutput += "答案：" + finalCorrectAnswer + "\n"; // 输出: 答案：xxx

            // --- 提取题目解析 ---
            const explanationParent = questionElement.querySelector('.Py_addpy'); // 解析区域的父容器
            if (explanationParent) {
                const explanationElement = explanationParent.querySelector('.pingyu'); // 实际的解析文本容器
                 if (explanationElement) {
                    const explanationText = getCleanTextFromElement(explanationElement);
                    if (explanationText) { // 只有当解析文本非空时才输出
                        qOutput += "解析：" + explanationText + "\n"; // 输出: 解析：xxx
                    }
                }
            }
            qOutput += "\n"; // 每个题目结束后加一个空行，用于分隔
            return qOutput;

        } catch (e) { // 异常处理
            console.error("处理题目时出错:", e, questionElement);
            // 尝试获取出错题目的题号用于提示
            const qNumEl = questionElement.querySelector('.Cy_TItle i.fl, .Zy_TItle i.fl, :scope > i.fl');
            return `处理题目 ${qNumEl ? qNumEl.textContent.trim() : '未知'} 时出错。详情请查看控制台。\n\n`;
        }
    }

    // --- UI: 输出区域和复制按钮 ---
    let outputAreaElement = null; // 存储输出文本框的DOM引用
    let scriptContainerElement = null; // 存储脚本添加的整个UI容器的引用

    /**
     * 在页面上显示提取的题目内容。
     * @param {string} output - 要显示的格式化后的题目字符串。
     */
    function displayOutput(output) {
        // 如果UI元素尚未创建，则进行初始化
        if (!scriptContainerElement) {
            scriptContainerElement = document.createElement('div');
            scriptContainerElement.id = "universalExtractorContainerGM"; // 为整个UI容器设置ID

            outputAreaElement = document.createElement('textarea');
            outputAreaElement.id = 'extractionOutputAreaGM'; // 文本框ID
            outputAreaElement.readOnly = true; // 设置为只读
            scriptContainerElement.appendChild(outputAreaElement);

            const copyButtonElement = document.createElement('button');
            copyButtonElement.id = 'copyExtractionButtonGM'; // 复制按钮ID
            copyButtonElement.textContent = '复制内容到剪贴板';
            copyButtonElement.addEventListener('click', function() {
                GM_setClipboard(outputAreaElement.value); // 点击时复制文本框内容
                showCustomNotification('内容已再次复制到剪贴板!'); // 使用自定义通知提示
            });
            scriptContainerElement.appendChild(copyButtonElement);

            // 决定将UI容器插入到页面的哪个位置
            const targetContainer = document.querySelector('#ZyBottom'); // 尝试插入到主内容区之后
            const commonWrapper = document.querySelector('.wrap1000.clearfix.con'); // 备用插入点

            if (targetContainer && targetContainer.parentNode) {
                // 插入到 #ZyBottom 元素的后面
                targetContainer.parentNode.insertBefore(scriptContainerElement, targetContainer.nextSibling);
            } else if (commonWrapper) {
                 commonWrapper.appendChild(scriptContainerElement); // 作为 .wrap1000 的子元素
            } else {
                document.body.appendChild(scriptContainerElement); // 最后手段：添加到 body 的末尾
            }
        }
        outputAreaElement.value = output; // 设置文本框内容
        outputAreaElement.scrollTop = 0; // 滚动到文本框顶部，方便查看开头
    }

    // --- UI: 手动提取按钮 ---
    /**
     * 在页面上创建一个手动提取题目的按钮。
     */
    function createManualButton() {
        // 如果按钮已存在，则不重复创建
        if (document.getElementById('extractQuizButtonGM_merged')) return;

        const manualExtractButton = document.createElement('button');
        manualExtractButton.id = 'extractQuizButtonGM_merged'; // 按钮ID，确保唯一性
        manualExtractButton.textContent = '提取题目';
        // 按钮样式由 GM_addStyle 定义

        manualExtractButton.addEventListener('click', function() {
            const btn = this;
            const originalText = btn.textContent;
            const originalBg = btn.style.backgroundColor; // 保存原始背景色

            // 更新按钮状态为“正在提取”
            btn.textContent = '正在提取...';
            btn.disabled = true;
            btn.style.backgroundColor = '#5a6268'; // 设置为“忙碌”状态的颜色

            // 使用 setTimeout 允许浏览器UI更新按钮状态，然后再执行耗时操作
            setTimeout(() => {
                const outputGenerated = extractAndFormatQuestions(true); // 调用主提取函数，标记为手动触发
                if (outputGenerated) {
                    btn.textContent = '提取完成!';
                    btn.style.backgroundColor = '#218838'; // 成功颜色
                } else {
                    btn.textContent = '提取失败!';
                    btn.style.backgroundColor = '#c82333'; // 失败颜色
                }
                // 2.5秒后恢复按钮原始状态
                setTimeout(() => {
                    btn.textContent = originalText;
                    btn.style.backgroundColor = originalBg; // 恢复原始背景或默认样式定义的颜色
                    btn.disabled = false;
                }, 2500);
            }, 50); // 短暂延迟
        });
        document.body.appendChild(manualExtractButton); // 将按钮添加到body
    }

    // --- 油猴菜单设置项 & 自动提取逻辑 ---
    /**
     * 切换自动提取功能的开启/关闭状态。
     * 状态通过 GM_setValue/GM_getValue 持久化存储。
     */
    function toggleAutoExtract() {
        let isEnabled = GM_getValue(AUTO_EXTRACT_KEY, false); // 读取当前状态，默认为false
        GM_setValue(AUTO_EXTRACT_KEY, !isEnabled); // 切换状态并保存
        alert(`自动提取并复制功能已 ${!isEnabled ? '开启' : '关闭'}。\n请刷新页面以使设置生效。`);
        registerMenuCommands(); // 重新注册菜单命令以更新标签文本（例如 ✅/❌）
    }

    /**
     * 注册油猴脚本菜单命令，用于控制自动提取功能。
     * 菜单项的标签会根据当前自动提取状态动态显示。
     */
    function registerMenuCommands() {
        let isEnabled = GM_getValue(AUTO_EXTRACT_KEY, false);
        // 根据状态显示不同的前缀图标和文本
        GM_registerMenuCommand(`${isEnabled ? '✅' : '❌'} 自动提取题目 (当前: ${isEnabled ? '开启' : '关闭'}) - 点击切换`, toggleAutoExtract, 'a');
    }

    // --- 脚本初始化 ---
    registerMenuCommands(); // 页面加载时即注册菜单命令
    createManualButton();   // 创建手动提取按钮

    // 页面加载完成后执行自动提取（如果已启用）
    window.addEventListener('load', function() {
        if (GM_getValue(AUTO_EXTRACT_KEY, false)) { // 检查自动提取是否已开启
            // 使用 setTimeout 延迟执行，给页面动态内容更多加载时间
            setTimeout(function() {
                console.log("油猴脚本：自动提取功能已开启，正在尝试提取...");
                extractAndFormatQuestions(false); // 调用主提取函数，标记为自动触发
            }, 1200); // 延迟1.2秒
        }
    });

    // --- 注入CSS样式 (用于脚本添加的UI元素) ---
    GM_addStyle(`
        #extractQuizButtonGM_merged { /* 手动提取按钮样式 (ID已更新) */
            position: fixed; top: 70px; right: 20px; z-index: 10001; /* 固定在右上角，高层级 */
            padding: 10px 15px; background-color: #007bff; color: white;
            border: none; border-radius: 5px; cursor: pointer;
            box-shadow: 0 2px 5px rgba(0,0,0,0.2); /* 阴影效果 */
            transition: background-color 0.3s ease, transform 0.1s ease, opacity 0.3s ease; /* 过渡动画 */
        }
        #extractQuizButtonGM_merged:hover { background-color: #0056b3; opacity: 0.9; } /* 悬停效果 */
        #extractQuizButtonGM_merged:active { transform: scale(0.98); } /* 点击效果 */
        #extractQuizButtonGM_merged:disabled { background-color: #5a6268; cursor: not-allowed; } /* 禁用状态 */

        #universalExtractorContainerGM { /* 脚本UI总容器样式 (ID已更新) */
            margin-top: 25px; padding: 15px; background-color: #f0f0f0; /* 背景与内边距 */
            border-top: 1px solid #dee2e6; border-radius: 0 0 8px 8px; /* 边框与圆角 */
            clear: both; /* 清除浮动，避免影响页面原有布局 */
        }
        #extractionOutputAreaGM { /* 提取结果文本框样式 */
            width: 95%; min-height: 300px; max-height: 70vh; /* 宽高与最大高度限制 */
            margin: 20px auto; padding: 15px; border: 1px solid #ccc;
            border-radius: 4px; font-family: 'Courier New', Courier, monospace; /* 等宽字体 */
            font-size: 13px; line-height: 1.6; box-shadow: inset 0 1px 3px rgba(0,0,0,0.1);
            resize: vertical; background-color: #fdfdfd; white-space: pre-wrap; /* 允许垂直调整大小，保留换行和空格 */
        }
        #copyExtractionButtonGM { /* 文本框下方的复制按钮样式 */
            display: block; margin: 10px auto 20px auto; padding: 12px 20px;
            background-color: #6c757d; color: white; border: none;
            border-radius: 4px; cursor: pointer; font-size: 15px;
            transition: background-color 0.2s ease-in-out;
        }
        #copyExtractionButtonGM:hover { background-color: #545b62; }

        #customNotificationGM { /* 自定义悬浮通知样式 */
            position: fixed; /* 固定定位 */
            top: 20px; /* 距顶部20px */
            left: 50%; /* 水平居中 */
            transform: translateX(-50%); /* 精确水平居中 */
            color: white;
            padding: 12px 25px;
            border-radius: 6px;
            box-shadow: 0 4px 10px rgba(0,0,0,0.15);
            z-index: 10002; /* 比提取按钮更高的层级 */
            font-size: 15px;
            display: none; /* 初始隐藏 */
            text-align: center;
            opacity: 0; /* 初始透明，配合JS实现淡入 */
        }
    `);

})(); // IIFE结束