creerExamen.js

import path from 'node:path';
import fs from 'node:fs/promises';
import readline from 'node:readline/promises';
import { stdin as input, stdout as output } from 'node:process';
import { discoverSujetStructure } from './chercherQuestions.js';
import { readGiftFile, parseGiftQuestion } from '../GiftParser.js';
import { colors } from '../utils/colors.js';

export function composeExamFromBlocks(blocks, options = {}) {
  function isLikelyInstructionParsed(q) {
    if (!q || !q.text) return false;
    const noAnswers = Array.isArray(q.answers) && q.answers.length === 0;
    if (!noAnswers) return false;
    const txt = (q.text || '').toLowerCase();
    const title = (q.title || '').toLowerCase();
    const keywords = ['complete', 'completez', 'complète', 'consigne', 'instruction', 'instructions', 'look carefully', 'read carefully', 'fill in', 'fill the', 'choose the', 'select the', 'complete the sentences', 'complete the text'];
    const containsKeyword = keywords.some(k => txt.includes(k) || title.includes(k));
    const tooLong = txt.length > 30;
    return containsKeyword || tooLong;
  }

  const unique = [];
  const seen = new Set();
  for (const b of blocks) {
    const key = b.trim();
    if (seen.has(key)) continue;
    let parsed = null;
    try { parsed = parseGiftQuestion(b); } catch (e) { parsed = null; }
    if (isLikelyInstructionParsed(parsed)) continue;
    unique.push(key);
    seen.add(key);
  }

  const count = unique.length;
  if (count < 15 || count > 20) {
    throw new Error(`Nombre de questions non valide: ${count} (doit être entre 15 et 20 inclus)`);
  }

  const content = unique.map(b => b.trim()).join('\n\n');
  return content;
}

export async function saveExamToDir(content, filename = null, dirName = 'examens') {
  const defaultName = `examen_${Date.now()}.gift`;
  let outName = filename && filename.trim() ? filename.trim() : defaultName;
  if (!outName.toLowerCase().endsWith('.gift')) outName += '.gift';
  const outDir = path.join(process.cwd(), dirName);
  await fs.mkdir(outDir, { recursive: true });
  const outPath = path.join(outDir, outName);
  await fs.writeFile(outPath, content, 'utf8');
  return outPath;
}

export default async function creerExamen(rl = null) {
  console.log('\n[actions] Création d\'un examen — sélection interactive (Spec_F2)');

  let ownRl = false;
  if (!rl) {
    rl = readline.createInterface({ input, output });
    ownRl = true;
  }


  try {
    const blue = colors.blue;
    const reset = colors.reset;
    const dataDir = path.join(process.cwd(), 'SujetB_data');
    const units = await discoverSujetStructure(dataDir);
    const unitKeys = Object.keys(units).sort();

    const selectedBlocks = [];
    const selectedSet = new Set();

    while (true) {
      console.log('\nUnités disponibles:');
      unitKeys.forEach((u, i) => console.log(`${i + 1}) ${u}`));

      // Prompt unité avec exemple bleu
      const unitPrompt = `\nNuméro d'unité (ou q pour terminer la création):\n${blue}(exemple: taper l'index "1" pour accéder à l'unité \"${unitKeys[0]}\")${reset} `;
      const unitChoice = await rl.question(unitPrompt);
      if (unitChoice.trim().toLowerCase() === 'q') break;
      const unitIdx = parseInt(unitChoice, 10) - 1;
      if (!(unitIdx >= 0 && unitIdx < unitKeys.length)) {
        console.log(`${colors.red}Choix d\'unité invalide.${colors.reset}`);
        continue;
      }

      const chosenUnit = unitKeys[unitIdx];
      const pages = Object.keys(units[chosenUnit]).sort();

      console.log(`\nPages disponibles pour ${chosenUnit}:`);
      pages.forEach((p, i) => console.log(`${i + 1}) ${p}`));

      // Prompt page avec exemple bleu
      let pagePrompt = '\nNuméro de page (ou q pour terminer la création): ';
      if (pages.length > 0) {
        pagePrompt += `\n${blue}(exemple: taper l'index "1" pour accéder à la page \"${pages[0]}\")${reset} `;
      }
      const pageChoice = await rl.question(pagePrompt);
      if (pageChoice.trim().toLowerCase() === 'q') break;
      const pageIdx = parseInt(pageChoice, 10) - 1;
      if (!(pageIdx >= 0 && pageIdx < pages.length)) {
        console.log(`${colors.red}Choix de page invalide.${colors.reset}`);
        continue;
      }

      const chosenPage = pages[pageIdx];
      const filesForPage = units[chosenUnit][chosenPage];

      let selectedFile;
      if (filesForPage.length === 1) {
        selectedFile = filesForPage[0];
      } else {
        console.log('\nFichiers disponibles pour cette page:');
        filesForPage.forEach((f, i) => console.log(`${i + 1}) ${f}`));
        const fileChoice = await rl.question('\nNuméro du fichier (ou q pour terminer la création): ');
        if (fileChoice.trim().toLowerCase() === 'q') break;
        const fileIdx = parseInt(fileChoice, 10) - 1;
        if (!(fileIdx >= 0 && fileIdx < filesForPage.length)) {
          console.log(`${colors.red}Choix de fichier invalide.${colors.reset}`);
          continue;
        }
        selectedFile = filesForPage[fileIdx];
      }

      const fullPath = path.join(dataDir, selectedFile);
      const blocks = readGiftFile(fullPath);
      if (!blocks || blocks.length === 0) {
        console.log(`${colors.red}Aucune question trouvée dans le fichier sélectionné.${colors.reset}`);
        continue;
      }

      const parsed = blocks.map(parseGiftQuestion);

      function isLikelyInstruction(q) {
        if (!q || !q.text) return false;
        const noAnswers = Array.isArray(q.answers) && q.answers.length === 0;
        if (!noAnswers) return false;
        const txt = (q.text || '').toLowerCase();
        const title = (q.title || '').toLowerCase();
        const keywords = ['complete', 'completez', 'complète', 'consigne', 'instruction', 'instructions', 'look carefully', 'read carefully', 'fill in', 'fill the', 'choose the', 'select the', 'complete the sentences', 'complete the text'];
        const containsKeyword = keywords.some(k => txt.includes(k) || title.includes(k));
        const tooLong = txt.length > 30;
        return containsKeyword || tooLong;
      }
      function isZeroItem(q) {
        if (!q || !q.title) return false;
        return /\b\d+\.0\b/.test(q.title);
      }

      const displayList = [];
      for (let i = 0; i < parsed.length; i++) {
        const q = parsed[i];
        if (isLikelyInstruction(q) || isZeroItem(q)) continue;
        displayList.push({ displayIndex: displayList.length + 1, actualIndex: i, q });
      }

      console.log(`\nQuestions dans ${selectedFile} (les consignes .0 sont cachées) :`);
      if (displayList.length === 0) console.log(`${colors.red}Aucune question affichable (toutes les entrées semblent être des consignes).${colors.reset}`);
      displayList.forEach(d => console.log(`${d.displayIndex}) ${d.q.title}`));

      // Prompt question avec exemple bleu
      let questionPrompt = '\nNuméro de question à ajouter (ou a pour ajouter une plage, q pour terminer): ';
      if (displayList.length > 0) {
        questionPrompt += `\n${blue}(exemple: taper l'index "1" pour ajouter la question "${displayList[0].q.title}")${reset} `;
      }
      const qChoice = await rl.question(questionPrompt);
      if (qChoice.trim().toLowerCase() === 'q') break;
      if (qChoice.trim().toLowerCase() === 'a') {
        const range = await rl.question('Entrez la plage (ex: 1-3) : ');
        const m = range.match(/^(\d+)\s*-\s*(\d+)$/);
        if (!m) {
          console.log(`${colors.red}Plage invalide.${colors.reset}`);
          continue;
        }
        const start = parseInt(m[1], 10) - 1;
        const end = parseInt(m[2], 10) - 1;
        if (displayList.length === 0) {
          console.log(`${colors.red}Aucune question disponible à ajouter.${colors.reset}`);
          continue;
        }
        if (start < 0 || end >= displayList.length || start > end) {
          console.log(`${colors.red}Plage hors limites.${colors.reset}`);
          continue;
        }
          for (let displayIdx = start; displayIdx <= end; displayIdx++) {
            const actualIdx = displayList[displayIdx].actualIndex;
            const parsedQ = parsed[actualIdx];
            const raw = blocks[actualIdx].trim();
            if (!selectedSet.has(raw)) {
              selectedBlocks.push(raw);
              selectedSet.add(raw);
            }
          }
      } else {
        const idx = parseInt(qChoice, 10) - 1;
        if (displayList.length === 0) {
          console.log(`${colors.red}Aucune question disponible à ajouter.${colors.reset}`);
          continue;
        }
        if (!(idx >= 0 && idx < displayList.length)) {
          console.log(`${colors.red}Choix de question invalide.${colors.reset}`);
          continue;
        }
        const actualIdx = displayList[idx].actualIndex;
        const raw = blocks[actualIdx].trim();
        if (selectedSet.has(raw)) {
          console.log('Question déjà sélectionnée, elle sera ignorée.');
        } else {
          selectedBlocks.push(raw);
          selectedSet.add(raw);
        }
      }

      console.log(`\nNombre de questions sélectionnées : ${selectedBlocks.length}`);

      // Verification du nombre de questions
      if (selectedBlocks.length < 15) {
        console.log(`${colors.red}Attention: Il manque ${15 - selectedBlocks.length} question(s) (minimum: 15)${colors.reset}`);
      } else if (selectedBlocks.length > 20) {
        console.log(`${colors.red}Attention: Vous avez ${selectedBlocks.length - 20} question(s) en trop (maximum: 20)${colors.reset}`);
      } else {
        console.log(`${colors.green}Nombre de questions valide (${selectedBlocks.length}/20)${colors.reset}`);
      }

      const finish = await rl.question(`Terminer la création maintenant ? (y=oui, n=continuer) : `);
      if (finish.trim().toLowerCase() === 'y') {
        // Empecher la validation si nombre incorrect
        if (selectedBlocks.length < 15 || selectedBlocks.length > 20) {
          console.log(`${colors.red}Impossible de terminer: l'examen doit contenir entre 15 et 20 questions.${colors.reset}`);
          continue;
        }
        break;
      }
    }

    try {
      const content = composeExamFromBlocks(selectedBlocks);
      console.log('\nExamen prêt — nombre de questions :', selectedBlocks.length);
      const defaultName = `examen_${Date.now()}.gift`;
      const name = await rl.question(`Nom du fichier (ou Entrée pour ${defaultName}): `);
      const filename = (name && name.trim()) ? name.trim() : defaultName;
      const outPath = await saveExamToDir(content, filename, 'examens');
      console.log('Examen sauvegardé sous :', outPath);
    } catch (e) {
      const red = colors.red;
      const reset = colors.reset;
      console.error(`\n${red}Erreur lors de la création de l'examen : ${e.message}\nAssurez-vous d'avoir entre 15 et 20 questions uniques. Vous pouvez relancer la création.${reset}`);
    }

  } finally {
    if (ownRl && rl) rl.close();
  }
}