import { getSystemDbPath } from './path.js';
import { executeWithRetry } from './utils.js';
import { getDbConnection } from './index.js';

/**
 * 添加新题干及相关数据
 * @param {Object} questionData - 题干数据
 * @param {string} questionData.question_type - 题型代码
 * @param {string} questionData.question_description - 题干描述
 * @param {Array} questionData.images - 图片数据数组
 * @param {Array} questionData.datasets - 数据集数据数组
 * @returns {Promise<number>} 新创建的题干ID
 */
async function addQuestion(questionData) {
  const { question_type, question_description, images = [], datasets = [] } = questionData;

  const db = await getDbConnection(getSystemDbPath());
  return executeWithRetry(db, async () => {
    // 开始事务
    await db.runAsync('BEGIN TRANSACTION');

    try {
      // 1. 插入题干基本信息
      const questionResult = await db.runAsync(
        'INSERT INTO questions (question_type, question_name, question_description, created_at, updated_at) VALUES (?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)',
        [question_type, '', question_description]
      );

      const questionId = questionResult.lastID;

      // 2. 插入图片数据
      if (images.length > 0) {
        for (const image of images) {
          await db.runAsync(
            'INSERT INTO question_images (question_id, image_name, image_base64, created_at, updated_at) VALUES (?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)',
            [questionId, image.image || 'image', image.base64]
          );
        }
      }

      // 3. 插入数据集数据
      if (datasets.length > 0) {
        for (const dataset of datasets) {
          await db.runAsync(
            'INSERT INTO question_datasets (question_id, dataset_name, dataset_data, created_at, updated_at) VALUES (?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)',
            [questionId, dataset.name || 'dataset',dataset.content]
          );
        }
      }

      // 提交事务
      await db.runAsync('COMMIT');
      return questionId;
    } catch (error) {
      // 回滚事务
      await db.runAsync('ROLLBACK');
      throw error;
    }
  });
}

/**
 * 获取所有题干
 * @returns {Promise<Array>} 题干列表
 */
async function getAllQuestions() {
  const db = await getDbConnection(getSystemDbPath());
  return executeWithRetry(db, async () => {
    return await db.allAsync('SELECT * FROM questions ORDER BY id DESC');
  });
}

/**
 * 根据ID获取题干详情
 * @param {number} id - 题干ID
 * @returns {Promise<Object>} 题干详情
 */
async function getQuestionById(id) {
  const db = await getDbConnection(getSystemDbPath());
  return executeWithRetry(db, async () => {
    return await db.getAsync('SELECT * FROM questions WHERE id = ?', [id]);
  });
}

/**
 * 更新题干信息
 * @param {number} id - 题干ID
 * @param {Object} questionData - 题干数据
 * @returns {Promise<boolean>} 是否更新成功
 */
async function updateQuestion(id, questionData) {
  const { question_type, question_description } = questionData;
  const db = await getDbConnection(getSystemDbPath());
  return executeWithRetry(db, async () => {
    const result = await db.runAsync(
      'UPDATE questions SET question_type = ?, question_description = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?',
      [question_type, question_description, id]
    );
    return result.changes > 0;
  });
}

/**
 * 删除题干
 * @param {number} id - 题干ID
 * @returns {Promise<boolean>} 是否删除成功
 */
async function deleteQuestion(id) {
  const db = await getDbConnection(getSystemDbPath());
  return executeWithRetry(db, async () => {
    // 开始事务
    await db.runAsync('BEGIN TRANSACTION');

    try {
      // 先删除关联数据
      await db.runAsync('DELETE FROM question_images WHERE question_id = ?', [id]);
      await db.runAsync('DELETE FROM question_datasets WHERE question_id = ?', [id]);

      // 删除关联的试题数据
      await db.runAsync('DELETE FROM question_choices WHERE question_id = ?', [id]);
      await db.runAsync('DELETE FROM question_fill_blanks WHERE question_id = ?', [id]);
      await db.runAsync('DELETE FROM question_fill_table WHERE question_id = ?', [id]);
      await db.runAsync('DELETE FROM question_fill_table_blanks WHERE question_id = ?', [id]);
      await db.runAsync('DELETE FROM question_judge WHERE question_id = ?', [id]);
      await db.runAsync('DELETE FROM question_short WHERE question_id = ?', [id]);

      // 再删除题干
      const result = await db.runAsync('DELETE FROM questions WHERE id = ?', [id]);

      // 提交事务
      await db.runAsync('COMMIT');
      return result.changes > 0;
    } catch (error) {
      // 回滚事务
      await db.runAsync('ROLLBACK');
      throw error;
    }
  });
}

/**
 * 获取所有题干及其关联信息
 * @returns {Promise<Array>} 包含关联信息的题干列表
 */
async function getAllQuestionsWithRelations() {
  const db = await getDbConnection(getSystemDbPath());
  return executeWithRetry(db, async () => {
    // 1. 查询所有题干基本信息及关联的题型名称
    const questions = await db.allAsync(`
      SELECT q.*, di.item_name as question_type_name
      FROM questions q
      LEFT JOIN dict_items di ON q.question_type = di.item_code AND di.type_code = 'question_type'
      ORDER BY q.id DESC
    `);

    // 2. 为每个题干查询关联的图片、数据集和特定类型的问题数据
    for (const question of questions) {
      // 查询关联的图片
      const images = await db.allAsync(
        'SELECT * FROM question_images WHERE question_id = ?',
        [question.id]
      );
      question.images = images;

      // 查询关联的数据集
      const datasets = await db.allAsync(
        'SELECT * FROM question_datasets WHERE question_id = ?',
        [question.id]
      );
      datasets.forEach(dataset => {
        try {
          dataset.dataset_data = JSON.parse(dataset.dataset_data);
        } catch (e) {
          console.error('解析数据集失败:', e);
          dataset.dataset_data = null;
        }
      });
      question.datasets = datasets;

      // 根据question_type关联不同的问题表
      switch (question.question_type) {
        case 'choice':
          // 关联选择题表
          question.choices = await db.allAsync(
            'SELECT * FROM question_choices WHERE question_id = ?',
            [question.id]
          );
          break;
        case 'fill_blank':
          // 关联填空题表
          question.fillBlanks = await db.allAsync(
            'SELECT * FROM question_fill_blanks WHERE question_id = ?',
            [question.id]
          );
          break;
        case 'fill_table':
          // 关联表格填空题表和表格填空项表
          question.fillTables = await db.allAsync(
            'SELECT * FROM question_fill_table WHERE question_id = ?',
            [question.id]
          );

          // 对每个表格查询其填空项
          for (let table of question.fillTables) {
            table.blanks = await db.allAsync(
              'SELECT * FROM question_fill_table_blanks WHERE table_id = ?',
              [table.id]
            );
          }
          break;
        case 'true_false':
          // 关联判断题表
          question.judges = await db.allAsync(
            'SELECT * FROM question_judge WHERE question_id = ?',
            [question.id]
          );
          break;
        case 'short_answer':
        case 'analysis':
        case 'essay':
          // 关联简答题表
          question.shorts = await db.allAsync(
            'SELECT * FROM question_short WHERE question_id = ?',
            [question.id]
          );
          break;
        default:
          // 未知题型，不关联任何表
          break;
      }
    }

    return questions;
  });
}

/**
 * 更新题干描述
 * @param {number} id - 题干ID
 * @param {string} questionDescription - 新的题干描述
 * @returns {Promise<boolean>} 是否更新成功
 */
async function updateQuestionDescription(id, questionDescription) {
  const db = await getDbConnection(getSystemDbPath());
  return executeWithRetry(db, async () => {
    const result = await db.runAsync(
      'UPDATE questions SET question_description = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?',
      [questionDescription, id]
    );
    return result.changes > 0;
  });
}

/**
 * 添加选择题问题
 * @param {Object} choiceData - 选择题数据
 * @param {number} choiceData.question_id - 题干ID
 * @param {string} choiceData.choice_description - 问题描述
 * @param {string} choiceData.choice_type - 题型(single/multiple)
 * @param {Array} choiceData.choice_options - 候选项数组
 * @param {Array} choiceData.correct_answers - 正确答案序号数组
 * @returns {Promise<number>} 新创建的选择题ID
 */
async function addChoiceQuestion(choiceData) {
  const { question_id, choice_description, choice_type, score, choice_options, correct_answers } = choiceData;

  const db = await getDbConnection(getSystemDbPath());
  return executeWithRetry(db, async () => {
    const result = await db.runAsync(
      'INSERT INTO question_choices (question_id, choice_description, choice_type, score, choice_options, correct_answers, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)',
      [question_id, choice_description, choice_type, score, JSON.stringify(choice_options), JSON.stringify(correct_answers)]
    );
    return result.lastID;
  });
}

/**
 * 添加选择题问题
 * @param {number} id - 选择题ID
 * @param {Object} choiceData - 选择题数据
 * @returns {Promise<boolean>} 是否更新成功
 */
async function updateChoiceQuestion(id, choiceData) {
  const { choice_description, choice_type, score, choice_options, correct_answers } = choiceData;

  const db = await getDbConnection(getSystemDbPath());
  return executeWithRetry(db, async () => {
    const result = await db.runAsync(
      'UPDATE question_choices SET choice_description = ?, choice_type = ?, score = ?, choice_options = ?, correct_answers = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?',
      [choice_description, choice_type, score, JSON.stringify(choice_options), JSON.stringify(correct_answers), id]
    );
    return result.changes > 0;
  });
}

/**
 * 添加填空题问题
 * @param {Object} fillBlankData - 填空题数据
 * @param {number} fillBlankData.question_id - 题干ID
 * @param {string} fillBlankData.blank_description - 问题描述
 * @param {number} fillBlankData.blank_count - 空白数量
 * @param {Array} fillBlankData.correct_answers - 正确答案数组
 * @param {number} fillBlankData.score - 分值
 * @returns {Promise<number>} 新创建的填空题ID
 */
async function addFillBlankQuestion(fillBlankData) {
  const { question_id, blank_description, blank_count, correct_answers, score } = fillBlankData;

  const db = await getDbConnection(getSystemDbPath());
  return executeWithRetry(db, async () => {
    const result = await db.runAsync(
      'INSERT INTO question_fill_blanks (question_id, blank_description, blank_count, correct_answers, score, created_at, updated_at) VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)',
      [question_id, blank_description, blank_count, JSON.stringify(correct_answers), score]
    );
    return result.lastID;
  });
}

/**
 * 更新填空题问题
 * @param {number} id - 填空题ID
 * @param {Object} fillBlankData - 填空题数据
 * @returns {Promise<boolean>} 是否更新成功
 */
async function updateFillBlankQuestion(id, fillBlankData) {
  const { blank_description, blank_count, correct_answers, score } = fillBlankData;

  const db = await getDbConnection(getSystemDbPath());
  return executeWithRetry(db, async () => {
    const result = await db.runAsync(
      'UPDATE question_fill_blanks SET blank_description = ?, blank_count = ?, correct_answers = ?, score = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?',
      [blank_description, blank_count, JSON.stringify(correct_answers), score, id]
    );
    return result.changes > 0;
  });
}

/**
 * 删除填空题问题
 * @param {number} id - 填空题ID
 * @returns {Promise<boolean>} 是否删除成功
 */
async function deleteFillBlankQuestion(id) {
  const db = await getDbConnection(getSystemDbPath());
  return executeWithRetry(db, async () => {
    const result = await db.runAsync('DELETE FROM question_fill_blanks WHERE id = ?', [id]);
    return result.changes > 0;
  });
}

/**
 * 根据题干ID查询填空题问题
 * @param {number} questionId - 题干ID
 * @returns {Promise<Array>} 填空题列表
 */
async function getFillBlankQuestionsByQuestionId(questionId) {
  const db = await getDbConnection(getSystemDbPath());
  return executeWithRetry(db, async () => {
    const questions = await db.allAsync('SELECT * FROM question_fill_blanks WHERE question_id = ?', [questionId]);
    // 解析correct_answers为数组
    questions.forEach(question => {
      try {
        question.correct_answers = JSON.parse(question.correct_answers);
      } catch (e) {
        console.error('解析填空题答案失败:', e);
        question.correct_answers = [];
      }
    });
    return questions;
  });
}

/**
 * 查询试题总数和总分
 * @returns {Promise<{totalQuestions: number, totalScore: number}>} 包含试题总数和总分的对象
 */
async function getQuestionsCountAndScore() {
  const db = await getDbConnection(getSystemDbPath());
  return executeWithRetry(db, async () => {
    // 查询选择题总数和总分
    const choiceResult = await db.getAsync(`
      SELECT COUNT(*) as count, SUM(qc.score) as score
      FROM questions q
      LEFT JOIN question_choices qc ON q.id = qc.question_id
      WHERE q.question_type = 'choice'
    `);

    // 查询填空题总数和总分
    const fillBlankResult = await db.getAsync(`
      SELECT COUNT(*) as count, SUM(qfb.score) as score
      FROM questions q
      LEFT JOIN question_fill_blanks qfb ON q.id = qfb.question_id
      WHERE q.question_type = 'fill_blank'
    `);

    // 计算总题数和总分
    const totalQuestions = (choiceResult.count || 0) + (fillBlankResult.count || 0);
    const totalScore = (choiceResult.score || 0) + (fillBlankResult.score || 0);

    return {
      totalQuestions,
      totalScore
    };
  });
}

export {
  addQuestion,
  getAllQuestions,
  getQuestionById,
  updateQuestion,
  deleteQuestion,
  getAllQuestionsWithRelations,
  updateQuestionDescription,
  addChoiceQuestion,
  updateChoiceQuestion,
  addFillBlankQuestion,
  updateFillBlankQuestion,
  deleteFillBlankQuestion,
  getFillBlankQuestionsByQuestionId,
  getQuestionsCountAndScore
};