seogeneratorserver/lib/selective-enhancement/demo-modulaire.js

// ========================================
// DÉMONSTRATION ARCHITECTURE MODULAIRE SELECTIVE
// Usage: node lib/selective-enhancement/demo-modulaire.js
// Objectif: Valider l'intégration modulaire selective enhancement
// ========================================

const { logSh } = require('../ErrorReporting');

// Import modules selective modulaires
const { applySelectiveLayer } = require('./SelectiveCore');
const { 
  applyPredefinedStack,
  applyAdaptiveLayers,
  getAvailableStacks
} = require('./SelectiveLayers');
const { 
  analyzeTechnicalQuality, 
  analyzeTransitionFluidity, 
  analyzeStyleConsistency,
  generateImprovementReport
} = require('./SelectiveUtils');

/**
 * EXEMPLE D'UTILISATION MODULAIRE SELECTIVE
 */
async function demoModularSelective() {
  console.log('\n🔧 === DÉMONSTRATION SELECTIVE MODULAIRE ===\n');

  // Contenu d'exemple avec problèmes de qualité
  const exempleContenu = {
    '|Titre_Principal_1|': 'Guide complet pour choisir votre plaque personnalisée',
    '|Introduction_1|': 'La personnalisation d\'une plaque signalétique représente un enjeu important pour votre entreprise. Cette solution permet de créer une identité visuelle.',
    '|Texte_1|': 'Il est important de noter que les matériaux utilisés sont de qualité. Par ailleurs, la qualité est bonne. En effet, nos solutions sont bonnes et robustes. Par ailleurs, cela fonctionne bien.',
    '|FAQ_Question_1|': 'Quels sont les matériaux disponibles ?',
    '|FAQ_Reponse_1|': 'Nos matériaux sont de qualité : ils conviennent parfaitement. Ces solutions garantissent une qualité et un rendu optimal.'
  };

  console.log('📊 CONTENU ORIGINAL:');
  Object.entries(exempleContenu).forEach(([tag, content]) => {
    console.log(`   ${tag}: "${content}"`);
  });

  // Analyser qualité originale
  const fullOriginal = Object.values(exempleContenu).join(' ');
  const qualiteOriginale = {
    technical: analyzeTechnicalQuality(fullOriginal, ['dibond', 'aluminium', 'pmma', 'impression']),
    transitions: analyzeTransitionFluidity(fullOriginal),
    style: analyzeStyleConsistency(fullOriginal)
  };
  
  console.log(`\n📈 QUALITÉ ORIGINALE:`);
  console.log(`   🔧 Technique: ${qualiteOriginale.technical.score}/100`);
  console.log(`   🔗 Transitions: ${qualiteOriginale.transitions.score}/100`);
  console.log(`   🎨 Style: ${qualiteOriginale.style.score}/100`);

  try {
    // ========================================
    // TEST 1: COUCHE TECHNIQUE SEULE
    // ========================================
    console.log('\n🔧 TEST 1: Application couche technique');
    
    const result1 = await applySelectiveLayer(exempleContenu, {
      layerType: 'technical',
      llmProvider: 'gpt4',
      intensity: 0.9,
      csvData: {
        personality: { nom: 'Marc', style: 'technique' },
        mc0: 'plaque personnalisée'
      }
    });

    console.log(`✅ Résultat: ${result1.stats.enhanced}/${result1.stats.processed} éléments améliorés`);
    console.log(`   ⏱️ Durée: ${result1.stats.duration}ms`);

    // ========================================
    // TEST 2: STACK PRÉDÉFINI
    // ========================================
    console.log('\n📦 TEST 2: Application stack prédéfini');
    
    // Lister stacks disponibles
    const stacks = getAvailableStacks();
    console.log('   Stacks disponibles:');
    stacks.forEach(stack => {
      console.log(`   - ${stack.name}: ${stack.description}`);
    });
    
    const result2 = await applyPredefinedStack(exempleContenu, 'standardEnhancement', {
      csvData: { 
        personality: { 
          nom: 'Sophie', 
          style: 'professionnel',
          vocabulairePref: 'signalétique,personnalisation,qualité,expertise',
          niveauTechnique: 'standard'
        },
        mc0: 'plaque personnalisée'
      }
    });

    console.log(`✅ Stack standard: ${result2.stats.totalModifications} modifications totales`);
    console.log(`   📊 Couches: ${result2.stats.layers.filter(l => l.success).length}/${result2.stats.layers.length} réussies`);

    // ========================================
    // TEST 3: COUCHES ADAPTATIVES
    // ========================================
    console.log('\n🧠 TEST 3: Application couches adaptatives');
    
    const result3 = await applyAdaptiveLayers(exempleContenu, {
      maxIntensity: 1.2,
      analysisThreshold: 0.3,
      csvData: {
        personality: { 
          nom: 'Laurent', 
          style: 'commercial',
          vocabulairePref: 'expertise,solution,performance,innovation',
          niveauTechnique: 'accessible'
        },
        mc0: 'signalétique personnalisée'
      }
    });

    if (result3.stats.adaptive) {
      console.log(`✅ Adaptatif: ${result3.stats.layersApplied} couches appliquées`);
      console.log(`   📊 Modifications: ${result3.stats.totalModifications}`);
    }

    // ========================================
    // COMPARAISON QUALITÉ FINALE
    // ========================================
    console.log('\n📊 ANALYSE QUALITÉ FINALE:');
    
    const contenuFinal = result2.content; // Prendre résultat stack standard
    const fullEnhanced = Object.values(contenuFinal).join(' ');
    
    const qualiteFinale = {
      technical: analyzeTechnicalQuality(fullEnhanced, ['dibond', 'aluminium', 'pmma', 'impression']),
      transitions: analyzeTransitionFluidity(fullEnhanced),
      style: analyzeStyleConsistency(fullEnhanced, result2.csvData?.personality)
    };
    
    console.log('\n📈 AMÉLIORATION QUALITÉ:');
    console.log(`   🔧 Technique: ${qualiteOriginale.technical.score} → ${qualiteFinale.technical.score} (+${(qualiteFinale.technical.score - qualiteOriginale.technical.score).toFixed(1)})`);
    console.log(`   🔗 Transitions: ${qualiteOriginale.transitions.score} → ${qualiteFinale.transitions.score} (+${(qualiteFinale.transitions.score - qualiteOriginale.transitions.score).toFixed(1)})`);
    console.log(`   🎨 Style: ${qualiteOriginale.style.score} → ${qualiteFinale.style.score} (+${(qualiteFinale.style.score - qualiteOriginale.style.score).toFixed(1)})`);

    // Rapport détaillé
    const rapport = generateImprovementReport(exempleContenu, contenuFinal, 'selective');
    
    console.log('\n📋 RAPPORT AMÉLIORATION:');
    console.log(`   📈 Amélioration moyenne: ${rapport.summary.averageImprovement.toFixed(1)}%`);
    console.log(`   ✅ Éléments améliorés: ${rapport.summary.elementsImproved}/${rapport.summary.elementsProcessed}`);
    
    if (rapport.details.recommendations.length > 0) {
      console.log(`   💡 Recommandations: ${rapport.details.recommendations.join(', ')}`);
    }

    // ========================================
    // EXEMPLES DE TRANSFORMATION
    // ========================================
    console.log('\n✨ EXEMPLES DE TRANSFORMATION:');
    
    console.log('\n📝 INTRODUCTION:');
    console.log('AVANT:', `"${exempleContenu['|Introduction_1|']}"`);
    console.log('APRÈS:', `"${contenuFinal['|Introduction_1|']}"`);
    
    console.log('\n📝 TEXTE PRINCIPAL:');
    console.log('AVANT:', `"${exempleContenu['|Texte_1|']}"`);
    console.log('APRÈS:', `"${contenuFinal['|Texte_1|']}"`);

    console.log('\n✅ === DÉMONSTRATION SELECTIVE MODULAIRE TERMINÉE ===\n');
    
    return {
      success: true,
      originalQuality: qualiteOriginale,
      finalQuality: qualiteFinale,
      improvementReport: rapport
    };

  } catch (error) {
    console.error('\n❌ ERREUR DÉMONSTRATION:', error.message);
    console.error(error.stack);
    return { success: false, error: error.message };
  }
}

/**
 * EXEMPLE D'INTÉGRATION AVEC PIPELINE EXISTANTE
 */
async function demoIntegrationExistante() {
  console.log('\n🔗 === DÉMONSTRATION INTÉGRATION PIPELINE ===\n');
  
  // Simuler contenu venant de ContentGeneration.js (Level 1)
  const contenuExistant = {
    '|Titre_H1_1|': 'Solutions de plaques personnalisées professionnelles',
    '|Meta_Description_1|': 'Découvrez notre gamme complète de plaques personnalisées pour tous vos besoins de signalétique professionnelle.',
    '|Introduction_1|': 'Dans le domaine de la signalétique personnalisée, le choix des matériaux et des techniques de fabrication constitue un élément déterminant.',
    '|Texte_Avantages_1|': 'Les avantages de nos solutions incluent la durabilité, la résistance aux intempéries et la possibilité de personnalisation complète.'
  };
  
  console.log('💼 SCÉNARIO: Application selective post-génération normale');
  
  try {
    console.log('\n🎯 Étape 1: Contenu généré par pipeline Level 1');
    console.log('   ✅ Contenu de base: qualité préservée');
    
    console.log('\n🎯 Étape 2: Application selective enhancement modulaire');
    
    // Test avec couche technique puis style
    let contenuEnhanced = contenuExistant;
    
    // Amélioration technique
    const resultTechnique = await applySelectiveLayer(contenuEnhanced, {
      layerType: 'technical',
      llmProvider: 'gpt4',
      intensity: 1.0,
      analysisMode: true,
      csvData: {
        personality: { nom: 'Marc', style: 'technique' },
        mc0: 'plaque personnalisée'
      }
    });
    
    contenuEnhanced = resultTechnique.content;
    console.log(`   ✅ Couche technique: ${resultTechnique.stats.enhanced} éléments améliorés`);
    
    // Amélioration style
    const resultStyle = await applySelectiveLayer(contenuEnhanced, {
      layerType: 'style',
      llmProvider: 'mistral',
      intensity: 0.8,
      analysisMode: true,
      csvData: {
        personality: { 
          nom: 'Sophie', 
          style: 'professionnel moderne',
          vocabulairePref: 'innovation,expertise,personnalisation,qualité',
          niveauTechnique: 'accessible'
        }
      }
    });
    
    contenuEnhanced = resultStyle.content;
    console.log(`   ✅ Couche style: ${resultStyle.stats.enhanced} éléments stylisés`);
    
    console.log('\n📊 RÉSULTAT FINAL INTÉGRÉ:');
    Object.entries(contenuEnhanced).forEach(([tag, content]) => {
      console.log(`\n   ${tag}:`);
      console.log(`     ORIGINAL: "${contenuExistant[tag]}"`);
      console.log(`     ENHANCED: "${content}"`);
    });
    
    return { 
      success: true, 
      techniqueResult: resultTechnique,
      styleResult: resultStyle,
      finalContent: contenuEnhanced
    };
    
  } catch (error) {
    console.error('❌ ERREUR INTÉGRATION:', error.message);
    return { success: false, error: error.message };
  }
}

/**
 * TEST PERFORMANCE ET BENCHMARKS
 */
async function benchmarkPerformance() {
  console.log('\n⚡ === BENCHMARK PERFORMANCE ===\n');
  
  // Contenu de test de taille variable
  const contenuTest = {};
  
  // Générer contenu test
  for (let i = 1; i <= 10; i++) {
    contenuTest[`|Element_${i}|`] = `Ceci est un contenu de test numéro ${i} pour valider les performances du système selective enhancement modulaire. ` +
      `Il est important de noter que ce contenu contient du vocabulaire générique et des répétitions. Par ailleurs, les transitions sont basiques. ` +
      `En effet, la qualité technique est faible et le style est générique. Par ailleurs, cela nécessite des améliorations.`.repeat(Math.floor(i/3) + 1);
  }
  
  console.log(`📊 Contenu test: ${Object.keys(contenuTest).length} éléments`);
  
  try {
    const benchmarks = [];
    
    // Test 1: Couche technique seule
    const start1 = Date.now();
    const result1 = await applySelectiveLayer(contenuTest, {
      layerType: 'technical',
      intensity: 0.8
    });
    benchmarks.push({
      test: 'Couche technique seule',
      duration: Date.now() - start1,
      enhanced: result1.stats.enhanced,
      processed: result1.stats.processed
    });
    
    // Test 2: Stack complet
    const start2 = Date.now();
    const result2 = await applyPredefinedStack(contenuTest, 'fullEnhancement');
    benchmarks.push({
      test: 'Stack complet (3 couches)',
      duration: Date.now() - start2,
      totalModifications: result2.stats.totalModifications,
      layers: result2.stats.layers.length
    });
    
    // Test 3: Adaptatif
    const start3 = Date.now();
    const result3 = await applyAdaptiveLayers(contenuTest, { maxIntensity: 1.0 });
    benchmarks.push({
      test: 'Couches adaptatives',
      duration: Date.now() - start3,
      layersApplied: result3.stats.layersApplied,
      totalModifications: result3.stats.totalModifications
    });
    
    console.log('\n📈 RÉSULTATS BENCHMARK:');
    benchmarks.forEach(bench => {
      console.log(`\n   ${bench.test}:`);
      console.log(`     ⏱️ Durée: ${bench.duration}ms`);
      if (bench.enhanced) console.log(`     ✅ Améliorés: ${bench.enhanced}/${bench.processed}`);
      if (bench.totalModifications) console.log(`     🔄 Modifications: ${bench.totalModifications}`);
      if (bench.layers) console.log(`     📦 Couches: ${bench.layers}`);
      if (bench.layersApplied) console.log(`     🧠 Couches adaptées: ${bench.layersApplied}`);
    });
    
    return { success: true, benchmarks };
    
  } catch (error) {
    console.error('❌ ERREUR BENCHMARK:', error.message);
    return { success: false, error: error.message };
  }
}

// Exécuter démonstrations si fichier appelé directement
if (require.main === module) {
  (async () => {
    await demoModularSelective();
    await demoIntegrationExistante();
    await benchmarkPerformance();
  })().catch(console.error);
}

module.exports = {
  demoModularSelective,
  demoIntegrationExistante,
  benchmarkPerformance
};