// ==UserScript==
// @name         超星学习通作业题目提取工具（支持图片）
// @namespace    http://tampermonkey.net/
// @version      1.3
// @description  提取超星学习通作业页面的题目、选项和答案，支持图片提取和Word下载
// @author       Assistant
// @match        *://*.chaoxing.com/mooc-ans/mooc2/work/view*
// @grant        none
// @require      https://unpkg.com/docx@7.8.2/build/index.js
// @require      https://unpkg.com/file-saver@2.0.5/dist/FileSaver.min.js
// ==/UserScript==

(function() {
    'use strict';

    // 等待页面加载完成
    function waitForElement(selector, timeout = 10000) {
        return new Promise((resolve, reject) => {
            const startTime = Date.now();
            
            function check() {
                const element = document.querySelector(selector);
                if (element) {
                    resolve(element);
                } else if (Date.now() - startTime > timeout) {
                    reject(new Error(`元素 ${selector} 未找到`));
                } else {
                    setTimeout(check, 100);
                }
            }
            
            check();
        });
    }

    // 图片信息结构
    class ImageInfo {
        constructor(src, alt = '', width = '', height = '') {
            this.src = src;
            this.alt = alt;
            this.width = width;
            this.height = height;
        }
    }

    // 题目数据结构
    class Question {
        constructor() {
            this.type = '';        // 题目类型
            this.number = '';      // 题目编号  
            this.content = '';     // 题目内容
            this.contentImages = []; // 题目中的图片
            this.options = [];     // 选项列表
            this.optionImages = []; // 选项中的图片 {optionIndex: number, images: ImageInfo[]}
            this.myAnswer = '';    // 我的答案
            this.correctAnswer = ''; // 正确答案
            this.score = '';       // 得分
            this.isCorrect = false; // 是否正确
            this.analysis = '';    // 答案解析
            this.analysisImages = []; // 解析中的图片
        }
    }

    // 题目解析器
    class QuestionParser {
        constructor() {
            this.questions = [];
        }

        // 解析所有题目
        parseAllQuestions() {
            this.questions = [];
            
            // 获取所有题目容器
            const questionContainers = document.querySelectorAll('.questionLi');
            
            questionContainers.forEach((container, index) => {
                try {
                    const question = this.parseQuestion(container, index + 1);
                    if (question) {
                        this.questions.push(question);
                    }
                } catch (error) {
                    console.error(`解析第${index + 1}题时出错:`, error);
                }
            });

            return this.questions;
        }

        // 提取元素中的图片
        extractImages(element) {
            const images = [];
            if (!element) return images;
            
            const imgElements = element.querySelectorAll('img');
            imgElements.forEach(img => {
                const src = img.getAttribute('src') || img.getAttribute('data-original');
                const alt = img.getAttribute('alt') || '';
                const width = img.getAttribute('width') || '';
                const height = img.getAttribute('height') || '';
                
                if (src) {
                    images.push(new ImageInfo(src, alt, width, height));
                }
            });
            
            return images;
        }

        // 获取纯文本内容（去除图片标签）
        getTextContent(element) {
            if (!element) return '';
            
            // 克隆元素以避免修改原DOM
            const cloned = element.cloneNode(true);
            
            // 将图片替换为占位符
            const images = cloned.querySelectorAll('img');
            images.forEach((img, index) => {
                const placeholder = document.createElement('span');
                placeholder.textContent = `[图片${index + 1}]`;
                img.parentNode.replaceChild(placeholder, img);
            });
            
            return this.cleanText(cloned.textContent);
        }

        // 解析单个题目
        parseQuestion(container, index) {
            const question = new Question();
            
            // 解析题目编号和类型
            const titleElement = container.querySelector('.mark_name');
            if (titleElement) {
                const titleText = titleElement.textContent.trim();
                const typeMatch = titleText.match(/\((.*?题)\)/);
                const numberMatch = titleText.match(/^(\d+)\./);
                
                question.type = typeMatch ? typeMatch[1] : '未知题型';
                question.number = numberMatch ? numberMatch[1] : index.toString();
            }

            // 解析题目内容和图片
            const contentElement = container.querySelector('.qtContent');
            if (contentElement) {
                question.content = this.getTextContent(contentElement);
                question.contentImages = this.extractImages(contentElement);
            }

            // 解析选项和选项图片
            const optionElements = container.querySelectorAll('.mark_letter li, .qtDetail li');
            optionElements.forEach((option, optionIndex) => {
                const optionText = this.getTextContent(option);
                if (optionText) {
                    question.options.push(optionText);
                    
                    // 提取选项中的图片
                    const optionImages = this.extractImages(option);
                    if (optionImages.length > 0) {
                        question.optionImages.push({
                            optionIndex: optionIndex,
                            images: optionImages
                        });
                    }
                }
            });

            // 解析我的答案
            const myAnswerElements = container.querySelectorAll('.stuAnswerContent');
            const myAnswers = [];
            myAnswerElements.forEach(elem => {
                const answerText = this.cleanText(elem.textContent);
                if (answerText) {
                    myAnswers.push(answerText);
                }
            });
            question.myAnswer = myAnswers.join('; ');

            // 解析正确答案
            const correctAnswerElements = container.querySelectorAll('.rightAnswerContent');
            const correctAnswers = [];
            correctAnswerElements.forEach(elem => {
                const answerText = this.cleanText(elem.textContent);
                if (answerText) {
                    correctAnswers.push(answerText);
                }
            });
            question.correctAnswer = correctAnswers.join('; ');

            // 解析答案解析
            const analysisElement = container.querySelector('.qtAnalysis');
            if (analysisElement) {
                question.analysis = this.getTextContent(analysisElement);
                question.analysisImages = this.extractImages(analysisElement);
            }

            // 解析得分
            const scoreElement = container.querySelector('.totalScore i');
            if (scoreElement) {
                question.score = scoreElement.textContent.trim();
            }

            // 判断是否正确
            const correctIcon = container.querySelector('.marking_dui');
            question.isCorrect = !!correctIcon;

            return question;
        }

        // 清理文本内容
        cleanText(text) {
            if (!text) return '';
            return text.replace(/\s+/g, ' ').trim();
        }

        // 获取作业标题
        getWorkTitle() {
            const titleElement = document.querySelector('.mark_title');
            return titleElement ? this.cleanText(titleElement.textContent) : '作业题目';
        }

        // 获取统计信息
        getStatistics() {
            const stats = {
                totalQuestions: this.questions.length,
                correctCount: this.questions.filter(q => q.isCorrect).length,
                totalScore: '0',
                maxScore: '0',
                totalImages: 0
            };

            // 统计图片数量
            this.questions.forEach(q => {
                stats.totalImages += q.contentImages.length;
                q.optionImages.forEach(optImg => {
                    stats.totalImages += optImg.images.length;
                });
                stats.totalImages += q.analysisImages.length;
            });

            // 获取总分
            const scoreElement = document.querySelector('.resultNum i');
            if (scoreElement) {
                stats.totalScore = scoreElement.textContent.trim();
            }

            // 获取满分
            const maxScoreElement = document.querySelector('.infoHead span:nth-child(2)');
            if (maxScoreElement) {
                const match = maxScoreElement.textContent.match(/满分:\s*(\d+)/);
                if (match) {
                    stats.maxScore = match[1];
                }
            }

            stats.accuracy = stats.totalQuestions > 0 ? 
                ((stats.correctCount / stats.totalQuestions) * 100).toFixed(1) + '%' : '0%';

            return stats;
        }
    }

    // 检查必要的库是否加载
    function checkLibraries() {
        const errors = [];
        
        if (typeof window.docx === 'undefined') {
            errors.push('docx库未加载');
        }
        
        if (typeof window.saveAs === 'undefined' && typeof saveAs === 'undefined') {
            errors.push('FileSaver库未加载');
        }
        
        return errors;
    }

    // Word文档生成器
    class WordGenerator {
        constructor() {
            this.docx = window.docx;
            this.saveAs = window.saveAs || saveAs;
            this.imageCache = new Map(); // 图片缓存
        }

        // 下载图片并转换为blob
        async downloadImage(url) {
            if (this.imageCache.has(url)) {
                return this.imageCache.get(url);
            }

            try {
                const response = await fetch(url);
                if (!response.ok) {
                    throw new Error(`HTTP error! status: ${response.status}`);
                }
                const blob = await response.blob();
                this.imageCache.set(url, blob);
                return blob;
            } catch (error) {
                console.warn(`无法下载图片 ${url}:`, error);
                return null;
            }
        }

        // 获取图片尺寸
        getImageDimensions(originalWidth, originalHeight, maxWidth = 400) {
            let width = parseInt(originalWidth) || 300;
            let height = parseInt(originalHeight) || 200;
            
            // 限制最大宽度
            if (width > maxWidth) {
                height = (height * maxWidth) / width;
                width = maxWidth;
            }
            
            return { width, height };
        }

        // 生成Word文档
        async generateWord(questions, title, stats, options = {}) {
            const { 
                includeMyAnswer = true, 
                includeCorrectAnswer = true,
                includeScore = true,
                includeStatistics = true,
                includeAnalysis = true,
                includeSeparator = true,
                embedImages = false
            } = options;

            const doc = new this.docx.Document({
                sections: [{
                    properties: {},
                    children: [
                        // 标题
                        new this.docx.Paragraph({
                            children: [
                                new this.docx.TextRun({
                                    text: title,
                                    bold: true,
                                    size: 32
                                })
                            ],
                            alignment: this.docx.AlignmentType.CENTER,
                            spacing: { after: 400 }
                        }),

                        // 统计信息
                        ...(includeStatistics ? this.createStatisticsSection(stats) : []),

                        // 题目列表
                        ...await this.createQuestionsSection(questions, includeMyAnswer, includeCorrectAnswer, includeScore, includeAnalysis, includeSeparator, embedImages)
                    ]
                }]
            });

            return doc;
        }

        // 创建统计信息部分
        createStatisticsSection(stats) {
            return [
                new this.docx.Paragraph({
                    children: [
                        new this.docx.TextRun({
                            text: "答题统计",
                            bold: true,
                            size: 24
                        })
                    ],
                    spacing: { before: 200, after: 200 }
                }),
                new this.docx.Paragraph({
                    children: [
                        new this.docx.TextRun({
                            text: `总题数: ${stats.totalQuestions}题 | 正确: ${stats.correctCount}题 | 准确率: ${stats.accuracy} | 得分: ${stats.totalScore}/${stats.maxScore}分 | 图片数: ${stats.totalImages}张`
                        })
                    ],
                    spacing: { after: 400 }
                })
            ];
        }

        // 创建图片信息段落
        async createImagesParagraphs(images, prefix = "图片", embedImages = false) {
            const paragraphs = [];
            
            if (images.length > 0) {
                for (let index = 0; index < images.length; index++) {
                    const img = images[index];
                    
                    if (embedImages) {
                        try {
                            const imageBlob = await this.downloadImage(img.src);
                            if (imageBlob) {
                                const dimensions = this.getImageDimensions(img.width, img.height);
                                
                                paragraphs.push(
                                    new this.docx.Paragraph({
                                        children: [
                                            new this.docx.TextRun({
                                                text: `${prefix}${index + 1}:`,
                                                bold: true,
                                                color: "666666"
                                            })
                                        ],
                                        spacing: { before: 200, after: 100 }
                                    }),
                                    new this.docx.Paragraph({
                                        children: [
                                            new this.docx.ImageRun({
                                                data: imageBlob,
                                                transformation: {
                                                    width: dimensions.width,
                                                    height: dimensions.height,
                                                },
                                            })
                                        ],
                                        alignment: this.docx.AlignmentType.CENTER,
                                        spacing: { after: 200 }
                                    })
                                );
                            } else {
                                // 如果图片下载失败，显示链接
                                paragraphs.push(
                                    new this.docx.Paragraph({
                                        children: [
                                            new this.docx.TextRun({
                                                text: `${prefix}${index + 1}: `,
                                                bold: true,
                                                color: "666666"
                                            }),
                                            new this.docx.TextRun({
                                                text: `${img.src} (下载失败)`,
                                                color: "CC0000"
                                            })
                                        ],
                                        indent: { left: 400 },
                                        spacing: { after: 100 }
                                    })
                                );
                            }
                        } catch (error) {
                            console.error(`处理图片时出错:`, error);
                            // 失败时显示链接
                            paragraphs.push(
                                new this.docx.Paragraph({
                                    children: [
                                        new this.docx.TextRun({
                                            text: `${prefix}${index + 1}: `,
                                            bold: true,
                                            color: "666666"
                                        }),
                                        new this.docx.TextRun({
                                            text: `${img.src} (处理失败)`,
                                            color: "CC0000"
                                        })
                                    ],
                                    indent: { left: 400 },
                                    spacing: { after: 100 }
                                })
                            );
                        }
                    } else {
                        // 显示链接
                        paragraphs.push(
                            new this.docx.Paragraph({
                                children: [
                                    new this.docx.TextRun({
                                        text: `${prefix}${index + 1}: `,
                                        bold: true,
                                        color: "666666"
                                    }),
                                    new this.docx.TextRun({
                                        text: img.src,
                                        color: "0066CC"
                                    }),
                                    ...(img.width || img.height ? [
                                        new this.docx.TextRun({
                                            text: ` (${img.width}x${img.height})`,
                                            color: "999999"
                                        })
                                    ] : [])
                                ],
                                indent: { left: 400 },
                                spacing: { after: 100 }
                            })
                        );
                    }
                }
            }
            
            return paragraphs;
        }

        // 创建题目部分
        async createQuestionsSection(questions, includeMyAnswer, includeCorrectAnswer, includeScore, includeAnalysis, includeSeparator, embedImages = false) {
            const elements = [];

            for (let index = 0; index < questions.length; index++) {
                const question = questions[index];
                
                // 题目标题
                elements.push(
                    new this.docx.Paragraph({
                        children: [
                            new this.docx.TextRun({
                                text: `${question.number}. [${question.type}] `,
                                bold: true
                            }),
                            new this.docx.TextRun({
                                text: question.content
                            })
                        ],
                        spacing: { before: 300, after: 200 }
                    })
                );

                // 题目中的图片
                if (question.contentImages.length > 0) {
                    const imageParagraphs = await this.createImagesParagraphs(question.contentImages, "题目图片", embedImages);
                    elements.push(...imageParagraphs);
                }

                // 选项
                if (question.options.length > 0) {
                    for (let optionIndex = 0; optionIndex < question.options.length; optionIndex++) {
                        const option = question.options[optionIndex];
                        
                        elements.push(
                            new this.docx.Paragraph({
                                children: [
                                    new this.docx.TextRun({
                                        text: option
                                    })
                                ],
                                indent: { left: 400 },
                                spacing: { after: 100 }
                            })
                        );

                        // 选项中的图片
                        const optionImageGroup = question.optionImages.find(oi => oi.optionIndex === optionIndex);
                        if (optionImageGroup && optionImageGroup.images.length > 0) {
                            const optionImageParagraphs = await this.createImagesParagraphs(
                                optionImageGroup.images, 
                                `选项${String.fromCharCode(65 + optionIndex)}图片`, 
                                embedImages
                            );
                            elements.push(...optionImageParagraphs);
                        }
                    }
                }

                // 我的答案
                if (includeMyAnswer && question.myAnswer) {
                    elements.push(
                        new this.docx.Paragraph({
                            children: [
                                new this.docx.TextRun({
                                    text: "我的答案: ",
                                    bold: true,
                                    color: "0066CC"
                                }),
                                new this.docx.TextRun({
                                    text: question.myAnswer,
                                    color: "0066CC"
                                })
                            ],
                            spacing: { after: 100 }
                        })
                    );
                }

                // 正确答案
                if (includeCorrectAnswer && question.correctAnswer) {
                    elements.push(
                        new this.docx.Paragraph({
                            children: [
                                new this.docx.TextRun({
                                    text: "正确答案: ",
                                    bold: true,
                                    color: "009900"
                                }),
                                new this.docx.TextRun({
                                    text: question.correctAnswer,
                                    color: "009900"
                                })
                            ],
                            spacing: { after: 100 }
                        })
                    );
                }

                // 答案解析
                if (includeAnalysis && question.analysis) {
                    elements.push(
                        new this.docx.Paragraph({
                            children: [
                                new this.docx.TextRun({
                                    text: "答案解析: ",
                                    bold: true,
                                    color: "FF6600"
                                }),
                                new this.docx.TextRun({
                                    text: question.analysis,
                                    color: "FF6600"
                                })
                            ],
                            spacing: { after: 100 }
                        })
                    );

                    // 解析中的图片
                    if (question.analysisImages.length > 0) {
                        const analysisImageParagraphs = await this.createImagesParagraphs(question.analysisImages, "解析图片", embedImages);
                        elements.push(...analysisImageParagraphs);
                    }
                }

                // 得分和正确性
                if (includeScore && question.score) {
                    elements.push(
                        new this.docx.Paragraph({
                            children: [
                                new this.docx.TextRun({
                                    text: `得分: ${question.score}分 `,
                                    bold: true
                                }),
                                new this.docx.TextRun({
                                    text: question.isCorrect ? "✓ 正确" : "✗ 错误",
                                    color: question.isCorrect ? "009900" : "CC0000",
                                    bold: true
                                })
                            ],
                            spacing: { after: 200 }
                        })
                    );
                }

                // 分隔线
                if (includeSeparator && index < questions.length - 1) {
                    elements.push(
                        new this.docx.Paragraph({
                            children: [
                                new this.docx.TextRun({
                                    text: "─".repeat(50),
                                    color: "CCCCCC"
                                })
                            ],
                            alignment: this.docx.AlignmentType.CENTER,
                            spacing: { before: 200, after: 200 }
                        })
                    );
                }
            }

            return elements;
        }

        async downloadWord(doc, filename) {
            try {
                const blob = await this.docx.Packer.toBlob(doc);
                
                // 尝试多种下载方式
                if (this.saveAs) {
                    this.saveAs(blob, `${filename}.docx`);
                } else if (typeof saveAs !== 'undefined') {
                    saveAs(blob, `${filename}.docx`);
                } else {
                    // 备用下载方法
                    const url = URL.createObjectURL(blob);
                    const a = document.createElement('a');
                    a.href = url;
                    a.download = `${filename}.docx`;
                    document.body.appendChild(a);
                    a.click();
                    document.body.removeChild(a);
                    URL.revokeObjectURL(url);
                }
                
                return true;
            } catch (error) {
                console.error('下载Word文档时出错:', error);
                return false;
            }
        }
    }

    // UI界面
    class ExtractorUI {
        constructor() {
            this.parser = new QuestionParser();
            this.wordGenerator = new WordGenerator();
            this.isVisible = false;
            this.questions = [];
        }

        // 创建UI界面
        createUI() {
            const container = document.createElement('div');
            container.id = 'chaoxing-extractor';
            container.innerHTML = `
                <style>
                    #chaoxing-extractor {
                        position: fixed;
                        top: 80px;
                        right: 20px;
                        width: 340px;
                        background: #fff;
                        border-radius: 12px;
                        box-shadow: 0 8px 32px rgba(0,0,0,0.1);
                        z-index: 10000;
                        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
                        transform: translateX(400px);
                        transition: transform 0.3s ease;
                        border: 1px solid #e1e5e9;
                        max-height: calc(100vh - 100px);
                        overflow-y: auto;
                    }
                    
                    #chaoxing-extractor.visible {
                        transform: translateX(0);
                    }
                    
                    .extractor-header {
                        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
                        color: white;
                        padding: 16px 20px;
                        border-radius: 12px 12px 0 0;
                        display: flex;
                        justify-content: space-between;
                        align-items: center;
                        position: sticky;
                        top: 0;
                        z-index: 1;
                    }
                    
                    .extractor-title {
                        font-size: 16px;
                        font-weight: 600;
                        margin: 0;
                    }
                    
                    .extractor-close {
                        background: rgba(255,255,255,0.2);
                        border: none;
                        color: white;
                        width: 28px;
                        height: 28px;
                        border-radius: 50%;
                        cursor: pointer;
                        font-size: 16px;
                        display: flex;
                        align-items: center;
                        justify-content: center;
                        transition: background-color 0.2s;
                    }
                    
                    .extractor-close:hover {
                        background: rgba(255,255,255,0.3);
                    }
                    
                    .extractor-content {
                        padding: 20px;
                    }
                    
                    .stats-card {
                        background: #f8fafc;
                        border-radius: 8px;
                        padding: 16px;
                        margin-bottom: 20px;
                        border-left: 4px solid #667eea;
                    }
                    
                    .stats-title {
                        font-size: 14px;
                        font-weight: 600;
                        color: #374151;
                        margin-bottom: 8px;
                    }
                    
                    .stats-item {
                        display: flex;
                        justify-content: space-between;
                        font-size: 13px;
                        color: #6b7280;
                        margin-bottom: 4px;
                    }
                    
                    .stats-item:last-child {
                        margin-bottom: 0;
                    }
                    
                    .options-group {
                        margin-bottom: 20px;
                    }
                    
                    .options-title {
                        font-size: 14px;
                        font-weight: 600;
                        color: #374151;
                        margin-bottom: 12px;
                    }
                    
                    .option-item {
                        display: flex;
                        align-items: center;
                        margin-bottom: 8px;
                    }
                    
                    .option-checkbox {
                        margin-right: 8px;
                    }
                    
                    .option-label {
                        font-size: 13px;
                        color: #6b7280;
                        cursor: pointer;
                        flex: 1;
                    }
                    
                    .option-hint {
                        font-size: 12px;
                        color: #9ca3af;
                        margin-left: 24px;
                        margin-top: 2px;
                        line-height: 1.3;
                    }
                    
                    .action-buttons {
                        display: flex;
                        flex-direction: column;
                        gap: 10px;
                    }
                    
                    .btn {
                        padding: 10px 16px;
                        border: none;
                        border-radius: 6px;
                        font-size: 14px;
                        font-weight: 500;
                        cursor: pointer;
                        transition: all 0.2s;
                        display: flex;
                        align-items: center;
                        justify-content: center;
                        gap: 8px;
                    }
                    
                    .btn-primary {
                        background: #667eea;
                        color: white;
                    }
                    
                    .btn-primary:hover {
                        background: #5a67d8;
                        transform: translateY(-1px);
                    }
                    
                    .btn-success {
                        background: #48bb78;
                        color: white;
                    }
                    
                    .btn-success:hover {
                        background: #38a169;
                        transform: translateY(-1px);
                    }
                    
                    .btn:disabled {
                        background: #e2e8f0;
                        color: #a0aec0;
                        cursor: not-allowed;
                        transform: none;
                    }
                    
                    .loading {
                        display: inline-block;
                        width: 16px;
                        height: 16px;
                        border: 2px solid rgba(255,255,255,0.3);
                        border-radius: 50%;
                        border-top-color: white;
                        animation: spin 1s ease-in-out infinite;
                    }
                    
                    @keyframes spin {
                        to { transform: rotate(360deg); }
                    }
                    
                    .message {
                        padding: 12px;
                        border-radius: 6px;
                        font-size: 13px;
                        margin-bottom: 16px;
                    }
                    
                    .message-success {
                        background: #f0fff4;
                        color: #38a169;
                        border: 1px solid #c6f6d5;
                    }
                    
                    .message-error {
                        background: #fed7d7;
                        color: #e53e3e;
                        border: 1px solid #feb2b2;
                    }
                    
                    .image-info {
                        color: #ff6600;
                        font-weight: 500;
                    }
                </style>
                
                <div class="extractor-header">
                    <h3 class="extractor-title">题目提取工具 v1.3</h3>
                    <button class="extractor-close" onclick="extractorUI.hide()">×</button>
                </div>
                
                <div class="extractor-content">
                    <div id="stats-container"></div>
                    
                    <div class="options-group">
                        <div class="options-title">导出选项</div>
                        <div class="option-item">
                            <input type="checkbox" id="include-my-answer" class="option-checkbox" checked>
                            <label for="include-my-answer" class="option-label">包含我的答案</label>
                        </div>
                        <div class="option-item">
                            <input type="checkbox" id="include-correct-answer" class="option-checkbox" checked>
                            <label for="include-correct-answer" class="option-label">包含正确答案</label>
                        </div>
                        <div class="option-item">
                            <input type="checkbox" id="include-score" class="option-checkbox" checked>
                            <label for="include-score" class="option-label">包含每题得分</label>
                        </div>
                        <div class="option-item">
                            <input type="checkbox" id="include-analysis" class="option-checkbox" checked>
                            <label for="include-analysis" class="option-label">包含答案解析</label>
                        </div>
                        <div class="option-item">
                            <input type="checkbox" id="include-statistics" class="option-checkbox" checked>
                            <label for="include-statistics" class="option-label">包含统计信息</label>
                        </div>
                        <div class="option-item">
                            <input type="checkbox" id="include-separator" class="option-checkbox" checked>
                            <label for="include-separator" class="option-label">题目间添加分割线</label>
                        </div>
                        <div class="option-item">
                            <input type="checkbox" id="embed-images" class="option-checkbox">
                            <label for="embed-images" class="option-label">Word中嵌入图片（文件较大）</label>
                        </div>
                        <div class="option-hint">
                            勾选后会下载并嵌入所有图片到Word文档中，生成时间较长，文件较大但可离线查看
                        </div>
                    </div>
                    
                    <div id="message-container"></div>
                    
                    <div class="action-buttons">
                        <button id="parse-btn" class="btn btn-primary" onclick="extractorUI.parseQuestions()">
                            📋 解析题目
                        </button>
                        <button id="download-btn" class="btn btn-success" onclick="extractorUI.downloadWord()" disabled>
                            📄 下载Word文档
                        </button>
                        <button id="download-json-btn" class="btn btn-primary" onclick="extractorUI.downloadJSON()" disabled>
                            📋 下载JSON数据
                        </button>
                    </div>
                </div>
            `;

            document.body.appendChild(container);
            return container;
        }

        // 创建浮动按钮
        createFloatButton() {
            const button = document.createElement('button');
            button.id = 'chaoxing-float-btn';
            button.innerHTML = '🖼️';
            button.title = '题目提取工具（支持图片）';
            button.style.cssText = `
                position: fixed;
                bottom: 80px;
                right: 20px;
                width: 56px;
                height: 56px;
                border-radius: 50%;
                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
                color: white;
                border: none;
                font-size: 24px;
                cursor: pointer;
                box-shadow: 0 4px 20px rgba(102, 126, 234, 0.4);
                z-index: 9999;
                transition: all 0.3s ease;
            `;

            button.addEventListener('mouseenter', () => {
                button.style.transform = 'scale(1.1)';
                button.style.boxShadow = '0 6px 25px rgba(102, 126, 234, 0.6)';
            });

            button.addEventListener('mouseleave', () => {
                button.style.transform = 'scale(1)';
                button.style.boxShadow = '0 4px 20px rgba(102, 126, 234, 0.4)';
            });

            button.onclick = () => this.toggle();
            document.body.appendChild(button);
        }

        // 显示界面
        show() {
            this.isVisible = true;
            document.getElementById('chaoxing-extractor').classList.add('visible');
        }

        // 隐藏界面
        hide() {
            this.isVisible = false;
            document.getElementById('chaoxing-extractor').classList.remove('visible');
        }

        // 切换显示状态
        toggle() {
            if (this.isVisible) {
                this.hide();
            } else {
                this.show();
            }
        }

        // 显示消息
        showMessage(text, type = 'success') {
            const container = document.getElementById('message-container');
            container.innerHTML = `
                <div class="message message-${type}">
                    ${text}
                </div>
            `;
            
            setTimeout(() => {
                container.innerHTML = '';
            }, 4000);
        }

        // 更新统计信息
        updateStats(stats) {
            const container = document.getElementById('stats-container');
            container.innerHTML = `
                <div class="stats-card">
                    <div class="stats-title">答题统计</div>
                    <div class="stats-item">
                        <span>题目总数:</span>
                        <span>${stats.totalQuestions}题</span>
                    </div>
                    <div class="stats-item">
                        <span>正确题数:</span>
                        <span>${stats.correctCount}题</span>
                    </div>
                    <div class="stats-item">
                        <span>正确率:</span>
                        <span>${stats.accuracy}</span>
                    </div>
                    <div class="stats-item">
                        <span>得分:</span>
                        <span>${stats.totalScore}/${stats.maxScore}分</span>
                    </div>
                    <div class="stats-item">
                        <span>图片数量:</span>
                        <span class="image-info">${stats.totalImages}张</span>
                    </div>
                </div>
            `;
        }

        // 解析题目
        async parseQuestions() {
            const parseBtn = document.getElementById('parse-btn');
            const downloadBtn = document.getElementById('download-btn');
            const downloadJsonBtn = document.getElementById('download-json-btn');
            
            // 更新按钮状态
            parseBtn.innerHTML = '<div class="loading"></div> 解析中...';
            parseBtn.disabled = true;
            downloadBtn.disabled = true;
            downloadJsonBtn.disabled = true;

            try {
                // 解析题目
                this.questions = this.parser.parseAllQuestions();
                
                if (this.questions.length === 0) {
                    throw new Error('未找到任何题目，请确保页面已完全加载');
                }

                // 获取统计信息
                const stats = this.parser.getStatistics();
                this.updateStats(stats);

                // 显示成功消息
                this.showMessage(`成功解析 ${this.questions.length} 道题目，包含 ${stats.totalImages} 张图片`, 'success');

                // 启用下载按钮
                downloadBtn.disabled = false;
                downloadJsonBtn.disabled = false;

            } catch (error) {
                console.error('解析题目时出错:', error);
                this.showMessage(`解析失败: ${error.message}`, 'error');
            } finally {
                // 恢复按钮状态
                parseBtn.innerHTML = '📋 解析题目';
                parseBtn.disabled = false;
            }
        }

        // 更新按钮文本和进度
        updateDownloadProgress(button, text) {
            button.innerHTML = `<div class="loading"></div> ${text}`;
        }

        // 下载Word文档
        async downloadWord() {
            if (this.questions.length === 0) {
                this.showMessage('请先解析题目', 'error');
                return;
            }

            // 检查库是否可用
            if (!this.wordGenerator.docx) {
                this.showMessage('docx库未加载，无法生成Word文档', 'error');
                return;
            }

            const downloadBtn = document.getElementById('download-btn');
            downloadBtn.disabled = true;

            try {
                // 获取导出选项
                const options = {
                    includeMyAnswer: document.getElementById('include-my-answer').checked,
                    includeCorrectAnswer: document.getElementById('include-correct-answer').checked,
                    includeScore: document.getElementById('include-score').checked,
                    includeAnalysis: document.getElementById('include-analysis').checked,
                    includeStatistics: document.getElementById('include-statistics').checked,
                    includeSeparator: document.getElementById('include-separator').checked,
                    embedImages: document.getElementById('embed-images').checked
                };

                // 获取标题和统计信息
                const title = this.parser.getWorkTitle();
                const stats = this.parser.getStatistics();

                // 显示不同的进度信息
                if (options.embedImages && stats.totalImages > 0) {
                    this.updateDownloadProgress(downloadBtn, `下载图片中 (${stats.totalImages}张)...`);
                    this.showMessage(`正在下载 ${stats.totalImages} 张图片，请稍候...`, 'success');
                } else {
                    this.updateDownloadProgress(downloadBtn, '生成中...');
                }

                // 生成Word文档
                console.log('开始生成Word文档...');
                const doc = await this.wordGenerator.generateWord(this.questions, title, stats, options);
                
                this.updateDownloadProgress(downloadBtn, '准备下载...');
                
                // 下载文档
                const filename = `${title}_${new Date().toLocaleDateString().replace(/\//g, '-')}`;
                console.log('开始下载Word文档...');
                const success = await this.wordGenerator.downloadWord(doc, filename);

                if (success) {
                    const imageStatus = options.embedImages ? 
                        `已嵌入 ${stats.totalImages} 张图片` : 
                        `包含 ${stats.totalImages} 张图片的URL`;
                    this.showMessage(`Word文档下载成功！${imageStatus}`, 'success');
                } else {
                    throw new Error('下载过程中发生错误');
                }

            } catch (error) {
                console.error('下载Word文档时出错:', error);
                this.showMessage(`下载失败: ${error.message}`, 'error');
            } finally {
                downloadBtn.innerHTML = '📄 下载Word文档';
                downloadBtn.disabled = false;
            }
        }

        // 下载JSON数据
        downloadJSON() {
            if (this.questions.length === 0) {
                this.showMessage('请先解析题目', 'error');
                return;
            }

            try {
                const title = this.parser.getWorkTitle();
                const stats = this.parser.getStatistics();
                
                // 获取导出选项
                const options = {
                    includeMyAnswer: document.getElementById('include-my-answer').checked,
                    includeCorrectAnswer: document.getElementById('include-correct-answer').checked,
                    includeScore: document.getElementById('include-score').checked,
                    includeAnalysis: document.getElementById('include-analysis').checked,
                    includeStatistics: document.getElementById('include-statistics').checked,
                    includeSeparator: document.getElementById('include-separator').checked
                };
                
                // 根据选项过滤题目数据
                const filteredQuestions = this.questions.map(question => {
                    const filtered = {
                        type: question.type,
                        number: question.number,
                        content: question.content,
                        contentImages: question.contentImages,
                        options: question.options,
                        optionImages: question.optionImages,
                        isCorrect: question.isCorrect
                    };
                    
                    if (options.includeMyAnswer) {
                        filtered.myAnswer = question.myAnswer;
                    }
                    
                    if (options.includeCorrectAnswer) {
                        filtered.correctAnswer = question.correctAnswer;
                    }
                    
                    if (options.includeScore) {
                        filtered.score = question.score;
                    }
                    
                    if (options.includeAnalysis) {
                        filtered.analysis = question.analysis;
                        filtered.analysisImages = question.analysisImages;
                    }
                    
                    return filtered;
                });
                
                const data = {
                    title: title,
                    exportTime: new Date().toLocaleString(),
                    exportOptions: options,
                    statistics: options.includeStatistics ? stats : null,
                    questions: filteredQuestions
                };

                const jsonStr = JSON.stringify(data, null, 2);
                const blob = new Blob([jsonStr], { type: 'application/json' });
                
                const url = URL.createObjectURL(blob);
                const a = document.createElement('a');
                a.href = url;
                a.download = `${title}_${new Date().toLocaleDateString().replace(/\//g, '-')}.json`;
                document.body.appendChild(a);
                a.click();
                document.body.removeChild(a);
                URL.revokeObjectURL(url);

                this.showMessage(`JSON数据下载成功！包含 ${stats.totalImages} 张图片信息`, 'success');
            } catch (error) {
                console.error('下载JSON时出错:', error);
                this.showMessage(`下载失败: ${error.message}`, 'error');
            }
        }

        // 初始化
        async init() {
            // 检查必要的库
            const libErrors = checkLibraries();
            if (libErrors.length > 0) {
                console.error('库加载检查失败:', libErrors);
                alert(`题目提取工具初始化失败：\n${libErrors.join('\n')}\n\n请检查网络连接或稍后重试`);
                return;
            }

            // 等待页面加载
            try {
                await waitForElement('.questionLi', 10000);
                
                // 创建UI
                this.createUI();
                this.createFloatButton();
                
                // 设置全局引用
                window.extractorUI = this;
                
                console.log('超星学习通题目提取工具（支持图片）已加载');
                
            } catch (error) {
                console.error('初始化失败:', error);
                alert(`题目提取工具初始化失败：${error.message}`);
            }
        }
    }

    // 启动应用
    function startApp() {
        // 等待库加载完成
        const checkInterval = setInterval(() => {
            const errors = checkLibraries();
            if (errors.length === 0) {
                clearInterval(checkInterval);
                const extractorUI = new ExtractorUI();
                extractorUI.init();
            }
        }, 500);

        // 超时处理
        setTimeout(() => {
            clearInterval(checkInterval);
            const errors = checkLibraries();
            if (errors.length > 0) {
                console.warn('库加载超时，尝试强制启动...');
                const extractorUI = new ExtractorUI();
                extractorUI.init();
            }
        }, 10000);
    }

    // 页面加载完成后启动
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', startApp);
    } else {
        startApp();
    }

})();