// === SCRIPT DE VÉRIFICATION APPLICATION RÉELLE ===

// Test que tous les composants fonctionnent ensemble dans l'app réelle
async function verifyRealApplication() {
    console.log('🔍 Vérification de l\'application réelle...\n');

    const tests = [];

    // Test 1: Vérifier que AppNavigation existe et est initialisé
    tests.push({
        name: 'AppNavigation disponible',
        test: () => window.AppNavigation && typeof window.AppNavigation.init === 'function',
        critical: true
    });

    // Test 2: Vérifier que le système de compatibilité est intégré
    tests.push({
        name: 'Système de compatibilité intégré',
        test: () => window.AppNavigation && window.AppNavigation.compatibilityChecker,
        critical: true
    });

    // Test 3: Vérifier que ContentScanner est opérationnel
    tests.push({
        name: 'ContentScanner opérationnel',
        test: () => window.AppNavigation && window.AppNavigation.contentScanner,
        critical: true
    });

    // Test 4: Vérifier que GameLoader existe
    tests.push({
        name: 'GameLoader disponible',
        test: () => window.GameLoader && typeof window.GameLoader.loadGame === 'function',
        critical: true
    });

    // Test 5: Vérifier que les modules de jeu sont chargés
    tests.push({
        name: 'Modules de jeu chargés',
        test: () => window.GameModules && Object.keys(window.GameModules).length > 0,
        critical: false
    });

    // Test 6: Vérifier que les modules de contenu sont chargés
    tests.push({
        name: 'Modules de contenu chargés',
        test: () => window.ContentModules && Object.keys(window.ContentModules).length > 0,
        critical: false
    });

    // Test 7: Vérifier que showGamesPage est async
    tests.push({
        name: 'showGamesPage est async',
        test: () => {
            const fn = window.AppNavigation.showGamesPage;
            return fn && fn.constructor.name === 'AsyncFunction';
        },
        critical: true
    });

    // Test 8: Vérifier les CSS de compatibilité
    tests.push({
        name: 'CSS de compatibilité chargé',
        test: () => {
            const sheets = Array.from(document.styleSheets);
            return sheets.some(sheet => {
                try {
                    const rules = Array.from(sheet.cssRules || []);
                    return rules.some(rule => rule.selectorText && rule.selectorText.includes('compatibility-badge'));
                } catch (e) {
                    return false;
                }
            });
        },
        critical: false
    });

    // Exécuter tous les tests
    let passedTests = 0;
    let criticalFailed = 0;

    console.log('📋 Résultats des tests:\n');

    for (const test of tests) {
        try {
            const result = test.test();
            if (result) {
                console.log(`✅ ${test.name}`);
                passedTests++;
            } else {
                const level = test.critical ? 'CRITIQUE' : 'OPTIONNEL';
                console.log(`❌ ${test.name} (${level})`);
                if (test.critical) criticalFailed++;
            }
        } catch (error) {
            const level = test.critical ? 'CRITIQUE' : 'OPTIONNEL';
            console.log(`🚨 ${test.name} - ERREUR: ${error.message} (${level})`);
            if (test.critical) criticalFailed++;
        }
    }

    console.log(`\n📊 Résultat: ${passedTests}/${tests.length} tests réussis`);

    if (criticalFailed === 0) {
        console.log('🎉 Tous les tests critiques passent! L\'application est prête.');

        // Test bonus: essayer de charger du contenu
        if (window.AppNavigation && window.AppNavigation.contentScanner) {
            console.log('\n🔍 Test bonus: chargement du contenu...');
            try {
                const results = await window.AppNavigation.contentScanner.scanAllContent();
                console.log(`✅ ${results.found.length} modules de contenu détectés`);

                // Test de compatibilité sur contenu réel
                if (results.found.length > 0 && window.AppNavigation.compatibilityChecker) {
                    const testContent = results.found[0];
                    const compatibility = window.AppNavigation.compatibilityChecker.checkCompatibility(testContent, 'whack-a-mole');
                    console.log(`✅ Test compatibilité: ${compatibility.compatible ? 'COMPATIBLE' : 'INCOMPATIBLE'} (${compatibility.score}%)`);
                }
            } catch (error) {
                console.log(`⚠️ Erreur lors du test bonus: ${error.message}`);
            }
        }

        return true;
    } else {
        console.log(`❌ ${criticalFailed} tests critiques ont échoué. Vérification nécessaire.`);
        return false;
    }
}

// Fonction d'auto-test
function autoVerify() {
    // Attendre que l'app soit complètement chargée
    if (document.readyState !== 'complete') {
        window.addEventListener('load', () => setTimeout(verifyRealApplication, 2000));
    } else {
        setTimeout(verifyRealApplication, 2000);
    }
}

// Export pour utilisation manuelle
window.verifyRealApplication = verifyRealApplication;

// Auto-vérification si ce script est chargé dans l'app réelle
if (typeof window !== 'undefined' && window.location.pathname === '/') {
    autoVerify();
}