/**
 * Script pour vérifier l'état de la migration des mots de passe
 * Affiche des statistiques sur les mots de passe migrés vs non migrés
 */

const crypto = require('crypto');

// Configuration pour détecter les mots de passe DES vs AES
const cryptoConfig = {
    password: 'EsupportL@chef@2020',
    iterations: 100000,
    salt: Buffer.from('de331012de331012', 'hex'),

    // Ancienne configuration DES
    oldIterations: 20,

    KDF: function (password, salt, iterations) {
        var pwd = Buffer.from(password, 'utf-8');
        var key = Buffer.concat([pwd, salt]);
        var i;
        for (i = 0; i < iterations; i += 1) {
            key = crypto.createHash("sha256").update(key).digest();
        }
        return key;
    },

    KDF_LEGACY: function (password, salt, iterations) {
        var pwd = Buffer.from(password, 'utf-8');
        var key = Buffer.concat([pwd, salt]);
        var i;
        for (i = 0; i < iterations; i += 1) {
            key = crypto.createHash("md5").update(key).digest();
        }
        return key;
    },

    getKeyIV: function (password, salt, iterations) {
        var key = this.KDF(password, salt, iterations);
        var keybuf = Buffer.from(key, 'binary').slice(0, 32);
        var ivbuf = Buffer.from(key, 'binary').slice(32, 48);
        return [keybuf, ivbuf];
    },

    getKeyIV_LEGACY: function (password, salt, iterations) {
        var key = this.KDF_LEGACY(password, salt, iterations);
        var keybuf = Buffer.from(key, 'binary').slice(0, 8);
        var ivbuf = Buffer.from(key, 'binary').slice(8, 16);
        return [keybuf, ivbuf];
    },

    // Test si un mot de passe est en format DES
    isDESFormat: function (encryptedPassword) {
        try {
            var encryptedBuffer = Buffer.from(encryptedPassword, 'base64');
            var kiv = this.getKeyIV_LEGACY(this.password, this.salt, this.oldIterations);
            var decipher = crypto.createDecipheriv('des', kiv[0], kiv[1]);
            var decrypted = [];
            decrypted.push(decipher.update(encryptedBuffer));
            decrypted.push(decipher.final('utf8'));
            return true; // Si on arrive ici, c'est du DES
        } catch (error) {
            return false; // Si erreur, c'est probablement du AES
        }
    },

    // Test si un mot de passe est en format AES
    isAESFormat: function (encryptedPassword) {
        try {
            var encryptedBuffer = Buffer.from(encryptedPassword, 'base64');
            var kiv = this.getKeyIV(this.password, this.salt, this.iterations);
            var decipher = crypto.createDecipheriv('aes-256-cbc', kiv[0], kiv[1]);
            var decrypted = [];
            decrypted.push(decipher.update(encryptedBuffer));
            decrypted.push(decipher.final('utf8'));
            return true; // Si on arrive ici, c'est du AES
        } catch (error) {
            return false; // Si erreur, c'est probablement du DES
        }
    }
};

async function checkMigrationStatus() {
    console.log('🔍 Vérification de l\'état de la migration des mots de passe...\n');

    try {
        // Récupérer tous les utilisateurs
        const users = await Utilisateurs.find();
        console.log(`📊 ${users.length} utilisateurs trouvés dans la base de données\n`);

        let desCount = 0;
        let aesCount = 0;
        let invalidCount = 0;
        let emptyCount = 0;

        const desUsers = [];
        const aesUsers = [];
        const invalidUsers = [];

        for (const user of users) {
            if (!user.password || user.password.length < 10) {
                emptyCount++;
                invalidUsers.push({ login: user.login, reason: 'Mot de passe vide ou trop court' });
                continue;
            }

            // Tester le format DES
            if (cryptoConfig.isDESFormat(user.password)) {
                desCount++;
                desUsers.push(user.login);
            }
            // Tester le format AES
            else if (cryptoConfig.isAESFormat(user.password)) {
                aesCount++;
                aesUsers.push(user.login);
            }
            // Format invalide
            else {
                invalidCount++;
                invalidUsers.push({ login: user.login, reason: 'Format de chiffrement invalide' });
            }
        }

        // Affichage des statistiques
        console.log('📈 Statistiques de migration :');
        console.log('='.repeat(50));
        console.log(`🔴 Mots de passe DES (à migrer) : ${desCount}`);
        console.log(`🟢 Mots de passe AES (migrés) : ${aesCount}`);
        console.log(`⚠️  Mots de passe invalides : ${invalidCount}`);
        console.log(`⚪ Mots de passe vides : ${emptyCount}`);
        console.log(`📊 Total : ${users.length}`);

        // Calcul du pourcentage de migration
        const totalValid = desCount + aesCount;
        const migrationPercentage = totalValid > 0 ? ((aesCount / totalValid) * 100).toFixed(1) : 0;

        console.log(`\n🎯 Progression de la migration : ${migrationPercentage}%`);

        if (migrationPercentage >= 100) {
            console.log('🎉 Migration terminée ! Tous les mots de passe sont en AES');
        } else if (migrationPercentage >= 80) {
            console.log('🚀 Migration presque terminée !');
        } else if (migrationPercentage >= 50) {
            console.log('📈 Migration en cours...');
        } else {
            console.log('🔄 Migration à peine commencée...');
        }

        // Détails des utilisateurs DES
        if (desUsers.length > 0) {
            console.log(`\n🔴 Utilisateurs avec mot de passe DES (${desUsers.length}) :`);
            console.log('   ' + desUsers.slice(0, 10).join(', '));
            if (desUsers.length > 10) {
                console.log(`   ... et ${desUsers.length - 10} autres`);
            }
        }

        // Détails des utilisateurs AES
        if (aesUsers.length > 0) {
            console.log(`\n🟢 Utilisateurs avec mot de passe AES (${aesUsers.length}) :`);
            console.log('   ' + aesUsers.slice(0, 10).join(', '));
            if (aesUsers.length > 10) {
                console.log(`   ... et ${aesUsers.length - 10} autres`);
            }
        }

        // Détails des utilisateurs invalides
        if (invalidUsers.length > 0) {
            console.log(`\n⚠️  Utilisateurs avec mot de passe invalide (${invalidUsers.length}) :`);
            invalidUsers.slice(0, 5).forEach(user => {
                console.log(`   - ${user.login}: ${user.reason}`);
            });
            if (invalidUsers.length > 5) {
                console.log(`   ... et ${invalidUsers.length - 5} autres`);
            }
        }

        // Recommandations
        console.log('\n💡 Recommandations :');
        if (desCount > 0) {
            console.log(`   - ${desCount} utilisateurs doivent encore se connecter pour être migrés automatiquement`);
            console.log('   - Ou exécutez le script de migration en masse : node scripts/migrate-passwords.js');
        }

        if (invalidCount > 0) {
            console.log(`   - ${invalidCount} utilisateurs ont des mots de passe invalides à corriger`);
        }

        if (aesCount === users.length) {
            console.log('   ✅ Tous les mots de passe sont migrés ! Vous pouvez désactiver le mode legacy');
        }

    } catch (error) {
        console.error('❌ Erreur lors de la vérification:', error);
        throw error;
    }
}

// Exécuter la vérification
checkMigrationStatus()
    .then(() => {
        console.log('\n✅ Vérification terminée !');
        process.exit(0);
    })
    .catch((error) => {
        console.error('\n❌ Erreur fatale:', error);
        process.exit(1);
    });
