// Test de cohérence - Plusieurs essais pour vérifier la stabilité des scores
import { default as IAEngine } from './src/DRS/services/IAEngine.js';

async function testConsistency() {
    console.log('🔄 TEST DE COHÉRENCE - Multiples essais pour vérifier la stabilité\n');
    console.log('========================================================\n');

    const engine = new IAEngine({
        defaultProvider: 'openai',
        fallbackProviders: ['deepseek']
    });

    await new Promise(resolve => setTimeout(resolve, 1000));

    // Cas de test critiques - on veut voir si les scores varient trop
    const testCases = [
        {
            name: 'Mauvaise réponse complètement folle',
            test: () => engine.validateComprehension(
                'Paris is the capital of France and has about 2 million inhabitants.',
                'Purple elephants fly in chocolate rivers on Mars',
                { exerciseType: 'text-comprehension' }
            ),
            expectedRange: [0, 30], // Devrait être très bas
            description: 'Réponse totalement hors sujet'
        },
        {
            name: 'Bonne réponse raisonnée',
            test: () => engine.validateComprehension(
                'Paris is the capital of France and has about 2 million inhabitants.',
                'Paris is the capital city of France with around 2 million people',
                { exerciseType: 'text-comprehension' }
            ),
            expectedRange: [70, 100], // Devrait être haut
            description: 'Réponse correcte et précise'
        },
        {
            name: 'Traduction absurde',
            test: () => engine.validateTranslation(
                'How are you today?',
                'Banana monkey computer jump',
                { fromLang: 'en', toLang: 'fr' }
            ),
            expectedRange: [0, 30], // Devrait être très bas
            description: 'Traduction complètement fausse'
        },
        {
            name: 'Traduction correcte',
            test: () => engine.validateTranslation(
                'How are you today?',
                'Comment allez-vous aujourd\'hui?',
                { fromLang: 'en', toLang: 'fr' }
            ),
            expectedRange: [70, 100], // Devrait être haut
            description: 'Traduction parfaite'
        }
    ];

    const rounds = 3; // Tester 3 fois chaque cas
    const results = {};

    for (const testCase of testCases) {
        console.log(`🧪 Testing: ${testCase.name} (${rounds} rounds)`);
        console.log(`   ${testCase.description}`);

        const scores = [];
        const providers = [];

        for (let round = 1; round <= rounds; round++) {
            try {
                console.log(`   Round ${round}...`);
                const result = await testCase.test();
                scores.push(result.score);
                providers.push(result.provider);

                const [min, max] = testCase.expectedRange;
                const inRange = result.score >= min && result.score <= max;
                console.log(`     Score: ${result.score} (attendu: ${min}-${max}) ${inRange ? '✅' : '❌'}`);

            } catch (error) {
                console.log(`     ❌ Erreur: ${error.message}`);
                scores.push('ERROR');
            }

            // Délai pour éviter les problèmes de rate limiting
            await new Promise(resolve => setTimeout(resolve, 3000));
        }

        // Analyse de la cohérence
        const validScores = scores.filter(s => typeof s === 'number');
        const [expectedMin, expectedMax] = testCase.expectedRange;

        results[testCase.name] = {
            scores: scores,
            providers: providers,
            average: validScores.length > 0 ? Math.round(validScores.reduce((a, b) => a + b, 0) / validScores.length) : 'N/A',
            variance: validScores.length > 1 ? Math.round(Math.max(...validScores) - Math.min(...validScores)) : 0,
            allInRange: validScores.every(score => score >= expectedMin && score <= expectedMax),
            consistency: validScores.length > 1 ? (Math.max(...validScores) - Math.min(...validScores)) < 20 : true
        };

        console.log(`   📊 Moyenne: ${results[testCase.name].average}`);
        console.log(`   📈 Variance: ${results[testCase.name].variance} points`);
        console.log(`   ✅ Tous dans la plage: ${results[testCase.name].allInRange ? 'OUI' : 'NON'}`);
        console.log(`   🎯 Cohérent (var<20): ${results[testCase.name].consistency ? 'OUI' : 'NON'}\n`);
    }

    // Analyse finale
    console.log('📊 ANALYSE DE COHÉRENCE FINALE:');
    console.log('==================================\n');

    let totalTests = 0;
    let passedTests = 0;
    let consistentTests = 0;

    Object.entries(results).forEach(([name, result]) => {
        totalTests++;
        if (result.allInRange) passedTests++;
        if (result.consistency) consistentTests++;

        const status = result.allInRange && result.consistency ? '✅' : '❌';
        console.log(`${status} ${name}:`);
        console.log(`    Scores: [${result.scores.join(', ')}]`);
        console.log(`    Moyenne: ${result.average}, Variance: ${result.variance}`);
        console.log(`    Dans la plage: ${result.allInRange}, Cohérent: ${result.consistency}\n`);
    });

    console.log('🎯 RÉSUMÉ FINAL:');
    console.log(`   Tests réussis: ${passedTests}/${totalTests} (${Math.round((passedTests/totalTests)*100)}%)`);
    console.log(`   Tests cohérents: ${consistentTests}/${totalTests} (${Math.round((consistentTests/totalTests)*100)}%)`);

    if (passedTests === totalTests && consistentTests === totalTests) {
        console.log('\n🎉 SYSTÈME STABLE ET FIABLE!');
        console.log('✅ Tous les scores sont dans les plages attendues');
        console.log('✅ Variance faible entre les essais (<20 points)');
        console.log('✅ Scoring IA cohérent et prévisible');
    } else {
        console.log('\n⚠️ INSTABILITÉ DÉTECTÉE');
        console.log('Le système montre des variations importantes');
        console.log('Possible besoin d\'ajuster les prompts pour plus de cohérence');
    }

    return results;
}

testConsistency().catch(console.error);