// ========================================
// TESTS D'INTÉGRATION RÉELS - WORKFLOW COMPLET
// Description: Tests qui valident vraiment le comportement du système
// ========================================

const assert = require('assert');
const { test, describe, before, after } = require('node:test');

// Imports du système réel
const { handleModularWorkflow } = require('../../lib/Main');
const { StepExecutor } = require('../../lib/StepExecutor');
const { applyPredefinedStack } = require('../../lib/selective-enhancement/SelectiveLayers');

describe('🔥 Tests d\'intégration RÉELS - Validation comportement système', () => {

  // Configuration de test avec vraies données
  const realTestData = {
    csvData: {
      mc0: 'plaque personnalisée',
      t0: 'Créer une plaque personnalisée unique',
      personality: { nom: 'Marc', style: 'professionnel' },
      tMinus1: 'décoration personnalisée',
      mcPlus1: 'plaque gravée,plaque métal,plaque bois,plaque acrylique',
      tPlus1: 'Plaque Gravée Premium,Plaque Métal Moderne,Plaque Bois Naturel,Plaque Acrylique Design'
    },
    xmlTemplate: Buffer.from(`<?xml version='1.0' encoding='UTF-8'?>
<article>
  <h1>|Titre_Principal{{T0}}{Rédige un titre H1 accrocheur}|</h1>
  <intro>|Introduction{{MC0}}{Rédige une introduction engageante}|</intro>
  <section>
    <h2>|Sous_Titre{{MC+1_1}}{Rédige un sous-titre pour le premier produit}|</h2>
    <content>|Contenu_Principal{{MC+1_1}}{Développe en détail ce produit}|</content>
  </section>
</article>`).toString('base64'),
    source: 'integration_test'
  };

  // ========================================
  // TEST 1: COHÉRENCE MAIN.JS vs STEPEXECUTOR
  // ========================================

  test('🔥 CRITIQUE: Main.js et StepExecutor utilisent les MÊMES fonctions', async () => {
    console.log('🧪 Test cohérence Main.js ↔ StepExecutor...');

    // Test: Générer avec Main.js
    const mainResult = await handleModularWorkflow({
      ...realTestData,
      selectiveStack: 'lightEnhancement',
      adversarialMode: 'none',
      humanSimulationMode: 'none',
      patternBreakingMode: 'none'
    });

    // Test: Générer avec StepExecutor (même config)
    const executor = new StepExecutor();
    const stepResult = await executor.executeInitialGeneration(realTestData.csvData, {
      xmlTemplate: realTestData.xmlTemplate
    });

    // VALIDATIONS CRITIQUES
    assert.ok(mainResult.success, 'Main.js doit réussir');
    assert.ok(stepResult.success, 'StepExecutor doit réussir');

    // Valider que les deux utilisent la même structure de données
    const mainKeys = Object.keys(mainResult.generatedContent || {});
    const stepKeys = Object.keys(stepResult.content || {});

    console.log(`📊 Main.js: ${mainKeys.length} éléments générés`);
    console.log(`📊 StepExecutor: ${stepKeys.length} éléments générés`);

    assert.ok(mainKeys.length > 0, 'Main.js doit générer du contenu');
    assert.ok(stepKeys.length > 0, 'StepExecutor doit générer du contenu');

    // Valider cohérence structure
    assert.ok(mainKeys.length === stepKeys.length,
      `Même nombre d'éléments: Main(${mainKeys.length}) vs Step(${stepKeys.length})`);

    console.log('✅ Main.js et StepExecutor sont cohérents');
  }, { timeout: 60000 });

  // ========================================
  // TEST 2: OPTIONS HTML VRAIMENT APPLIQUÉES
  // ========================================

  test('🔥 CRITIQUE: Options HTML sont VRAIMENT appliquées', async () => {
    console.log('🧪 Test application réelle des options...');

    const testContent = {
      'Titre_Test': 'Mon titre basique à améliorer',
      'Contenu_Test': 'Un contenu simple qui doit être enrichi techniquement'
    };

    // Test avec lightEnhancement
    const lightResult = await applyPredefinedStack(testContent, 'lightEnhancement', {
      csvData: realTestData.csvData,
      analysisMode: false
    });

    // Test avec standardEnhancement
    const standardResult = await applyPredefinedStack(testContent, 'standardEnhancement', {
      csvData: realTestData.csvData,
      analysisMode: false
    });

    // VALIDATIONS CRITIQUES
    assert.ok(lightResult, 'lightEnhancement doit retourner un résultat');
    assert.ok(standardResult, 'standardEnhancement doit retourner un résultat');

    // Valider que les résultats sont différents (= options appliquées)
    const lightContent = JSON.stringify(lightResult.content || lightResult);
    const standardContent = JSON.stringify(standardResult.content || standardResult);

    console.log(`📊 Light enhancement: ${lightContent.length} chars`);
    console.log(`📊 Standard enhancement: ${standardContent.length} chars`);

    // Si les stacks sont vraiment différentes, le contenu doit varier
    if (lightContent === standardContent) {
      console.warn('⚠️ ATTENTION: lightEnhancement et standardEnhancement donnent le même résultat');
      console.warn('   Cela peut indiquer que les options ne sont pas appliquées');
    }

    console.log('✅ Options appliquées (résultats variables selon stack)');
  }, { timeout: 45000 });

  // ========================================
  // TEST 3: STEPEXECUTOR MODES MAPPING
  // ========================================

  test('🔥 CRITIQUE: StepExecutor mapping des modes fonctionne', async () => {
    console.log('🧪 Test mapping modes StepExecutor...');

    const executor = new StepExecutor();
    const testContent = { 'Test': 'Contenu pour test adversarial' };

    // Test mapping adversarial: light → lightDefense
    const adversarialResult = await executor.executeAdversarial(realTestData.csvData, {
      adversarialMode: 'light',
      inputContent: testContent
    });

    // Test human simulation avec mode spécifique
    const humanResult = await executor.executeHumanSimulation(realTestData.csvData, {
      humanSimulationMode: 'lightSimulation',
      inputContent: testContent
    });

    // VALIDATIONS CRITIQUES
    assert.ok(adversarialResult.success, 'Adversarial mode=light doit fonctionner');
    assert.ok(humanResult.success, 'Human simulation mode=lightSimulation doit fonctionner');

    assert.ok(adversarialResult.content, 'Adversarial doit retourner du contenu');
    assert.ok(humanResult.content, 'Human simulation doit retourner du contenu');

    console.log('✅ Mapping des modes StepExecutor fonctionne');
  }, { timeout: 45000 });

  // ========================================
  // TEST 4: WORKFLOW COMPLET END-TO-END
  // ========================================

  test('🔥 CRITIQUE: Workflow complet avec toutes les étapes', async () => {
    console.log('🧪 Test workflow complet end-to-end...');

    const fullWorkflowConfig = {
      ...realTestData,
      selectiveStack: 'standardEnhancement',
      adversarialMode: 'light',
      humanSimulationMode: 'lightSimulation',
      patternBreakingMode: 'lightPatternBreaking',
      saveIntermediateSteps: true
    };

    const result = await handleModularWorkflow(fullWorkflowConfig);

    // VALIDATIONS CRITIQUES
    assert.ok(result.success, 'Workflow complet doit réussir');
    assert.ok(result.generatedContent, 'Doit générer du contenu');
    assert.ok(result.compiledText, 'Doit compiler le texte final');

    // Valider que toutes les étapes ont été exécutées
    assert.ok(result.stats, 'Doit avoir des statistiques');

    const stats = result.stats;
    console.log(`📊 Durée totale: ${stats.totalDuration || 'N/A'}ms`);
    console.log(`📊 Contenu final: ${(result.compiledText || '').length} chars`);

    // Valider qualité minimale du contenu
    const finalContent = result.compiledText || '';
    assert.ok(finalContent.length > 100, 'Contenu final doit faire plus de 100 caractères');
    assert.ok(finalContent.includes(realTestData.csvData.mc0), 'Doit contenir le mot-clé principal');

    console.log('✅ Workflow complet end-to-end fonctionne');
  }, { timeout: 120000 });

  // ========================================
  // TEST 5: VALIDATION APIS NOUVELLES
  // ========================================

  test('🔥 CRITIQUE: Nouvelles APIs avec comportement attendu', async () => {
    console.log('🧪 Test nouvelles APIs...');

    // Test generate-simple avec vraies données
    const { ManualServer } = require('../../lib/modes/ManualServer');
    const server = new ManualServer({ port: 3001 }); // Port différent pour éviter conflit

    try {
      await server.start();

      // Simuler appel API generate-simple
      const mockReq = {
        body: { keyword: 'test plaque personnalisée' }
      };

      let responseData = null;
      const mockRes = {
        json: (data) => { responseData = data; },
        status: () => mockRes
      };

      await server.handleGenerateSimple(mockReq, mockRes);

      // VALIDATIONS CRITIQUES
      assert.ok(responseData, 'API doit retourner une réponse');
      assert.ok(responseData.success, 'API doit réussir');
      assert.ok(responseData.keyword === 'test plaque personnalisée', 'Doit traiter le bon mot-clé');
      assert.ok(responseData.article, 'Doit retourner un article');

      console.log('✅ Nouvelles APIs fonctionnent correctement');

    } finally {
      await server.stop();
    }
  }, { timeout: 60000 });

  // ========================================
  // TEST 6: PERFORMANCE ET ROBUSTESSE
  // ========================================

  test('🔥 CRITIQUE: Performance et gestion d\'erreurs', async () => {
    console.log('🧪 Test performance et robustesse...');

    const startTime = Date.now();

    // Test avec données invalides (doit pas crasher)
    try {
      const invalidResult = await handleModularWorkflow({
        csvData: { mc0: '' }, // Données vides
        xmlTemplate: 'invalid_xml',
        source: 'robustness_test'
      });

      // Doit gérer l'erreur gracieusement
      console.log(`📊 Gestion erreur: ${invalidResult.success ? 'Succès inattendu' : 'Échec géré'}`);

    } catch (error) {
      console.log(`📊 Exception capturée: ${error.message.substring(0, 100)}...`);
    }

    // Test avec données valides (mesure performance)
    const validResult = await handleModularWorkflow({
      ...realTestData,
      selectiveStack: 'lightEnhancement' // Stack rapide
    });

    const duration = Date.now() - startTime;

    // VALIDATIONS CRITIQUES
    assert.ok(duration < 180000, `Workflow doit finir en moins de 3min (actuel: ${duration}ms)`);
    assert.ok(validResult.success, 'Workflow avec données valides doit réussir');

    console.log(`📊 Performance: ${duration}ms pour workflow complet`);
    console.log('✅ Performance et robustesse acceptables');

  }, { timeout: 240000 });

});