// 导入必要的模块和函数
import { getSystemDbPath, getUserDbPath } from './path.js';
import { getDbConnection } from './index.js';
import { batchInsert } from './utils.js';

/**
 * 生成考生试卷
 * @param {Object} examineeData - 考生数据
 * @param {number} examDuration - 考试时长(分钟)
 * @returns {Promise<Object>} - 包含试卷ID和状态的对象
 */
// 变更函数入参，从examDuration改为examData
export async function generateExamineePaper(examineeData, examData) {
  try {
    // 1. 获取数据库连接
    const systemDb = await getDbConnection(getSystemDbPath());
    const userDb = await getDbConnection(getUserDbPath());

    // 2. 处理考生数据，将空值转换为空字符串
    console.log('开始处理考生数据...');
    const processedExamineeData = {
      id: examineeData.id,
      examinee_name: examineeData.examinee_name || '',
      examinee_gender: examineeData.examinee_gender || '',
      examinee_unit: examineeData.examinee_unit || '',
      written_exam_room: examineeData.written_exam_room || '',
      written_exam_seat: examineeData.written_exam_seat || '',
      computer_exam_room: examineeData.computer_exam_room || '',
      computer_exam_seat: examineeData.computer_exam_seat || '',
      examinee_id_card: examineeData.examinee_id_card || '',
      examinee_admission_ticket: examineeData.examinee_admission_ticket || ''
    };

    // 3. 在user库中添加考生数据
    console.log('开始添加考生数据...');
    const examineeResult = await userDb.runAsync(
      `INSERT INTO examinee (
        id, examinee_name, examinee_gender, examinee_unit,
        written_exam_room, written_exam_seat, computer_exam_room,
        computer_exam_seat, examinee_id_card, examinee_admission_ticket, created_at
      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)`,
      [
        processedExamineeData.id,
        processedExamineeData.examinee_name,
        processedExamineeData.examinee_gender,
        processedExamineeData.examinee_unit,
        processedExamineeData.written_exam_room,
        processedExamineeData.written_exam_seat,
        processedExamineeData.computer_exam_room,
        processedExamineeData.computer_exam_seat,
        processedExamineeData.examinee_id_card,
        processedExamineeData.examinee_admission_ticket
      ]
    );
    const examineeId = examineeResult.lastID || processedExamineeData.id;
    console.log(`成功添加考生数据，ID: ${examineeId}`);

    // 3. 生成examinee_papers记录
    console.log('开始生成试卷记录...');
    // 使用examData中的exam_minutes和exam_minutes_min
    const paperResult = await userDb.runAsync(
      `INSERT INTO examinee_papers (
        examinee_id, paper_minutes, paper_minuts_min, paper_status
      ) VALUES (?, ?, ?, ?)`,
      [examineeId, examData.exam_minutes, examData.exam_minutes_min, 0] // 0表示未开始
    );
    const paperId = paperResult.lastID;
    console.log(`成功生成试卷记录，ID: ${paperId}`);

    // 4. 从system库获取所有questions记录
    console.log('开始获取系统题库...');
    const systemQuestions = await systemDb.allAsync('SELECT * FROM questions');
    console.log(`成功获取 ${systemQuestions.length} 道题目`);

    // 打乱题目顺序
    const shuffledQuestions = [...systemQuestions].sort(() => Math.random() - 0.5);

    // 5. 准备paper_questions数据
    console.log('开始准备试卷题目数据...');
    const paperQuestionsData = shuffledQuestions.map(question => ({
      examinee_id: examineeId,
      paper_id: paperId,
      question_type: question.question_type,
      question_name: question.question_name,
      question_description: question.question_description,
      created_at: new Date().toISOString()
    }));

    // 创建question_id映射关系（system_id -> user_id）
    const questionIdMap = new Map();

    // 6. 插入paper_questions数据并记录映射关系
    console.log('开始插入试卷题目数据...');
    for (let i = 0; i < paperQuestionsData.length; i++) {
      const result = await userDb.runAsync(
        `INSERT INTO paper_questions (
          examinee_id, paper_id, question_type,
          question_name, question_description, created_at
        ) VALUES (?, ?, ?, ?, ?, ?)`,
        [
          paperQuestionsData[i].examinee_id,
          paperQuestionsData[i].paper_id,
          paperQuestionsData[i].question_type,
          paperQuestionsData[i].question_name,
          paperQuestionsData[i].question_description,
          paperQuestionsData[i].created_at
        ]
      );
      questionIdMap.set(systemQuestions[i].id, result.lastID);
    }
    console.log(`成功插入 ${paperQuestionsData.length} 条试卷题目数据`);

    // 7. 处理question_datasets表
    console.log('开始处理数据集...');
    const systemDatasets = await systemDb.allAsync('SELECT * FROM question_datasets');
    const userDatasets = systemDatasets
      .filter(dataset => questionIdMap.has(dataset.question_id))
      .map(dataset => ({
        question_id: questionIdMap.get(dataset.question_id),
        dataset_name: dataset.dataset_name,
        dataset_data: dataset.dataset_data,
        created_at: new Date().toISOString()
      }));
    if (userDatasets.length > 0) {
      await batchInsert(userDb, 'question_datasets', userDatasets);
    }
    console.log(`成功处理 ${userDatasets.length} 个数据集`);

    // 8. 处理question_images表
    console.log('开始处理图片...');
    const systemImages = await systemDb.allAsync('SELECT * FROM question_images');
    const userImages = systemImages
      .filter(image => questionIdMap.has(image.question_id))
      .map(image => ({
        question_id: questionIdMap.get(image.question_id),
        image_name: image.image_name,
        image_base64: image.image_base64,
        created_at: new Date().toISOString(),
        updated_at: new Date().toISOString()
      }));
    if (userImages.length > 0) {
      await batchInsert(userDb, 'question_images', userImages);
    }
    console.log(`成功处理 ${userImages.length} 张图片`);

    // 9. 处理question_choices表
    console.log('开始处理选择题...');
    const systemChoices = await systemDb.allAsync('SELECT * FROM question_choices');
    let userChoices = systemChoices
      .filter(choice => questionIdMap.has(choice.question_id))
      .map(choice => {
        // 打乱选项顺序
        const options = JSON.parse(choice.choice_options);
        const shuffledOptions = [...options].sort(() => Math.random() - 0.5);

        return {
          question_id: questionIdMap.get(choice.question_id),
          choice_description: choice.choice_description,
          choice_type: choice.choice_type,
          choice_options: JSON.stringify(shuffledOptions),
          correct_answers: choice.correct_answers,
          examinee_answers: '',
          score: choice.score,
          score_real: 0,
          created_at: new Date().toISOString(),
          updated_at: new Date().toISOString()
        };
      });

    // 打乱选择题顺序
    userChoices = userChoices.sort(() => Math.random() - 0.5);

    if (userChoices.length > 0) {
      await batchInsert(userDb, 'question_choices', userChoices);
    }
    console.log(`成功处理 ${userChoices.length} 道选择题`);

    // 10. 处理question_fill_blanks表
    console.log('开始处理填空题...');
    const systemFillBlanks = await systemDb.allAsync('SELECT * FROM question_fill_blanks');
    let userFillBlanks = systemFillBlanks
      .filter(blank => questionIdMap.has(blank.question_id))
      .map(blank => ({
        question_id: questionIdMap.get(blank.question_id),
        blank_description: blank.blank_description,
        blank_count: blank.blank_count,
        correct_answers: blank.correct_answers,
        examinee_answers: '',
        score: blank.score,
        score_real: 0,
        created_at: new Date().toISOString(),
        updated_at: new Date().toISOString()
      }));

    // 打乱填空题顺序
    userFillBlanks = userFillBlanks.sort(() => Math.random() - 0.5);

    if (userFillBlanks.length > 0) {
      await batchInsert(userDb, 'question_fill_blanks', userFillBlanks);
    }
    console.log(`成功处理 ${userFillBlanks.length} 道填空题`);

    // 返回成功结果
    return {
      success: true,
      paperId,
      examineeId,
      message: '试卷生成成功'
    };
  } catch (error) {
    console.error('生成试卷失败:', error);
    return {
      success: false,
      message: `生成试卷失败: ${error.message}`
    };
  }
}