// ===================== 工具函数 =====================

/**
 * 节次与周次合并去重函数
 * @param {Array<Object>} courses 原始解析课程数组
 * @returns {Array<Object>} 合并去重后的课程数组
 */
function mergeAndDistinctCourses(courses) {
    if (!Array.isArray(courses) || courses.length <= 1) return courses;

    const list = courses.map(c => ({
        ...c,
        name: c.name || '',
        teacher: c.teacher || '',
        position: c.position || '',
        weeks: Array.isArray(c.weeks) ? [...c.weeks].sort((a, b) => a - b) : []
    }));

    list.sort((a, b) => {
        return a.name.localeCompare(b.name) ||
               a.teacher.localeCompare(b.teacher) ||
               a.position.localeCompare(b.position) ||
               (a.day || 0) - (b.day || 0) ||
               a.weeks.join(',').localeCompare(b.weeks.join(',')) ||
               (a.startSection || 0) - (b.startSection || 0);
    });

    const step1Merged = [];
    let current = list[0];

    for (let i = 1; i < list.length; i++) {
        const next = list[i];

        const isSameCourseAndWeeks =
            current.name === next.name &&
            current.teacher === next.teacher &&
            current.position === next.position &&
            current.day === next.day &&
            current.weeks.join(',') === next.weeks.join(',');

        const isContinuous = current.endSection + 1 === next.startSection;
        const isDuplicate = current.startSection === next.startSection && current.endSection === next.endSection;

        if (isSameCourseAndWeeks && isContinuous) {
            current.endSection = next.endSection;
        } else if (isSameCourseAndWeeks && isDuplicate) {
            continue;
        } else {
            step1Merged.push(current);
            current = next;
        }
    }
    step1Merged.push(current);

    step1Merged.sort((a, b) => {
        return a.name.localeCompare(b.name) ||
               a.teacher.localeCompare(b.teacher) ||
               a.position.localeCompare(b.position) ||
               (a.day || 0) - (b.day || 0) ||
               (a.startSection || 0) - (b.startSection || 0) ||
               (a.endSection || 0) - (b.endSection || 0);
    });

    const step2Merged = [];
    let cur = step1Merged[0];

    for (let i = 1; i < step1Merged.length; i++) {
        const nxt = step1Merged[i];

        const isSameCourseAndSection =
            cur.name === nxt.name &&
            cur.teacher === nxt.teacher &&
            cur.position === nxt.position &&
            cur.day === nxt.day &&
            cur.startSection === nxt.startSection &&
            cur.endSection === nxt.endSection;

        if (isSameCourseAndSection) {
            cur.weeks = Array.from(new Set([...cur.weeks, ...nxt.weeks])).sort((a, b) => a - b);
        } else {
            step2Merged.push(cur);
            cur = nxt;
        }
    }
    step2Merged.push(cur);

    return step2Merged;
}

/**
 * 解析周次字符串，例如 "1-16周"、"1-8周,10-16周"、"1-16周(单)"、"1-16周(双)" 等。
 * @param {string} weekStr - 周次描述字符串
 * @returns {number[]} 周次数字数组（升序）
 */
function parseWeeks(weekStr) {
    if (typeof weekStr !== 'string') {
        weekStr = String(weekStr || '');
    }
    if (!weekStr) return [];

    let cleanStr = weekStr.replace(/周/g, '').replace(/\s+/g, '');
    const weeks = new Set();
    const parts = cleanStr.split(',');

    for (let rawPart of parts) {
        if (!rawPart) continue;

        // ========== 改进点 1：先判断单双标记，再提取数字 ==========
        const hasDan = /单/.test(rawPart);
        const hasShuang = /双/.test(rawPart);
        // 仅含“单”不含“双” → 单周（奇数）
        let oddOnly = hasDan && !hasShuang;
        // 仅含“双”不含“单” → 双周（偶数）
        let evenOnly = hasShuang && !hasDan;
        // 若同时包含“单”和“双”，视为不限制奇偶（每周都上）
        // 无需额外处理，因为 oddOnly 和 evenOnly 已经为 false

        // 提取片段中的数字和连字符（忽略括号、单双等非数字字符）
        const numericPart = rawPart.replace(/[^\d\-]/g, '');
        if (!numericPart) {
            console.warn(`JS: 解析周次时忽略非法片段: ${rawPart}`);
            continue;
        }

        if (!/^[\d\-]+$/.test(numericPart)) {
            console.warn(`JS: 解析周次时忽略非法片段: ${rawPart}`);
            continue;
        }

        // 解析范围或单个数字
        if (numericPart.includes('-')) {
            const [startStr, endStr] = numericPart.split('-');
            const start = Number(startStr);
            const end = Number(endStr);
            if (!isNaN(start) && !isNaN(end) && start <= end) {
                for (let w = start; w <= end; w++) {
                    if (oddOnly && w % 2 !== 1) continue;   // 单周只保留奇数
                    if (evenOnly && w % 2 !== 0) continue;   // 双周只保留偶数
                    weeks.add(w);
                }
            }
        } else {
            const w = Number(numericPart);
            if (!isNaN(w)) {
                if (oddOnly && w % 2 !== 1) continue;
                if (evenOnly && w % 2 !== 0) continue;
                weeks.add(w);
            }
        }
    }

    // 备用解析：如果正常解析为空，尝试用正则直接提取所有数字和范围
    if (weeks.size === 0) {
        // ========== 改进点 2：备用解析使用一致的奇偶判断逻辑 ==========
        const hasDanOverall = /单/.test(weekStr);
        const hasShuangOverall = /双/.test(weekStr);
        let oddOnlyOverall = hasDanOverall && !hasShuangOverall;
        let evenOnlyOverall = hasShuangOverall && !hasDanOverall;

        const rangePattern = /(\d+)\s*-\s*(\d+)/g;
        let match;
        let matched = false;
        while ((match = rangePattern.exec(weekStr)) !== null) {
            const start = Number(match[1]);
            const end = Number(match[2]);
            if (start <= end) {
                for (let w = start; w <= end; w++) {
                    if (oddOnlyOverall && w % 2 === 0) continue;   // 单周跳过偶数
                    if (evenOnlyOverall && w % 2 !== 0) continue;   // 双周跳过奇数
                    weeks.add(w);
                }
                matched = true;
            }
        }
        if (!matched) {
            const singlePattern = /(\d+)周/g;
            while ((match = singlePattern.exec(weekStr)) !== null) {
                const w = Number(match[1]);
                if (!isNaN(w)) {
                    if (oddOnlyOverall && w % 2 === 0) continue;
                    if (evenOnlyOverall && w % 2 !== 0) continue;
                    weeks.add(w);
                }
            }
        }
    }

    return Array.from(weeks).sort((a, b) => a - b);
}
/**
 * 解析 API 返回的 JSON 数据，提取课程信息。
 * 保持与旧版完全一致的课程解析行为。
 * @param {Object} jsonData - 教务系统返回的 JSON 对象
 * @returns {Array} 解析后的课程数组
 */
function parseJsonData(jsonData) {
    console.log("JS: parseJsonData 正在解析 JSON 数据...");

    if (!jsonData || !Array.isArray(jsonData.kbList)) {
        console.warn("JS: JSON 数据结构错误或缺少 kbList 字段。");
        return [];
    }

    const rawCourseList = jsonData.kbList;
    const finalCourseList = [];

    for (const rawCourse of rawCourseList) {
        // 旧版严格非空校验，包含 cdmc
        if (!rawCourse.kcmc || !rawCourse.xm || !rawCourse.cdmc ||
            !rawCourse.xqj || !rawCourse.jcs || !rawCourse.zcd) {
            continue;
        }

        const weeksArray = parseWeeks(rawCourse.zcd);
        if (weeksArray.length === 0) {
            continue;
        }

        // 旧版节次解析：整体去除“节”字，按 '-' 分割取首尾
        const jcs = String(rawCourse.jcs).replace(/节/g, '');
        const sectionParts = jcs.split('-');
        const startSection = Number(sectionParts[0]);
        const endSection = Number(sectionParts[sectionParts.length - 1]);

        const day = Number(rawCourse.xqj);

        if (isNaN(day) || isNaN(startSection) || isNaN(endSection) ||
            day < 1 || day > 7 || startSection > endSection) {
            continue;
        }

        finalCourseList.push({
            name: rawCourse.kcmc.trim(),
            teacher: rawCourse.xm.trim(),
            position: rawCourse.cdmc.trim(),
            day: day,
            startSection: startSection,
            endSection: endSection,
            weeks: weeksArray
        });
    }

    // 旧版排序规则
    finalCourseList.sort((a, b) =>
        a.day - b.day ||
        a.startSection - b.startSection ||
        a.name.localeCompare(b.name)
    );

    console.log(`JS: JSON 数据解析完成，共找到 ${finalCourseList.length} 门课程。`);
    const merged = mergeAndDistinctCourses(finalCourseList);
    window.shiguangBridge.showToast(`去重前：${finalCourseList.length} 门，去重后：${merged.length} 门`);
    return merged;
}
/**
 * 根据课程周次数组推断学期总周数。
 * @param {Array} courses - 课程数组
 * @returns {number} 推断出的最大周次，至少为1
 */
function inferTotalWeeks(courses) {
    let maxWeek = 0;
    for (const course of courses) {
        const weekNums = course.weeks;
        if (weekNums.length > 0) {
            maxWeek = Math.max(maxWeek, ...weekNums);
        }
    }
    // 返回至少1周，若无法推断则使用默认20
    return Math.max(1, maxWeek || 20);
}

/**
 * 从周次数据数组中解析第 1 周的开学日期。
 * @param {Array} weekList - 教务系统返回的周次数据数组
 * @returns {string|null} 开学日期字符串（YYYY-MM-DD），解析失败返回 null
 */
function parseSchoolStartDate(weekList) {
    if (!Array.isArray(weekList) || weekList.length === 0) {
        return null;
    }

    // 找到第 1 周
    let firstWeek = weekList.find(item => String(item.zs) === '1');

    if (!firstWeek) {
        firstWeek = weekList.find(item => Number(item.zs) === 1);
    }

    // 如果还是没有，就按周次排序，取最小周次
    if (!firstWeek) {
        const sorted = [...weekList].sort((a, b) => Number(a.zs) - Number(b.zs));
        firstWeek = sorted[0];
    }

    if (!firstWeek) {
        return null;
    }

    // 优先从 rq 字段取开始日期
    const rq = String(firstWeek.rq || '');
    const rqMatch = rq.match(/\d{4}-\d{1,2}-\d{1,2}/);
    if (rqMatch) {
        return rqMatch[0];
    }

    // 兼容从 zcrq 字段取开始日期
    const zcrq = String(firstWeek.zcrq || '');
    const zcrqMatch = zcrq.match(/\d{4}-\d{1,2}-\d{1,2}/);
    if (zcrqMatch) {
        return zcrqMatch[0];
    }

    return null;
}

/**
 * 从教务系统周次数据中提取最大周次。
 * @param {Array} weekList - 教务系统周次数据数组
 * @returns {number|null} 最大周次，解析失败返回 null
 */
function getMaxWeekFromSchoolWeekList(weekList) {
    if (!Array.isArray(weekList) || weekList.length === 0) {
        return null;
    }
    let max = 0;
    for (const item of weekList) {
        const week = Number(item.zs);
        if (!isNaN(week) && week > max) {
            max = week;
        }
    }
    return max > 0 ? max : null;
}

function getDefaultSemesterDate(academicYear, semesterIndex) {
    const year = Number(academicYear);
    if (isNaN(year)) return "2026-02-01";
    if (semesterIndex === 0) {
        return `${year}-09-01`;
    } else {
        return `${year + 1}-02-01`;
    }
}

// ===================== 全局常量 =====================

const BASE_URL = 'https://jwglxt.gpnu.edu.cn';

// ===================== 全局验证函数 =====================

/**
 * 判断一个字符串是否为有效的日期（YYYY-MM-DD），并检查日期是否真实存在。
 * @param {string} dateStr - 日期字符串
 * @returns {boolean} 是否有效
 */
function isValidDateString(dateStr) {
    if (!/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) return false;
    const [year, month, day] = dateStr.split('-').map(Number);
    if (year < 2000 || year > 2100) return false;
    if (month < 1 || month > 12) return false;
    const daysInMonth = new Date(year, month, 0).getDate();
    return day >= 1 && day <= daysInMonth;
}

/**
 * 校验学年输入：必须为四位数字，且在合理范围内（2000-2100）。
 * @param {string|null|undefined} input - 用户输入
 * @returns {string|false} 校验失败返回提示字符串，通过返回 false
 */
function validateYearInput(input) {
    console.log("JS:  validateYearInput被调用，输入: " + input);
    if (input === null || input === undefined) {
        return "请输入四位数字的学年喵~";
    }
    if (/^[0-9]{4}$/.test(input)) {
        const year = Number(input);
        if (year >= 2000 && year <= 2100) {
            return false;
        } else {
            return "学年需在 2000 到 2100 之间喵~";
        }
    } else {
        return "请输入四位数字的学年喵~";
    }
}

/**
 * 校验日期输入：允许空值，格式必须为 YYYY-MM-DD，且日期有效。
 * @param {string|null|undefined} input - 用户输入
 * @returns {string|false} 校验失败返回提示字符串，通过返回 false
 */
function validateDateInput(input) {
    if (input === null || input === undefined || input.trim() === '') {
        return false;
    }
    if (isValidDateString(input.trim())) {
        return false;
    }
    return "日期格式应为 YYYY-MM-DD，且为有效日期喵~";
}

/**
 * 校验学期总周数输入：必须为 1~30 的整数。
 * @param {string|null|undefined} input - 用户输入
 * @returns {string|false} 校验失败返回提示字符串，通过返回 false
 */
function validateWeeksInput(input) {
    if (input === null || input === undefined || input.trim() === '') {
        return "请输入学期总周数（1-30）喵~";
    }
    const num = Number(input.trim());
    if (Number.isInteger(num) && num >= 1 && num <= 30) {
        return false;
    }
    return "周数必须是 1 到 30 之间的整数喵~";
}

// ===================== 与原生交互的异步封装 =====================

/**
 * 询问用户是否退出当前导入流程。
 * @returns {Promise<boolean>} true=退出，false=留在页面
 */
async function promptUserToExit() {
    console.log("JS: 询问用户是否退出。");
    const options = ["退出", "留在页面"];
    const rawIndex = await window.shiguangBridgePromise.showSingleSelection(
        "导入流程已结束",
        JSON.stringify(options),
        0  // 默认选中“退出”
    );

    // 用户取消选择（返回 null/undefined/''）时，默认不退出
    if (rawIndex === null || rawIndex === undefined || rawIndex === '') {
        console.log("JS: 用户取消退出选择，默认留在页面。");
        return false;
    }
    const index = Number(rawIndex);
    if (isNaN(index) || index < 0 || index >= options.length) {
        console.warn("JS: 退出选择索引无效，默认留在页面。");
        return false;
    }
    return index === 0;
}

async function promptUserToStart() {
    console.log("JS: 流程开始：显示公告。");
    return await window.shiguangBridgePromise.showAlert(
        "教务系统课表导入喵~",
        "Ciallo~ 导入前请确保您已成功登录教务系统哦喵~",
        "好的"
    );
}

/**
 * 显示课程导入成功的弹窗公告。
 * @param {number} length - 导入的课程数量
 */
async function promptUserToSUCCESS(length) {
    console.log("JS: SUCCESS：显示公告。");
    return await window.shiguangBridgePromise.showAlert(
        "SUCCESS",
        `成功了喵~ 共导入 ${length} 门课程！`,
        "好的"
    );
}

const SCHOOL_START_MONTH = 8; // 默认

async function getAcademicYear() {
    const now = new Date();
    let academicYear = now.getFullYear();
    if (now.getMonth() + 1 < SCHOOL_START_MONTH) {
        academicYear -= 1;
    }
    const defaultYear = academicYear.toString();
    return await window.shiguangBridgePromise.showPrompt(
        "选择学年喵~（Auto value）",
        "请输入要导入课程的起始学年喵~:",
        defaultYear,
        "validateYearInput"
    );
}

async function selectSemester() {
    const semesters = ["第一学期", "第二学期"];
    console.log("JS: 提示用户选择学期。");
    const rawIndex = await window.shiguangBridgePromise.showSingleSelection(
        "选择学期喵~",
        JSON.stringify(semesters),
        0
    );

    if (rawIndex === null || rawIndex === undefined || rawIndex === '') {
        console.log("JS: 用户取消选择学期。");
        return null;
    }
    const index = Number(rawIndex);
    if (isNaN(index) || index < 0 || index >= semesters.length) {
        console.warn("JS: 学期索引无效，返回 null。");
        return null;
    }
    return index;
}

async function selectArea() {
    const areas = ["东/西/北校区", "白云校区", "河源校区"];
    console.log("JS: 提示用户选择校区。");
    const rawIndex = await window.shiguangBridgePromise.showSingleSelection(
        "选择校区喵~",
        JSON.stringify(areas),
        0
    );

    if (rawIndex === null || rawIndex === undefined || rawIndex === '') {
        console.log("JS: 用户取消选择校区。");
        return null;
    }
    const index = Number(rawIndex);
    if (isNaN(index) || index < 0 || index >= areas.length) {
        console.warn("JS: 校区索引无效，返回 null。");
        return null;
    }
    return index;
}

async function selectTotalWeeksSource(courseMaxWeeks, schoolMaxWeeks) {
    const options = [
        `课程最大周数（${courseMaxWeeks}周）`,
        schoolMaxWeeks ? `教务系统周数（${schoolMaxWeeks}周）` : "教务系统周数（无数据）",
        "手动输入"
    ];
    console.log("JS: 提示用户选择周数来源。");
    const rawIndex = await window.shiguangBridgePromise.showSingleSelection(
        "选择学期总周数来源喵~（已自动解析）",
        JSON.stringify(options),
        0
    );

    if (rawIndex === null || rawIndex === undefined || rawIndex === '') {
        console.log("JS: 用户取消选择周数来源。");
        return null;
    }

    const index = Number(rawIndex);
    if (isNaN(index) || index < 0 || index > 2) {
        console.warn("JS: 周数来源选择无效，默认使用课程最大周数。");
        return 0;
    }
    return index;
}

/**
 * 获取学期开始日期。
 * 优先使用传入的周次数据解析开学日期；若未传入或数据无效，则向教务系统请求。
 * 解析成功后弹出对话框让用户确认或修改，用户可留空跳过（返回 null）。
 * @param {string} academicYear - 学年（四位数字）
 * @param {number} semesterIndex - 学期索引（0 第一学期，1 第二学期）
 * @param {Array|null} [weekList=null] - 可选的周次数据数组，若提供且非空则直接使用
 * @returns {Promise<string|null>} 用户确认的日期字符串（YYYY-MM-DD），取消或留空返回 null
 */
async function getSemesterStartDate(academicYear, semesterIndex, weekList = null) {
    console.log("JS: 正在获取学期周次数据以解析开学日期...");
    let defaultDate = getDefaultSemesterDate(academicYear, semesterIndex);

    // 1. 确定要使用的周次数据来源
    let data = weekList;
    if (!Array.isArray(data) || data.length === 0) {
        // 外部没有提供有效数据，尝试从教务系统获取
        try {
            data = await fetchSchoolWeekData(academicYear, getSemesterCode(semesterIndex));
        } catch (error) {
            console.warn("JS: 获取周次数据失败，将使用动态默认日期。", error);
            window.shiguangBridge.showToast("未能获取学期周次数据，开始日期可能需要手动填写。");
            data = null; // 确保后续不会使用无效数据
        }
    }

    // 2. 解析开学日期
    if (Array.isArray(data) && data.length > 0) {
        const parsedDate = parseSchoolStartDate(data);
        if (parsedDate) {
            defaultDate = parsedDate;
            console.log(`JS: 解析到的开学日期: ${defaultDate}`);
        } else {
            console.log("JS: 未能从周次数据解析出开学日期，使用动态默认值。");
        }
    } else {
        console.log("JS: 无可用周次数据，使用动态默认值。");
    }

    // 3. 弹出对话框让用户确认或修改日期（可留空跳过）
    console.log("JS: 提示用户输入学期开始日期（可留空跳过）。");
    const input = await window.shiguangBridgePromise.showPrompt(
        "学期开始日期喵~",
        "请输入学期第一天的日期喵~（YYYY-MM-DD）（已尝试自动解析）",
        defaultDate,
        "validateDateInput"
    );

    if (input === null || input === undefined) {
        console.log("JS: 用户取消了开始日期输入，继续流程。");
        return null;
    }
    if (input.trim() === '') {
        return null;
    }
    return input.trim();
}

async function getSemesterTotalWeeks(defaultWeeks) {
    console.log(`JS: 提示用户输入学期总周数，默认值：${defaultWeeks}`);
    const input = await window.shiguangBridgePromise.showPrompt(
        "设置学期总周数喵~",
        "请输入本学期的总周数喵~（1-30）",
        String(defaultWeeks),
        "validateWeeksInput"
    );
    if (input === null || input === undefined) {
        console.log("JS: 用户取消了总周数输入，流程继续使用默认值。");
        return defaultWeeks;
    }
    const weeks = Number(input.trim());
    if (!Number.isInteger(weeks) || weeks < 1 || weeks > 30) {
        console.warn("JS: 周数输入非法，使用默认值。");
        return defaultWeeks;
    }
    return weeks;
}

async function promptImportTimeSlots() {
    console.log("JS: 询问用户是否导入预设时间段。");
    return await window.shiguangBridgePromise.showAlert(
        "导入预设时间段喵~",
        "是否导入该校区对应的预设上课时间段喵~？",
        "导入"
    );
}

// ===================== 网络请求 =====================

async function fetchCourseData(academicYear, semesterIndex) {
    const semesterCode = getSemesterCode(semesterIndex);
    const requestBody = new URLSearchParams({
        gnmkdm: 'N2151',
        xnm: academicYear,
        xqm: semesterCode,
        kzlx: 'ck',
        xsdm: '',
        kclbdm: '',
        kclxdm: ''
    }).toString();

    const targetUrls = [
        `${BASE_URL}/jwglxt/kbcx/xskbcx_cxXsgrkb.html?gnmkdm=N2151`,
    ];

    const errors = [];

    for (const url of targetUrls) {
        try {
            const response = await fetch(url, {
                method: "POST",
                headers: {
                    "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
                    "X-Requested-With": "XMLHttpRequest"
                },
                body: requestBody,
                credentials: "include"
            });

            if (!response.ok) {
                const msg = `HTTP ${response.status} ${response.statusText}`;
                errors.push(`${url} -> ${msg}`);
                console.warn(`课表数据请求失败（${msg}）：${url}`);
                continue;
            }

            const jsonText = await response.text();
            if (jsonText.includes('<html')) {
                errors.push(`${url} -> 返回登录页面，可能登录已过期`);
                console.warn(`课表数据返回登录页面，可能未登录或会话过期：${url}`);
                continue;
            }

            let data;
            try {
                data = JSON.parse(jsonText);
            } catch (parseError) {
                errors.push(`${url} -> JSON 解析失败: ${parseError.message}`);
                console.warn(`课表数据 JSON 解析失败：${url}`, parseError);
                continue;
            }

            if (!data || !Array.isArray(data.kbList)) {
                errors.push(`${url} -> 返回数据缺少 kbList 数组`);
                console.warn(`课表数据缺少 kbList 字段：${url}`, data);
                continue;
            }

            return data;
        } catch (networkError) {
            errors.push(`${url} -> 网络异常: ${networkError.message}`);
            console.warn(`课表数据网络请求异常：${url}`, networkError);
        }
    }

    const errorMessage = errors.length > 0
        ? `课表数据获取失败，尝试了 ${targetUrls.length} 个地址：\n${errors.join('\n')}`
        : '课表数据获取失败，未配置任何请求地址';
    console.error(errorMessage);
    throw new Error(errorMessage);
}

async function fetchSchoolWeekData(xnm, xqm) {
    const targetUrls = [
        `${BASE_URL}/jwglxt/kbcx/xskbcxZccx_cxZcByXnxq.html?gnmkdm=N2154`,
    ];

    const requestBody = new URLSearchParams({
        xnm: xnm,
        xqm: xqm
    }).toString();

    const errors = [];

    for (const url of targetUrls) {
        try {
            const response = await fetch(url, {
                headers: {
                    'accept': 'application/json, text/javascript, */*; q=0.01',
                    'accept-language': 'zh-CN,zh;q=0.9',
                    'content-type': 'application/x-www-form-urlencoded;charset=UTF-8',
                    'x-requested-with': 'XMLHttpRequest'
                },
                body: requestBody,
                method: 'POST',
                mode: 'cors',
                credentials: 'include'
            });

            if (!response.ok) {
                const msg = `HTTP ${response.status} ${response.statusText}`;
                errors.push(`${url} -> ${msg}`);
                console.warn(`周次数据请求失败（${msg}）：${url}`);
                continue;
            }

            const text = await response.text();
            if (text.includes('<html')) {
                errors.push(`${url} -> 返回登录页面，可能登录已过期`);
                console.warn(`周次数据返回登录页面，可能未登录或会话过期：${url}`);
                continue;
            }

            let data;
            try {
                data = JSON.parse(text);
            } catch (parseError) {
                errors.push(`${url} -> JSON 解析失败: ${parseError.message}`);
                console.warn(`周次数据 JSON 解析失败：${url}`, parseError);
                continue;
            }

            if (!Array.isArray(data)) {
                const msg = '返回数据不是数组';
                errors.push(`${url} -> ${msg}`);
                console.warn(`周次数据格式错误（期望数组）：${url}`, data);
                continue;
            }

            return data;
        } catch (networkError) {
            errors.push(`${url} -> 网络异常: ${networkError.message}`);
            console.warn(`周次数据网络请求异常：${url}`, networkError);
        }
    }

    const errorMessage = errors.length > 0
        ? `周次数据获取失败，尝试了 ${targetUrls.length} 个地址：\n${errors.join('\n')}`
        : '周次数据获取失败，未配置任何请求地址';
    console.error(errorMessage);
    throw new Error(errorMessage);
}

// ===================== 数据解析与配置构建 =====================

function buildCourseDataFromRaw(rawData, startDate) {
    console.log("JS: buildCourseDataFromRaw 开始解析原始数据...");

    if (!rawData || !Array.isArray(rawData.kbList)) {
        throw new Error('课表数据格式错误或缺少 kbList 字段');
    }

    const courses = parseJsonData(rawData);
    if (courses.length === 0) {
        throw new Error('未解析到有效课程，请检查课表数据');
    }

    const inferredWeeks = inferTotalWeeks(courses);
    const config = {
        semesterStartDate: startDate,
        semesterTotalWeeks: inferredWeeks
    };

    console.log(`JS: 解析成功，课程数：${courses.length}，推断总周数：${inferredWeeks}`);
    return { courses, config };
}

// ===================== 数据保存 =====================

async function saveCourses(parsedCourses) {
    window.shiguangBridge.showToast(`正在保存 ${parsedCourses.length} 门课程...`);
    console.log(`JS: 尝试保存 ${parsedCourses.length} 门课程...`);
    try {
        await window.shiguangBridgePromise.saveImportedCourses(JSON.stringify(parsedCourses));
        console.log("JS: 课程保存成功！");
        return true;
    } catch (error) {
        window.shiguangBridge.showToast(`课程保存失败: ${error.message}`);
        console.error('JS: Save Courses Error:', error);
        return false;
    }
}

async function importPresetTimeSlots(timeSlots) {
    console.log(`JS: 准备导入 ${timeSlots.length} 个预设时间段。`);
    if (timeSlots.length > 0) {
        window.shiguangBridge.showToast(`正在导入 ${timeSlots.length} 个预设时间段...`);
        try {
            await window.shiguangBridgePromise.savePresetTimeSlots(JSON.stringify(timeSlots));
            window.shiguangBridge.showToast("预设时间段导入成功！");
        } catch (error) {
            window.shiguangBridge.showToast("导入时间段失败: " + error.message);
            console.error('JS: Save Time Slots Error:', error);
        }
    } else {
        window.shiguangBridge.showToast("警告：时间段为空，未导入时间段信息。");
        console.warn("JS: 警告：传入时间段为空，未导入时间段信息。");
    }
}

// ===================== 三个校区的时间表 =====================

const TimeSlots_one = [
    { number: 1, startTime: "08:20", endTime: "09:00" },
    { number: 2, startTime: "09:10", endTime: "09:50" },
    { number: 3, startTime: "10:00", endTime: "10:40" },
    { number: 4, startTime: "10:50", endTime: "11:30" },
    { number: 5, startTime: "13:30", endTime: "14:10" },
    { number: 6, startTime: "14:20", endTime: "15:00" },
    { number: 7, startTime: "15:10", endTime: "15:50" },
    { number: 8, startTime: "16:00", endTime: "16:40" },
    { number: 9, startTime: "18:40", endTime: "19:20" },
    { number: 10, startTime: "19:30", endTime: "20:10" },
    { number: 11, startTime: "20:20", endTime: "21:00" }
];

const TimeSlots_two = [
    { number: 1, startTime: "08:30", endTime: "09:10" },
    { number: 2, startTime: "09:15", endTime: "09:55" },
    { number: 3, startTime: "10:05", endTime: "10:45" },
    { number: 4, startTime: "10:50", endTime: "11:30" },
    { number: 5, startTime: "13:30", endTime: "14:10" },
    { number: 6, startTime: "14:15", endTime: "14:55" },
    { number: 7, startTime: "15:05", endTime: "15:45" },
    { number: 8, startTime: "15:50", endTime: "16:30" },
    { number: 9, startTime: "18:40", endTime: "19:20" },
    { number: 10, startTime: "19:25", endTime: "20:05" },
    { number: 11, startTime: "20:10", endTime: "20:50" }
];

const TimeSlots_three = [
    { number: 1, startTime: "08:20", endTime: "09:00" },
    { number: 2, startTime: "09:10", endTime: "09:50" },
    { number: 3, startTime: "10:10", endTime: "10:50" },
    { number: 4, startTime: "11:00", endTime: "11:40" },
    { number: 5, startTime: "13:50", endTime: "14:30" },
    { number: 6, startTime: "14:40", endTime: "15:20" },
    { number: 7, startTime: "15:40", endTime: "16:20" },
    { number: 8, startTime: "16:30", endTime: "17:10" },
    { number: 9, startTime: "18:40", endTime: "19:20" },
    { number: 10, startTime: "19:30", endTime: "20:10" },
    { number: 11, startTime: "20:20", endTime: "21:00" }
];

// ===================== 索引 =====================

function getSemesterCode(semesterIndex) {
    return semesterIndex === 0 ? "3" : "12";
}

function getTimeSlotsByAreaIndex(areaIndex) {
    if (areaIndex === 0) return TimeSlots_one;
    if (areaIndex === 1) return TimeSlots_two;
    if (areaIndex === 2) return TimeSlots_three;
    return TimeSlots_one;
}

// ===================== 主流程 =====================

async function runImportFlow() {
    let shouldExit = false;          // 最终是否退出（由用户选择决定）
    let flowEnded = false;           // 标记流程是否已经走到需要询问退出的节点

    try {
        // ================= 流程开始 =================
        const alertConfirmed = await promptUserToStart();
        if (!alertConfirmed) {
            window.shiguangBridge.showToast("导入已取消。");
            console.log("JS: 用户取消了导入流程。");
            flowEnded = true;
            return; // 直接返回，但 finally 中会询问是否退出
        }

        // 获取学年
        const academicYear = await getAcademicYear();
        if (academicYear === null || academicYear === undefined) {
            window.shiguangBridge.showToast("导入已取消。");
            console.log("JS: 获取学年失败/取消，流程终止。");
            flowEnded = true;
            return;
        }
        console.log(`JS: 已选择学年: ${academicYear}`);

        // 选择学期
        const semesterIndex = await selectSemester();
        if (semesterIndex === null) {
            window.shiguangBridge.showToast("导入已取消。");
            console.log("JS: 选择学期失败/取消，流程终止。");
            flowEnded = true;
            return;
        }
        console.log(`JS: 已选择学期索引: ${semesterIndex}`);

        // 选择校区
        const areaIndex = await selectArea();
        if (areaIndex === null) {
            window.shiguangBridge.showToast("导入已取消。");
            console.log("JS: 选择校区失败/取消，流程终止。");
            flowEnded = true;
            return;
        }
        console.log(`JS: 已选择校区索引: ${areaIndex}`);

        // 获取周次数据（可选）
        let schoolWeekList = null;
        try {
            schoolWeekList = await fetchSchoolWeekData(academicYear, getSemesterCode(semesterIndex));
        } catch (error) {
            console.warn("JS: 获取周次数据失败，稍后周数来源可能缺少教务系统选项。", error);
            window.shiguangBridge.showToast("获取周次数据失败，将使用课程周数或手动输入。");
            schoolWeekList = [];
        }

        // 获取学期开始日期
        const startDate = await getSemesterStartDate(academicYear, semesterIndex, schoolWeekList);
        console.log(`JS: 学期开始日期输入结果: ${startDate}`);

        // 获取课表原始数据
        const rawData = await fetchCourseData(academicYear, semesterIndex);

        // 解析课程
        let courses, config;
        try {
            const parsedResult = buildCourseDataFromRaw(rawData, startDate);
            courses = parsedResult.courses;
            config = parsedResult.config;
        } catch (error) {
            window.shiguangBridge.showToast(error.message);
            console.error('JS: 课程解析失败:', error);
            flowEnded = true;
            return;
        }

        // 周数来源选择
        const courseMaxWeeks = config.semesterTotalWeeks;
        const schoolMaxWeeks = getMaxWeekFromSchoolWeekList(schoolWeekList);

        const weekSource = await selectTotalWeeksSource(courseMaxWeeks, schoolMaxWeeks);
        if (weekSource === null) {
            window.shiguangBridge.showToast("未选择周数来源，导入已取消。");
            console.log("JS: 用户取消周数来源选择，流程终止。");
            flowEnded = true;
            return;
        }

        let finalWeeks;
        if (weekSource === 0) {
            finalWeeks = courseMaxWeeks;
        } else if (weekSource === 1) {
            if (schoolMaxWeeks) {
                finalWeeks = schoolMaxWeeks;
            } else {
                window.shiguangBridge.showToast("教务系统周数不可用，已使用课程最大周数。");
                finalWeeks = courseMaxWeeks;
            }
        } else {
            finalWeeks = await getSemesterTotalWeeks(courseMaxWeeks);
        }
        config.semesterTotalWeeks = finalWeeks;

        // 保存课程
        const saveResult = await saveCourses(courses);
        if (!saveResult) {
            console.log("JS: 课程保存失败，流程终止。");
            flowEnded = true;
            return;
        }

        // 保存配置
        try {
            await window.shiguangBridgePromise.saveCourseConfig(JSON.stringify(config));
            window.shiguangBridge.showToast(`课表配置更新成功！总周数：${config.semesterTotalWeeks}周。`);
        } catch (error) {
            window.shiguangBridge.showToast(`课表配置保存失败: ${error.message}`);
            console.error('JS: Save Config Error:', error);
        }

        // 导入预设时间段
        const timeSlots = getTimeSlotsByAreaIndex(areaIndex);
        const shouldImportTimeSlots = await promptImportTimeSlots();
        if (shouldImportTimeSlots) {
            await importPresetTimeSlots(timeSlots);
        } else {
            console.log("JS: 用户取消导入预设时间段，跳过。");
            window.shiguangBridge.showToast("已跳过导入时间段。");
        }

        await promptUserToSUCCESS(courses.length);
        console.log("JS: 整个导入流程执行完毕并成功。");
        flowEnded = true; // 成功结束

    } catch (e) {
        console.error('JS: 导入流程异常：', e);
        try {
            window.shiguangBridge.showToast('导入失败：' + (e && e.message ? e.message : e));
        } catch (_) {}
        flowEnded = true; // 异常结束
    } finally {
        // 无论成功、失败、取消，只要流程已经结束，就询问是否退出
        if (flowEnded) {
            shouldExit = await promptUserToExit();
            if (shouldExit) {
                console.log("JS: 用户选择退出，通知原生任务结束。");
                try {
                    window.shiguangBridge.notifyTaskCompletion();
                } catch (error) {
                    console.error("JS: 调用 notifyTaskCompletion 失败:", error);
                }
            } else {
                console.log("JS: 用户选择留在页面，不通知原生。");
                // 可在此处添加刷新页面或保持现状的逻辑
                window.location.reload();
            }
        }
    }
}
runImportFlow();