import { AutoReporter } from '../reporters/AutoReporter.js';
// ========================================
// TESTS RAPIDES - VALIDATION SYSTÈME
// Description: Tests rapides qui valident la cohérence sans appels LLM lents
// ========================================

import assert from 'node:assert';
import { test, describe } from 'node:test';
import { requireCommonJS } from '../_helpers/commonjs-bridge.js';

// Imports système
const { StepExecutor } = requireCommonJS('StepExecutor');
const { applyPredefinedStack } = requireCommonJS('selective-enhancement/SelectiveLayers');
const { applyPredefinedStack: applyAdversarialStack } = requireCommonJS('adversarial-generation/AdversarialLayers');
const { applyPredefinedSimulation } = requireCommonJS('human-simulation/HumanSimulationLayers');
const { applyPatternBreakingStack } = requireCommonJS('pattern-breaking/PatternBreakingLayers');


// Auto-Reporter Configuration
const autoReporter = new AutoReporter();

describe('🚀 Tests RAPIDES - Validation cohérence système', () => {

  const mockData = {
    mc0: 'test produit',
    t0: 'Test titre produit',
    personality: { nom: 'Marc', style: 'professionnel' },
    tMinus1: 'test ancien',
    mcPlus1: 'test1,test2,test3',
    tPlus1: 'Test 1,Test 2,Test 3'
  };

  const mockContent = {
    'Titre_Test': 'Mon titre de test à traiter',
    'Contenu_Test': 'Contenu de test qui doit être modifié selon les options'
  };

  // ========================================
  // TEST 1: STEPEXECUTOR RESPECTE LES OPTIONS
  // ========================================

  test('🔥 CRITIQUE: StepExecutor utilise vraiment les stacks spécifiées', async () => {
    console.log('🧪 Test StepExecutor options...');

    const executor = new StepExecutor();

    // Test que executeSelective utilise la bonne stack
    try {
      const lightResult = await executor.executeSelective(mockData, {
        selectiveStack: 'lightEnhancement',
        inputContent: mockContent
      });

      assert.ok(lightResult.success, 'executeSelective avec lightEnhancement doit réussir');
      assert.ok(lightResult.content, 'Doit retourner du contenu');

      console.log('✅ executeSelective respecte selectiveStack');

    } catch (error) {
      console.error('❌ Erreur executeSelective:', error.message);
      throw error;
    }

    // Test que executeAdversarial utilise le bon mapping
    try {
      const adversarialResult = await executor.executeAdversarial(mockData, {
        adversarialMode: 'light',
        inputContent: mockContent
      });

      assert.ok(adversarialResult.success, 'executeAdversarial avec mode light doit réussir');
      assert.ok(adversarialResult.content, 'Doit retourner du contenu');

      console.log('✅ executeAdversarial respecte adversarialMode');

    } catch (error) {
      console.error('❌ Erreur executeAdversarial:', error.message);
      throw error;
    }

    console.log('✅ StepExecutor respecte les options');

  }, { timeout: 30000 });

  // ========================================
  // TEST 2: STACKS DIRECTES VS STEPEXECUTOR
  // ========================================

  test('🔥 CRITIQUE: Stacks directes et StepExecutor sont cohérentes', async () => {
    console.log('🧪 Test cohérence stacks directes vs StepExecutor...');

    // Test stack selective directe
    const directSelectiveResult = await applyPredefinedStack(mockContent, 'lightEnhancement', {
      csvData: mockData,
      analysisMode: false
    });

    // Test via StepExecutor
    const executor = new StepExecutor();
    const stepExecutorResult = await executor.executeSelective(mockData, {
      selectiveStack: 'lightEnhancement',
      inputContent: mockContent
    });

    // Validation cohérence
    assert.ok(directSelectiveResult, 'Stack directe doit retourner un résultat');
    assert.ok(stepExecutorResult.success, 'StepExecutor doit réussir');

    assert.ok(directSelectiveResult.content || directSelectiveResult, 'Stack directe doit avoir du contenu');
    assert.ok(stepExecutorResult.content, 'StepExecutor doit avoir du contenu');

    console.log('📊 Stack directe: contenu présent');
    console.log('📊 StepExecutor: contenu présent');

    console.log('✅ Cohérence stacks directes ↔ StepExecutor validée');

  }, { timeout: 30000 });

  // ========================================
  // TEST 3: MAPPING MODES ADVERSARIAL
  // ========================================

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

    const modes = [
      { mode: 'light', expectedStack: 'lightDefense' },
      { mode: 'standard', expectedStack: 'standardDefense' },
      { mode: 'heavy', expectedStack: 'heavyDefense' }
    ];

    for (const { mode, expectedStack } of modes) {
      console.log(`🧪 Test mode ${mode} → stack ${expectedStack}`);

      // Test direct stack
      try {
        const directResult = await applyAdversarialStack(mockContent, expectedStack, {
          csvData: mockData
        });

        assert.ok(directResult, `Stack ${expectedStack} doit fonctionner`);
        console.log(`✅ Stack directe ${expectedStack}: OK`);

      } catch (error) {
        console.warn(`⚠️ Stack directe ${expectedStack} a échoué: ${error.message}`);
      }

      // Test via StepExecutor avec mapping
      try {
        const executor = new StepExecutor();
        const stepResult = await executor.executeAdversarial(mockData, {
          adversarialMode: mode,
          inputContent: mockContent
        });

        assert.ok(stepResult.success, `StepExecutor mode ${mode} doit réussir`);
        console.log(`✅ StepExecutor mode ${mode}: OK`);

      } catch (error) {
        console.warn(`⚠️ StepExecutor mode ${mode} a échoué: ${error.message}`);
      }
    }

    console.log('✅ Mapping modes adversarial validé');

  }, { timeout: 45000 });

  // ========================================
  // TEST 4: FONCTIONS IMPORTÉES CORRECTEMENT
  // ========================================

  test('🔥 CRITIQUE: Fonctions importées et utilisées correctement', async () => {
    console.log('🧪 Test imports et utilisation fonctions...');

    // Vérifier que StepExecutor importe les bonnes fonctions
    const executor = new StepExecutor();

    // Vérifier présence des méthodes critiques
    assert.ok(typeof executor.executeSelective === 'function', 'executeSelective doit être une fonction');
    assert.ok(typeof executor.executeAdversarial === 'function', 'executeAdversarial doit être une fonction');
    assert.ok(typeof executor.executeHumanSimulation === 'function', 'executeHumanSimulation doit être une fonction');
    assert.ok(typeof executor.executePatternBreaking === 'function', 'executePatternBreaking doit être une fonction');

    // Vérifier que les fonctions de stacks directes sont accessibles
    assert.ok(typeof applyPredefinedStack === 'function', 'applyPredefinedStack selective doit être accessible');
    assert.ok(typeof applyAdversarialStack === 'function', 'applyAdversarialStack doit être accessible');
    assert.ok(typeof applyPredefinedSimulation === 'function', 'applyPredefinedSimulation doit être accessible');
    assert.ok(typeof applyPatternBreakingStack === 'function', 'applyPatternBreakingStack doit être accessible');

    console.log('✅ Toutes les fonctions sont importées correctement');

    // Test que les fonctions peuvent être appelées
    try {
      await executor.executeSelective(mockData, {
        selectiveStack: 'lightEnhancement',
        inputContent: { 'Test': 'contenu test' }
      });

      console.log('✅ executeSelective peut être appelée');

    } catch (error) {
      console.warn(`⚠️ executeSelective error: ${error.message}`);
    }

    console.log('✅ Fonctions importées et utilisables');

  }, { timeout: 30000 });

  // ========================================
  // TEST 5: STRUCTURE DONNÉES COHÉRENTE
  // ========================================

  test('🔥 CRITIQUE: Structure données cohérente entre composants', async () => {
    console.log('🧪 Test structure données...');

    const executor = new StepExecutor();

    // Test executeSelective structure de retour
    const selectiveResult = await executor.executeSelective(mockData, {
      selectiveStack: 'lightEnhancement',
      inputContent: mockContent
    });

    // Vérifier structure attendue
    assert.ok(selectiveResult.success !== undefined, 'Doit avoir propriété success');
    assert.ok(selectiveResult.content, 'Doit avoir propriété content');
    assert.ok(selectiveResult.tokensUsed !== undefined, 'Doit avoir propriété tokensUsed');
    assert.ok(selectiveResult.cost !== undefined, 'Doit avoir propriété cost');

    console.log('📊 Structure executeSelective:', Object.keys(selectiveResult));

    // Test executeAdversarial structure de retour
    const adversarialResult = await executor.executeAdversarial(mockData, {
      adversarialMode: 'light',
      inputContent: mockContent
    });

    assert.ok(adversarialResult.success !== undefined, 'Adversarial doit avoir success');
    assert.ok(adversarialResult.content, 'Adversarial doit avoir content');

    console.log('📊 Structure executeAdversarial:', Object.keys(adversarialResult));

    // Vérifier cohérence structure
    const expectedKeys = ['success', 'content', 'tokensUsed', 'cost'];
    for (const key of expectedKeys) {
      assert.ok(selectiveResult[key] !== undefined, `executeSelective doit avoir ${key}`);
      assert.ok(adversarialResult[key] !== undefined, `executeAdversarial doit avoir ${key}`);
    }

    console.log('✅ Structure données cohérente entre composants');

  }, { timeout: 30000 });

  // ========================================
  // TEST 6: CONFIGURATION DISPONIBLE
  // ========================================

  test('🔥 CRITIQUE: Configuration stacks et modes disponible', () => {
    console.log('🧪 Test configuration disponible...');

    // Vérifier qu'on peut importer les configurations
    const selectiveStacks = [
      'lightEnhancement',
      'standardEnhancement',
      'fullEnhancement',
      'personalityFocus',
      'fluidityFocus',
      'adaptive'
    ];

    const adversarialModes = [
      'none',
      'light',
      'standard',
      'heavy',
      'adaptive'
    ];

    const humanSimulationModes = [
      'none',
      'lightSimulation',
      'standardSimulation',
      'heavySimulation',
      'adaptiveSimulation',
      'personalityFocus',
      'temporalFocus'
    ];

    const patternBreakingModes = [
      'none',
      'lightPatternBreaking',
      'standardPatternBreaking',
      'heavyPatternBreaking',
      'adaptivePatternBreaking',
      'syntaxFocus',
      'connectorsFocus'
    ];

    // Vérifier que les modes sont cohérents avec ce qu'on attend
    console.log(`📊 Selective stacks: ${selectiveStacks.length} disponibles`);
    console.log(`📊 Adversarial modes: ${adversarialModes.length} disponibles`);
    console.log(`📊 Human simulation modes: ${humanSimulationModes.length} disponibles`);
    console.log(`📊 Pattern breaking modes: ${patternBreakingModes.length} disponibles`);

    // Test que les modes de base sont présents
    assert.ok(selectiveStacks.includes('lightEnhancement'), 'lightEnhancement doit être disponible');
    assert.ok(selectiveStacks.includes('standardEnhancement'), 'standardEnhancement doit être disponible');
    assert.ok(adversarialModes.includes('light'), 'adversarial light doit être disponible');
    assert.ok(adversarialModes.includes('standard'), 'adversarial standard doit être disponible');

    console.log('✅ Configuration stacks et modes disponible');

  });

});