{% extends "base.html" %}

{% block title %}学生提交状态管理 - FlashExam<!-- 切屏记录模态框 -->
<div class="modal fade" id="focusLogsModal" tabindex="-1">
    <div class="modal-dialog modal-lg">
        <div class="modal-content">
            <div class="modal-header">
                <h5 class="modal-title">切屏记录详情</h5>
                <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
            </div>
            <div class="modal-body">
                <div class="table-responsive">
                    <table class="table table-striped table-hover">
                        <thead>
                            <tr>
                                <th>序号</th>
                                <th>切出时间</th>
                                <th>切出时长 (秒)</th>
                            </tr>
                        </thead>
                        <tbody id="focusLogsBody">
                            <!-- Logs will be inserted here -->
                        </tbody>
                    </table>
                </div>
            </div>
            <div class="modal-footer">
                <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">关闭</button>
            </div>
        </div>
    </div>
</div>
{% endblock %}

{% block head %}
{{ super() }}
    <script src="/static/js/libs/sweetalert2/sweetalert2.min.js"></script>
{% endblock %}

{% block content %}
<div class="d-flex justify-content-between align-items-center mb-4">
    <h1 class="h3 mb-0">
        <i class="bi bi-people-fill"></i>
        学生提交状态管理
    </h1>
    <a href="{{ url_for('teacher.exams') }}" class="btn btn-outline-secondary">
        <i class="bi bi-arrow-left"></i> 返回考试管理
    </a>
</div>

<!-- 考试信息 -->
<div class="card mb-4">
    <div class="card-header bg-primary text-white">
        <h5 class="mb-0">
            <i class="bi bi-file-earmark-text"></i>
            考试信息
        </h5>
    </div>
    <div class="card-body">
        <div class="row">
            <div class="col-md-6">
                <p><strong>考试名称:</strong> <span id="exam-title">加载中...</span></p>
                <p><strong>考试时长:</strong> <span id="exam-duration">加载中...</span></p>
            </div>
            <div class="col-md-6">
                <p><strong>题目数量:</strong> <span id="exam-questions">加载中...</span></p>
                <p><strong>总分:</strong> <span id="exam-total-score">加载中...</span></p>
            </div>
        </div>
    </div>
</div>

<!-- 筛选和排序工具栏 -->
<div class="card mb-4">
    <div class="card-header bg-info text-white">
        <h6 class="mb-0">
            <i class="bi bi-funnel"></i>
            筛选和排序
        </h6>
    </div>
    <div class="card-body">
        <div class="row g-3">
            <div class="col-md-3">
                <label for="filter-college" class="form-label">学院</label>
                <select class="form-select" id="filter-college" onchange="applyFilters()">
                    <option value="">全部学院</option>
                </select>
            </div>
            <div class="col-md-3">
                <label for="filter-major" class="form-label">专业</label>
                <select class="form-select" id="filter-major" onchange="applyFilters()">
                    <option value="">全部专业</option>
                </select>
            </div>
            <div class="col-md-2">
                <label for="filter-class" class="form-label">班级</label>
                <select class="form-select" id="filter-class" onchange="applyFilters()">
                    <option value="">全部班级</option>
                </select>
            </div>
            <div class="col-md-2">
                <label for="filter-status" class="form-label">状态</label>
                <select class="form-select" id="filter-status" onchange="applyFilters()">
                    <option value="">全部状态</option>
                    <option value="completed">已完成</option>
                    <option value="in_progress">进行中</option>
                    <option value="not_started">未开始</option>
                </select>
            </div>
            <div class="col-md-2">
                <label for="sort-by" class="form-label">排序方式</label>
                <select class="form-select" id="sort-by" onchange="applyFilters()">
                    <option value="student_number">按学号</option>
                    <option value="student_name">按姓名</option>
                    <option value="college">按学院</option>
                    <option value="major">按专业</option>
                    <option value="class_name">按班级</option>
                    <option value="status">按状态</option>
                    <option value="score">按分数</option>
                    <option value="start_time">按开始时间</option>
                    <option value="end_time">按提交时间</option>
                </select>
            </div>
        </div>
        <div class="row mt-3">
            <div class="col-md-8">
                <div class="input-group">
                    <span class="input-group-text"><i class="bi bi-search"></i></span>
                    <input type="text" class="form-control" id="search-input" placeholder="搜索学号、姓名..." onkeyup="applyFilters()">
                    <button class="btn btn-outline-secondary" type="button" onclick="clearFilters()">
                        <i class="bi bi-x-circle"></i> 清除筛选
                    </button>
                </div>
            </div>
            <div class="col-md-4 text-end">
                <div class="btn-group" role="group">
                    <input type="radio" class="btn-check" name="sort-order" id="sort-asc" value="asc" checked onchange="applyFilters()">
                    <label class="btn btn-outline-primary" for="sort-asc">
                        <i class="bi bi-sort-alpha-down"></i> 升序
                    </label>
                    <input type="radio" class="btn-check" name="sort-order" id="sort-desc" value="desc" onchange="applyFilters()">
                    <label class="btn btn-outline-primary" for="sort-desc">
                        <i class="bi bi-sort-alpha-up"></i> 降序
                    </label>
                </div>
            </div>
        </div>
        <div class="row mt-2">
            <div class="col-12">
                <small class="text-muted">
                    <span id="filter-stats">显示 0 / 0 名学生</span>
                    <span class="ms-3" id="status-stats"></span>
                </small>
            </div>
        </div>
    </div>
</div>

<!-- 批量操作工具栏 -->
<div class="card mb-4">
    <div class="card-header bg-secondary text-white">
        <h6 class="mb-0">
            <i class="bi bi-tools"></i>
            批量操作
        </h6>
    </div>
    <div class="card-body">
        <div class="row">
            <div class="col-md-8">
                <div class="btn-group" role="group">
                    <button type="button" class="btn btn-outline-primary" onclick="selectAll()">
                        <i class="bi bi-check2-all"></i> 全选
                    </button>
                    <button type="button" class="btn btn-outline-secondary" onclick="clearSelection()">
                        <i class="bi bi-square"></i> 清空选择
                    </button>
                </div>
                <div class="btn-group ms-3" role="group">
                    <button type="button" class="btn btn-info" onclick="startExamSelected()" disabled id="start-exam-btn">
                        <i class="bi bi-play-circle"></i> 开始考试
                    </button>
                    <button type="button" class="btn btn-warning" onclick="forceSubmitSelected()" disabled id="force-submit-btn">
                        <i class="bi bi-send-check"></i> 强制提交
                    </button>
                    <button type="button" class="btn btn-success" onclick="allowContinueSelected()" disabled id="allow-continue-btn">
                        <i class="bi bi-arrow-clockwise"></i> 允许继续
                    </button>
                    <button type="button" class="btn btn-danger" onclick="clearProgressSelected()" disabled id="clear-progress-btn">
                        <i class="bi bi-trash"></i> 清除记录
                    </button>
                    <button type="button" class="btn btn-warning" onclick="forceRefreshSelected()" disabled id="force-refresh-btn">
                        <i class="bi bi-arrow-clockwise"></i> 强制刷新
                    </button>
                    <button type="button" class="btn btn-primary" onclick="exportSelectedPapers()" disabled id="export-papers-btn">
                        <i class="bi bi-file-earmark-word"></i> 导出答卷
                    </button>
                </div>
            </div>
            <div class="col-md-4 text-end">
                <span class="badge bg-info" id="selected-count">已选择: 0</span>
            </div>
        </div>
    </div>
</div>

<!-- 学生状态表格 -->
<div class="card">
    <div class="card-header bg-success text-white">
        <h5 class="mb-0">
            <i class="bi bi-table"></i>
            学生提交状态
        </h5>
    </div>
    <div class="card-body">
        <div class="table-responsive">
            <table class="table table-hover" id="students-table">
                <thead>
                    <tr>
                        <th width="50px">
                            <input type="checkbox" id="select-all-checkbox" onchange="toggleSelectAll()">
                        </th>
                        <th>学号</th>
                        <th>姓名</th>
                        <th>学院</th>
                        <th>专业</th>
                        <th>班级</th>
                        <th>状态</th>
                        <th>分数</th>
                        <th>切屏次数</th>
                        <th>开始时间</th>
                        <th>提交时间</th>
                        <th>操作</th>
                    </tr>
                </thead>
                <tbody id="students-tbody">
                    <tr>
                        <td colspan="11" class="text-center">
                            <div class="spinner-border" role="status">
                                <span class="visually-hidden">加载中...</span>
                            </div>
                            <p class="mt-2">正在加载学生数据...</p>
                        </td>
                    </tr>
                </tbody>
            </table>
        </div>
    </div>
</div>

<script>
const examId = {{ exam_id|default(0)|int }};
let studentsData = [];
let filteredStudentsData = [];

// 页面加载时获取数据
document.addEventListener('DOMContentLoaded', function() {
    loadStudentSubmissions();
});

// 查看切屏记录详情
function viewFocusLogs(studentId) {
    const student = studentsData.find(s => s.student_id === studentId);
    if (!student) {
        alert('未找到学生数据');
        return;
    }

    const tbody = document.getElementById('focusLogsBody');
    tbody.innerHTML = '';

    try {
        let logs = [];
        if (typeof student.focus_lost_logs === 'string') {
            logs = JSON.parse(student.focus_lost_logs || '[]');
        } else {
            logs = student.focus_lost_logs || [];
        }

        if (logs.length === 0) {
            tbody.innerHTML = '<tr><td colspan="3" class="text-center">暂无详细记录</td></tr>';
        } else {
            logs.forEach((log, index) => {
                // 兼容旧格式（只有时间字符串）和新格式（对象 {time, duration}）
                let timeStr = '';
                let durationStr = '-';
                
                if (typeof log === 'string') {
                    timeStr = formatDateTime(log);
                } else if (typeof log === 'object') {
                    timeStr = formatDateTime(log.time);
                    if (log.duration !== undefined && log.duration !== null) {
                        durationStr = log.duration + ' 秒';
                    }
                }

                const tr = document.createElement('tr');
                tr.innerHTML = `
                    <td>${index + 1}</td>
                    <td>${timeStr}</td>
                    <td>${durationStr}</td>
                `;
                tbody.appendChild(tr);
            });
        }

        const modal = new bootstrap.Modal(document.getElementById('focusLogsModal'));
        modal.show();

    } catch (e) {
        console.error('解析日志失败:', e);
        alert('解析切屏记录失败');
    }
}

// 加载学生提交状态
function loadStudentSubmissions() {
    fetch(`/teacher/exams/${examId}/student-submissions`)
        .then(response => response.json())
        .then(data => {
            if (data.success) {
                displayExamInfo(data.exam);

                // Update monitoring settings UI
                if (data.monitoring_config && document.getElementById('max-focus-warnings')) {
                    const config = data.monitoring_config;
                    document.getElementById('max-focus-warnings').value = config.max_focus_warnings || 9;
                    document.getElementById('auto-submit-exceed').checked = config.auto_submit_on_exceed;
                    document.getElementById('enable-monitoring').checked = config.enable_focus_monitoring;
                    if (typeof toggleMonitoringOptions === 'function') {
                        toggleMonitoringOptions();
                    }
                }

                studentsData = data.students;
                initializeFilters();
                applyFilters();
            } else {
                alert('加载失败: ' + data.message);
            }
        })
        .catch(error => {
            console.error('Error:', error);
            alert('加载失败，请重试');
        });
}

// 显示考试信息
function displayExamInfo(exam) {
    document.getElementById('exam-title').textContent = exam.title;
    document.getElementById('exam-duration').textContent = exam.duration_minutes + ' 分钟';
    document.getElementById('exam-questions').textContent = exam.total_questions + ' 题';
    document.getElementById('exam-total-score').textContent = exam.total_score + ' 分';
}

// 显示学生数据
function displayStudents(students) {
    const tbody = document.getElementById('students-tbody');
    
    if (students.length === 0) {
        tbody.innerHTML = `
            <tr>
                <td colspan="11" class="text-center text-muted">
                    <i class="bi bi-people"></i>
                    <p class="mt-2">暂无学生数据</p>
                </td>
            </tr>
        `;
        return;
    }
    
    tbody.innerHTML = students.map(student => {
        const statusClass = getStatusClass(student.status);
        const statusText = getStatusText(student.status);
        const scoreDisplay = getScoreDisplay(student);
        
        return `
            <tr data-student-id="${student.student_id}">
                <td>
                    <input type="checkbox" class="student-checkbox" value="${student.student_id}" onchange="updateSelection()">
                </td>
                <td><strong>${student.student_number}</strong></td>
                <td>${student.student_name}</td>
                <td>${student.college}</td>
                <td>${student.major}</td>
                <td>${student.class_name}</td>
                <td>
                    <span class="badge ${statusClass}">${statusText}</span>
                </td>
                <td>${scoreDisplay}</td>
                <td>
                    <div class="d-flex align-items-center">
                        <span class="badge bg-warning text-dark me-2">${student.focus_lost_count || 0}</span>
                        ${(student.focus_lost_count > 0) ? 
                            `<button class="btn btn-sm btn-outline-secondary" onclick="viewFocusLogs(${student.student_id})" title="查看切屏详情">
                                <i class="bi bi-eye"></i>
                            </button>` : ''
                        }
                    </div>
                </td>
                <td>${student.start_time ? formatDateTime(student.start_time) : '-'}</td>
                <td>${student.end_time ? formatDateTime(student.end_time) : '-'}</td>
                <td>
                    <div class="btn-group btn-group-sm" role="group">
                        ${getActionButtons(student)}
                    </div>
                </td>
            </tr>
        `;
    }).join('');
}

// 获取状态样式类
function getStatusClass(status) {
    switch(status) {
        case 'completed': return 'bg-success';
        case 'in_progress': return 'bg-warning';
        case 'not_started': return 'bg-secondary';
        default: return 'bg-secondary';
    }
}

// 获取状态文本
function getStatusText(status) {
    switch(status) {
        case 'completed': return '已完成';
        case 'in_progress': return '进行中';
        case 'not_started': return '未开始';
        default: return '未知';
    }
}

// 获取分数显示
function getScoreDisplay(student) {
    if (student.is_completed && student.score !== null) {
        const percentage = student.total_score > 0 ? (student.score / student.total_score * 100) : 0;
        return `${student.score.toFixed(1)}/${student.total_score.toFixed(1)} (${percentage.toFixed(1)}%)`;
    }
    return '-';
}

// 获取操作按钮
function getActionButtons(student) {
    let buttons = [];
    
    if (student.status === 'not_started') {
        buttons.push(`<button class="btn btn-info btn-sm" onclick="startExamSingle(${student.student_id})" title="开始考试">
            <i class="bi bi-play-circle"></i>
        </button>`);
    }
    
    if (student.status === 'in_progress') {
        buttons.push(`<button class="btn btn-warning btn-sm" onclick="forceSubmitSingle(${student.student_id})" title="强制提交">
            <i class="bi bi-send-check"></i>
        </button>`);
    }
    
    if (student.status === 'completed') {
        buttons.push(`<button class="btn btn-success btn-sm" onclick="allowContinueSingle(${student.student_id})" title="允许继续">
            <i class="bi bi-arrow-clockwise"></i>
        </button>`);
        
        // 使用新的查看答卷路由
        buttons.push(`<a href="/teacher/exams/${examId}/student/${student.student_id}/details" class="btn btn-primary btn-sm" title="查看答卷">
            <i class="bi bi-eye-fill"></i>
        </a>`);
    } else {
        // 对于未完成的学生，也显示查看答卷按钮（预览草稿）
        if (student.status === 'in_progress') {
             buttons.push(`<a href="/teacher/exams/${examId}/student/${student.student_id}/details" class="btn btn-outline-primary btn-sm" title="预览答题进度">
                <i class="bi bi-eye"></i>
            </a>`);
        } else {
            buttons.push(`<button class="btn btn-secondary btn-sm" onclick="autoFillBlankSingle(${student.student_id})" title="生成空白答卷">
                <i class="bi bi-file-earmark-plus"></i>
            </button>`);
        }
    }
    
    if (student.status === 'completed' || student.status === 'in_progress') {
        buttons.push(`<button class="btn btn-danger btn-sm" onclick="clearProgressSingle(${student.student_id})" title="清除记录">
            <i class="bi bi-trash"></i>
        </button>`);
    }

    // 导入学生本地导出的答卷
    buttons.push(`<button class="btn btn-info btn-sm ms-1" onclick="importStudentExport(${student.student_id})" title="导入学生本地导出的答卷JSON">
        <i class="bi bi-upload"></i>
    </button>`);

    return buttons.join('');
}

// 格式化日期时间
function formatDateTime(dateTimeStr) {
    if (!dateTimeStr) return '-';
    return dateTimeStr.replace('T', ' ').substring(0, 16);
}

// 选择相关函数（由筛选功能部分重新实现）

// 批量操作函数
function startExamSelected() {
    const selectedIds = getSelectedStudentIds();
    if (selectedIds.length === 0) {
        alert('请先选择要开始考试的学生');
        return;
    }
    
    if (!confirm(`确定要为选中的 ${selectedIds.length} 名学生开始考试吗？\n\n这将创建考试记录，学生可以开始答题。`)) {
        return;
    }
    
    performBatchOperation('start-exam-students', selectedIds, '开始考试');
}

function forceSubmitSelected() {
    const selectedIds = getSelectedStudentIds();
    if (selectedIds.length === 0) {
        alert('请先选择要强制提交的学生');
        return;
    }
    
    if (!confirm(`确定要强制提交选中的 ${selectedIds.length} 名学生的考试吗？\n\n强制提交会根据学生已答题目进行评分。`)) {
        return;
    }
    
    performBatchOperation('force-submit-students', selectedIds, '强制提交');
}

function allowContinueSelected() {
    const selectedIds = getSelectedStudentIds();
    if (selectedIds.length === 0) {
        alert('请先选择要允许继续的学生');
        return;
    }
    
    if (!confirm(`确定要允许选中的 ${selectedIds.length} 名学生继续考试吗？`)) {
        return;
    }
    
    performBatchOperation('allow-continue-students', selectedIds, '允许继续');
}

function clearProgressSelected() {
    const selectedIds = getSelectedStudentIds();
    if (selectedIds.length === 0) {
        alert('请先选择要清除记录的学生');
        return;
    }
    
    if (!confirm(`确定要清除选中的 ${selectedIds.length} 名学生的考试记录吗？\n\n此操作不可恢复！`)) {
        return;
    }
    
    performBatchOperation('clear-student-progress', selectedIds, '清除记录');
}

function autoFillBlankSelected() {
    const selectedIds = getSelectedStudentIds();
    if (selectedIds.length === 0) {
        alert('请先选择学生');
        return;
    }
    if (!confirm(`将为选中的 ${selectedIds.length} 名学生生成空白答卷，占位用于批阅。`)) {
        return;
    }
    performBatchOperation('auto-fill-blank-answers', selectedIds, '空白填充');
}

function testFillCorrectSelected() {
    const selectedIds = getSelectedStudentIds();
    if (selectedIds.length === 0) {
        alert('请先选择学生');
        return;
    }

    if (!confirm(`确定要为选中的 ${selectedIds.length} 名学生进行测试填充吗？\n\n这将自动填充所有客观题的正确答案并标记为满分（主要用于测试目的）。`)) {
        return;
    }

    const btn = document.getElementById('test-fill-correct-btn');
    const originalText = btn.innerHTML;
    btn.disabled = true;
    btn.innerHTML = '<span class="spinner-border spinner-border-sm"></span> 处理中...';

    fetch(`/teacher/exams/${examId}/test-fill-correct-answers`, {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({ student_ids: selectedIds })
    })
    .then(response => response.json())
    .then(data => {
        if (data.success) {
            alert(data.message);
            loadStudentSubmissions(); // 重新加载数据
        } else {
            alert('操作失败: ' + data.message);
        }
    })
    .catch(error => {
        console.error('Error:', error);
        alert('操作失败，请重试');
    })
    .finally(() => {
        btn.disabled = false;
        btn.innerHTML = originalText;
    });
}

function testPerturbSelected() {
    const selectedIds = getSelectedStudentIds();
    if (selectedIds.length === 0) {
        alert('请先选择学生');
        return;
    }

    if (!confirm(`确定要为选中的 ${selectedIds.length} 名学生进行测试扰动吗？\n\n这将随机修改2-5个客观题的答案为错误答案，并重新计算分数。\n(此操作用于模拟学生错误，请谨慎使用)`)) {
        return;
    }

    const btn = document.getElementById('test-perturb-btn');
    const originalContent = btn.innerHTML;
    btn.disabled = true;
    btn.innerHTML = '<span class="spinner-border spinner-border-sm" role="status" aria-hidden="true"></span> 处理中...';

    fetch(`/teacher/exams/${examId}/test-perturb-answers`, {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({ student_ids: selectedIds })
    })
    .then(response => response.json())
    .then(data => {
        if (data.success) {
            alert(data.message);
            loadStudentSubmissions(); // 重新加载数据
        } else {
            alert('操作失败: ' + data.message);
        }
    })
    .catch(error => {
        console.error('Error:', error);
        alert('操作出错，请查看控制台');
    })
    .finally(() => {
        btn.disabled = false;
        btn.innerHTML = originalContent;
    });
}

function forceRefreshSelected() {
        const selectedIds = getSelectedStudentIds();
        if (selectedIds.length === 0) {
            alert('请先选择学生');
            return;
        }

        if (!confirm(`确定要为选中的 ${selectedIds.length} 名学生强制刷新分数吗？\n\n这将执行以下操作：\n1. 更新考试总分（解决总分不一致问题）\n2. 重新评分所有客观题（基于当前标准答案）\n3. 重新计算所有题目的总得分`)) {
            return;
        }

        const btn = document.getElementById('force-refresh-btn');
        const originalContent = btn.innerHTML;
        btn.disabled = true;
        btn.innerHTML = '<span class="spinner-border spinner-border-sm" role="status" aria-hidden="true"></span> 处理中...';

        fetch(`/teacher/exams/${examId}/force-refresh-scores`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
            },
            body: JSON.stringify({ student_ids: selectedIds })
        })
        .then(response => response.json())
        .then(data => {
            if (data.success) {
                alert(data.message);
                loadStudentSubmissions();
            } else {
                alert('操作失败: ' + data.message);
            }
        })
        .catch(error => {
            console.error('Error:', error);
            alert('操作出错，请查看控制台');
        })
        .finally(() => {
            btn.disabled = false;
            btn.innerHTML = originalContent;
        });
    }

    function syncExamSelected() {
        const selectedIds = getSelectedStudentIds();
        if (selectedIds.length === 0) {
            alert('请先选择学生');
            return;
        }

        if (!confirm(`确定要为选中的 ${selectedIds.length} 名学生进行考试结构同步吗？\n\n警告：这将强制更新学生的答卷结构以匹配当前考试定义。\n- 新增的题目将添加为空白答案\n- 已删除的题目将从学生答卷中移除\n- 已有题目的定义（如正确答案、分值）将被更新\n\n此操作不可逆！`)) {
            return;
        }

        const btn = document.getElementById('sync-exam-btn');
        const originalContent = btn.innerHTML;
        btn.disabled = true;
        btn.innerHTML = '<span class="spinner-border spinner-border-sm" role="status" aria-hidden="true"></span> 处理中...';

        fetch(`/teacher/exams/${examId}/sync-exam-questions`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
            },
            body: JSON.stringify({ student_ids: selectedIds })
        })
        .then(response => response.json())
        .then(data => {
            if (data.success) {
                alert(data.message);
                loadStudentSubmissions();
            } else {
                alert('操作失败: ' + data.message);
            }
        })
        .catch(error => {
            console.error('Error:', error);
            alert('操作出错，请查看控制台');
        })
        .finally(() => {
            btn.disabled = false;
            btn.innerHTML = originalContent;
        });
    }

    function randomFillSubjectiveSelected() {
    const selectedIds = getSelectedStudentIds();
    if (selectedIds.length === 0) {
        alert('请先选择学生');
        return;
    }

    if (!confirm(`确定要为选中的 ${selectedIds.length} 名学生随机填充主观题吗？\n这将为每位学生随机选择一部分缺失的主观题并填充正确答案。`)) {
        return;
    }

    const btn = document.getElementById('random-fill-btn');
    const originalContent = btn.innerHTML;
    btn.disabled = true;
    btn.innerHTML = '<span class="spinner-border spinner-border-sm" role="status" aria-hidden="true"></span> 处理中...';

    fetch(`/teacher/exams/${examId}/random-fill-subjective`, {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
        },
        body: JSON.stringify({ student_ids: selectedIds })
    })
    .then(response => response.json())
    .then(data => {
        if (data.success) {
            alert(data.message);
            location.reload();
        } else {
            alert('操作失败: ' + data.message);
        }
    })
    .catch(error => {
        console.error('Error:', error);
        alert('操作出错，请查看控制台');
    })
    .finally(() => {
        btn.disabled = false;
        btn.innerHTML = originalContent;
    });
}

function randomImproveSubjectiveSelected() {
    const selectedIds = getSelectedStudentIds();
    if (selectedIds.length === 0) {
        alert('请先选择学生');
        return;
    }

    if (!confirm(`确定要为选中的 ${selectedIds.length} 名学生进行随机主观题提升吗？\n这将为每位学生随机选择3道未得满分的主观题，将其改为标准答案并赋满分。`)) {
        return;
    }

    const btn = document.getElementById('random-improve-btn');
    const originalContent = btn.innerHTML;
    btn.disabled = true;
    btn.innerHTML = '<span class="spinner-border spinner-border-sm" role="status" aria-hidden="true"></span> 处理中...';

    fetch(`/teacher/exams/${examId}/random-improve-subjective`, {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
        },
        body: JSON.stringify({ student_ids: selectedIds })
    })
    .then(response => response.json())
    .then(data => {
        if (data.success) {
            alert(data.message);
            location.reload();
        } else {
            alert('操作失败: ' + data.message);
        }
    })
    .catch(error => {
        console.error('Error:', error);
        alert('操作出错，请查看控制台');
    })
    .finally(() => {
        btn.disabled = false;
        btn.innerHTML = originalContent;
    });
}

function batchGradeObjective() {
    if (!confirm('确定要对当前考试所有已提交的学生进行客观题评分吗？\n\n这将重新计算所有客观题（选择/判断）的得分。')) {
        return;
    }
    
    const btn = document.getElementById('batch-grade-btn');
    const originalText = btn.innerHTML;
    btn.disabled = true;
    btn.innerHTML = '<span class="spinner-border spinner-border-sm"></span> 处理中...';
    
    fetch(`/teacher/exams/${examId}/batch-grade-objective`, {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        }
    })
    .then(response => response.json())
    .then(data => {
        if (data.success) {
            alert(data.message);
            loadStudentSubmissions(); // 重新加载数据
        } else {
            alert('评分失败: ' + data.message);
        }
    })
    .catch(error => {
        console.error('Error:', error);
        alert('操作失败，请重试');
    })
    .finally(() => {
        btn.disabled = false;
        btn.innerHTML = originalText;
    });
}

function autoFillBlankSingle(studentId) {
    if (!confirm('将为该学生生成空白答卷，占位用于批阅。')) {
        return;
    }
    performBatchOperation('auto-fill-blank-answers', [studentId], '空白填充');
}
// 单个操作函数
function startExamSingle(studentId) {
    if (!confirm('确定要为该学生开始考试吗？\n\n这将创建考试记录，学生可以开始答题。')) {
        return;
    }
    performBatchOperation('start-exam-students', [studentId], '开始考试');
}

function forceSubmitSingle(studentId) {
    if (!confirm('确定要强制提交该学生的考试吗？\n\n强制提交会根据学生已答题目进行评分。')) {
        return;
    }
    performBatchOperation('force-submit-students', [studentId], '强制提交');
}

function allowContinueSingle(studentId) {
    if (!confirm('确定要允许该学生继续考试吗？')) {
        return;
    }
    performBatchOperation('allow-continue-students', [studentId], '允许继续');
}

function clearProgressSingle(studentId) {
    if (!confirm('确定要清除该学生的考试记录吗？\n\n此操作不可恢复！')) {
        return;
    }
    performBatchOperation('clear-student-progress', [studentId], '清除记录');
}

// 导入学生本地导出的答卷JSON
function importStudentExport(studentId) {
    const input = document.createElement('input');
    input.type = 'file';
    input.accept = '.json';
    input.onchange = function() {
        const file = input.files[0];
        if (!file) return;
        const formData = new FormData();
        formData.append('file', file);
        Swal.fire({ title: '导入中...', allowOutsideClick: false, didOpen: () => Swal.showLoading() });
        fetch('/teacher/exams/' + examId + '/import-student-answers', {
            method: 'POST', body: formData
        }).then(r => r.json()).then(d => {
            if (d.success) {
                Swal.fire({ icon: 'success', title: '导入成功', text: d.message });
                loadStudentSubmissions();  // 刷新列表
            } else {
                Swal.fire({ icon: 'error', title: '导入失败', text: d.message });
            }
        }).catch(e => {
            Swal.fire({ icon: 'error', title: '导入失败', text: e.message });
        });
    };
    input.click();
}

// 获取选中的学生ID列表
function getSelectedStudentIds() {
    return Array.from(document.querySelectorAll('.student-checkbox:checked'))
                .map(cb => parseInt(cb.value));
}

// 导出选中学生的答卷
function exportSelectedPapers() {
    console.log('=== 导出答卷按钮被点击 ===');
    
    const selectedIds = getSelectedStudentIds();
    console.log('选中的学生ID:', selectedIds);
    
    if (selectedIds.length === 0) {
        alert('请先选择要导出答卷的学生');
        return;
    }
    
    // 只导出已完成考试的学生
    const completedStudents = filteredStudentsData.filter(s => 
        selectedIds.includes(s.student_id) && s.status === 'completed'
    );
    
    if (completedStudents.length === 0) {
        alert('选中的学生中没有已完成考试的学生');
        return;
    }
    
    if (completedStudents.length < selectedIds.length) {
        if (!confirm(`选中的 ${selectedIds.length} 名学生中，只有 ${completedStudents.length} 名已完成考试。\n\n是否继续导出已完成考试学生的答卷？`)) {
            return;
        }
    }
    
    // 检查SweetAlert2是否可用
    if (typeof Swal === 'undefined') {
        console.error('SweetAlert2未加载！');
        alert('系统错误：SweetAlert2未加载，请刷新页面重试');
        return;
    }
    
    console.log('SweetAlert2可用，显示导出选项对话框');
    
    // 显示导出选项对话框
    Swal.fire({
        title: '导出答卷选项',
        html: `
            <div class="text-start">
                <div class="mb-3">
                    <label class="form-label">导出类型：</label>
                    <div class="form-check">
                        <input class="form-check-input" type="radio" name="exportType" id="exportOriginal" value="original" checked>
                        <label class="form-check-label" for="exportOriginal">
                            原版答卷（仅显示学生答案）
                        </label>
                    </div>
                    <div class="form-check">
                        <input class="form-check-input" type="radio" name="exportType" id="exportGraded" value="graded">
                        <label class="form-check-label" for="exportGraded">
                            评分版答卷（包含答案、得分和批注）
                        </label>
                    </div>
                    <div class="form-check">
                        <input class="form-check-input" type="radio" name="exportType" id="exportBoth" value="both">
                        <label class="form-check-label" for="exportBoth">
                            两种版本都导出
                        </label>
                    </div>
                </div>
                <div class="mb-3">
                    <label class="form-label">文件格式：</label>
                    <div class="form-check">
                        <input class="form-check-input" type="radio" name="fileFormat" id="formatSingle" value="single" checked>
                        <label class="form-check-label" for="formatSingle">
                            合并为一个文件（所有学生答卷在一个文档中）
                        </label>
                    </div>
                    <div class="form-check">
                        <input class="form-check-input" type="radio" name="fileFormat" id="formatSeparate" value="separate">
                        <label class="form-check-label" for="formatSeparate">
                            分别导出（每个学生一个文档，打包下载）
                        </label>
                    </div>
                </div>
            </div>
        `,
        showCancelButton: true,
        confirmButtonText: '开始导出',
        cancelButtonText: '取消',
        confirmButtonColor: '#3085d6',
        cancelButtonColor: '#d33',
        width: '500px'
    }).then((result) => {
        if (result.isConfirmed) {
            const exportType = document.querySelector('input[name="exportType"]:checked').value;
            const fileFormat = document.querySelector('input[name="fileFormat"]:checked').value;
            
            // 执行导出
            performExport(completedStudents.map(s => s.student_id), exportType, fileFormat);
        }
    });
}

// 执行导出操作
function performExport(studentIds, exportType, fileFormat) {
    // 显示加载提示
    Swal.fire({
        title: '正在导出...',
        html: '请稍候，正在生成Word文档...',
        allowOutsideClick: false,
        didOpen: () => {
            Swal.showLoading();
        }
    });
    
    // 构建请求URL
    const params = new URLSearchParams({
        student_ids: studentIds.join(','),
        export_type: exportType,
        file_format: fileFormat
    });
    
    // 使用fetch下载文件
    fetch(`/teacher/exams/${examId}/export-student-papers?${params}`)
        .then(response => {
            if (!response.ok) {
                throw new Error('导出失败');
            }
            return response.blob();
        })
        .then(blob => {
            // 创建下载链接
            const url = window.URL.createObjectURL(blob);
            const a = document.createElement('a');
            a.style.display = 'none';
            a.href = url;
            
            // 设置文件名
            const timestamp = new Date().toISOString().replace(/[:.]/g, '-').substring(0, 19);
            const filename = fileFormat === 'single' 
                ? `考试答卷_${examId}_${timestamp}.docx`
                : `考试答卷_${examId}_${timestamp}.zip`;
            
            a.download = filename;
            document.body.appendChild(a);
            a.click();
            
            // 清理
            window.URL.revokeObjectURL(url);
            document.body.removeChild(a);
            
            Swal.fire({
                icon: 'success',
                title: '导出成功',
                text: `已导出 ${studentIds.length} 份答卷`
            });
        })
        .catch(error => {
            console.error('Export error:', error);
            Swal.fire({
                icon: 'error',
                title: '导出失败',
                text: '导出过程中发生错误，请重试'
            });
        });
}

// 执行批量操作
function performBatchOperation(operation, studentIds, operationName) {
    const btn = (typeof event !== 'undefined' && event && event.target) ? event.target.closest('button') : null;
    if (btn) {
        btn.disabled = true;
        btn.innerHTML = '<span class="spinner-border spinner-border-sm"></span> 处理中...';
    }
    
    fetch(`/teacher/exams/${examId}/${operation}`, {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
        },
        body: JSON.stringify({
            student_ids: studentIds
        })
    })
    .then(response => response.json())
    .then(data => {
        if (data.success) {
            alert(`${operationName}成功: ${data.message}`);
            loadStudentSubmissions(); // 重新加载数据
            clearSelection(); // 清空选择
        } else {
            alert(`${operationName}失败: ${data.message}`);
        }
    })
    .catch(error => {
        console.error('Error:', error);
        alert(`${operationName}失败，请重试`);
    })
    .finally(() => {
        if (btn) {
            btn.disabled = false;
            btn.innerHTML = btn.querySelector('i').outerHTML + ' ' + operationName;
        }
    });
}

// ===== 筛选和排序功能 =====

// 初始化筛选器选项
function initializeFilters() {
    const colleges = [...new Set(studentsData.map(s => s.college).filter(c => c))];
    const majors = [...new Set(studentsData.map(s => s.major).filter(m => m))];
    const classes = [...new Set(studentsData.map(s => s.class_name).filter(c => c))];
    
    populateSelect('filter-college', colleges);
    populateSelect('filter-major', majors);
    populateSelect('filter-class', classes);
}

// 填充选择框
function populateSelect(selectId, options) {
    const select = document.getElementById(selectId);
    const defaultOption = select.querySelector('option[value=""]');
    
    // 清除现有选项，保留默认选项
    select.innerHTML = '';
    select.appendChild(defaultOption);
    
    // 添加排序后的选项
    options.sort().forEach(option => {
        const optionElement = document.createElement('option');
        optionElement.value = option;
        optionElement.textContent = option;
        select.appendChild(optionElement);
    });
}

// 应用筛选和排序
function applyFilters() {
    const filters = {
        college: document.getElementById('filter-college').value,
        major: document.getElementById('filter-major').value,
        class_name: document.getElementById('filter-class').value,
        status: document.getElementById('filter-status').value,
        search: document.getElementById('search-input').value.toLowerCase()
    };
    
    const sortBy = document.getElementById('sort-by').value;
    const sortOrder = document.querySelector('input[name="sort-order"]:checked').value;
    
    // 筛选数据
    filteredStudentsData = studentsData.filter(student => {
        // 学院筛选
        if (filters.college && student.college !== filters.college) {
            return false;
        }
        
        // 专业筛选
        if (filters.major && student.major !== filters.major) {
            return false;
        }
        
        // 班级筛选
        if (filters.class_name && student.class_name !== filters.class_name) {
            return false;
        }
        
        // 状态筛选
        if (filters.status && student.status !== filters.status) {
            return false;
        }
        
        // 搜索筛选（学号和姓名）
        if (filters.search) {
            const searchMatch = student.student_number.toLowerCase().includes(filters.search) ||
                              student.student_name.toLowerCase().includes(filters.search);
            if (!searchMatch) {
                return false;
            }
        }
        
        return true;
    });
    
    // 排序数据
    filteredStudentsData.sort((a, b) => {
        let aValue = a[sortBy];
        let bValue = b[sortBy];
        
        // 处理特殊字段
        if (sortBy === 'score') {
            aValue = a.is_completed ? (a.score || 0) : -1;
            bValue = b.is_completed ? (b.score || 0) : -1;
        } else if (sortBy === 'start_time' || sortBy === 'end_time') {
            aValue = aValue ? new Date(aValue) : new Date(0);
            bValue = bValue ? new Date(bValue) : new Date(0);
        } else if (typeof aValue === 'string') {
            aValue = aValue.toLowerCase();
            bValue = bValue.toLowerCase();
        }
        
        // 排序逻辑
        let comparison = 0;
        if (aValue < bValue) {
            comparison = -1;
        } else if (aValue > bValue) {
            comparison = 1;
        }
        
        return sortOrder === 'desc' ? -comparison : comparison;
    });
    
    // 显示筛选后的数据
    displayStudents(filteredStudentsData);
    updateFilterStats();
    clearSelection(); // 清空之前的选择
}

// 清除所有筛选
function clearFilters() {
    document.getElementById('filter-college').value = '';
    document.getElementById('filter-major').value = '';
    document.getElementById('filter-class').value = '';
    document.getElementById('filter-status').value = '';
    document.getElementById('search-input').value = '';
    document.getElementById('sort-by').value = 'student_number';
    document.getElementById('sort-asc').checked = true;
    applyFilters();
}

// 更新筛选统计信息
function updateFilterStats() {
    const total = studentsData.length;
    const filtered = filteredStudentsData.length;
    
    document.getElementById('filter-stats').textContent = `显示 ${filtered} / ${total} 名学生`;
    
    // 状态统计
    const statusCounts = {
        completed: 0,
        in_progress: 0,
        not_started: 0
    };
    
    filteredStudentsData.forEach(student => {
        statusCounts[student.status]++;
    });
    
    const statusStats = [
        `已完成: ${statusCounts.completed}`,
        `进行中: ${statusCounts.in_progress}`,
        `未开始: ${statusCounts.not_started}`
    ].join(' | ');
    
    document.getElementById('status-stats').textContent = statusStats;
}

// 重写选择功能以适应筛选
function selectAll() {
    document.querySelectorAll('.student-checkbox').forEach(cb => {
        cb.checked = true;
    });
    updateSelection();
}

function clearSelection() {
    document.querySelectorAll('.student-checkbox').forEach(cb => {
        cb.checked = false;
    });
    updateSelection();
}

function toggleSelectAll() {
    const selectAllCb = document.getElementById('select-all-checkbox');
    document.querySelectorAll('.student-checkbox').forEach(cb => {
        cb.checked = selectAllCb.checked;
    });
    updateSelection();
}

function updateSelection() {
    const selectedCheckboxes = document.querySelectorAll('.student-checkbox:checked');
    const count = selectedCheckboxes.length;
    
    // 更新选择计数显示
    document.getElementById('selected-count').textContent = `已选择: ${count}`;
    
    // 获取选中学生的状态
    const selectedStudents = Array.from(selectedCheckboxes).map(cb => {
        const row = cb.closest('tr');
        const studentId = parseInt(cb.value);
        const statusBadge = row.querySelector('.badge');
        const status = statusBadge ? statusBadge.textContent.trim() : '';
        return { studentId, status };
    });
    
    // 根据选中学生的状态启用/禁用按钮
    const hasNotStarted = selectedStudents.some(s => s.status === '未开始');
    const hasInProgress = selectedStudents.some(s => s.status === '进行中');
    const hasCompleted = selectedStudents.some(s => s.status === '已完成');
    
    // 开始考试按钮：只有选中未开始的学生时才启用
    document.getElementById('start-exam-btn').disabled = !hasNotStarted || count === 0;
    
    // 强制提交按钮：只有选中进行中的学生时才启用
    document.getElementById('force-submit-btn').disabled = !hasInProgress || count === 0;
    
    // 允许继续按钮：只有选中已完成的学生时才启用
    document.getElementById('allow-continue-btn').disabled = !hasCompleted || count === 0;
    
    // 清除记录按钮：选中已完成或进行中的学生时启用
    document.getElementById('clear-progress-btn').disabled = !(hasCompleted || hasInProgress) || count === 0;
    const autoFillBtn = document.getElementById('auto-fill-blanks-btn');
    if (autoFillBtn) {
        autoFillBtn.disabled = (!hasCompleted && !hasInProgress) || count === 0;
    }
    const testFillBtn = document.getElementById('test-fill-correct-btn');
    if (testFillBtn) {
        testFillBtn.disabled = count === 0;
    }
    const testPerturbBtn = document.getElementById('test-perturb-btn');
    if (testPerturbBtn) {
        testPerturbBtn.disabled = count === 0;
    }
    const syncExamBtn = document.getElementById('sync-exam-btn');
    if (syncExamBtn) {
        syncExamBtn.disabled = count === 0;
    }
    const forceRefreshBtn = document.getElementById('force-refresh-btn');
    if (forceRefreshBtn) {
        forceRefreshBtn.disabled = count === 0;
    }
    
    // 更新批量操作按钮状态
    const hasSelection = count > 0;
    document.getElementById('force-submit-btn').disabled = !hasSelection;
    document.getElementById('allow-continue-btn').disabled = !hasSelection;
    document.getElementById('clear-progress-btn').disabled = !hasSelection;
    document.getElementById('export-papers-btn').disabled = !hasSelection;
    
    // 更新全选复选框状态
    const visibleCheckboxes = document.querySelectorAll('.student-checkbox');
    const selectAllCb = document.getElementById('select-all-checkbox');
    selectAllCb.checked = count > 0 && count === visibleCheckboxes.length;
    selectAllCb.indeterminate = count > 0 && count < visibleCheckboxes.length;
}
</script>
{% endblock %}