/**
 * Script de migration au démarrage de l'application
 * Peut être exécuté manuellement ou au démarrage pour migrer les mots de passe
 */

const crypto = require('crypto');

// Configuration pour la migration DES vers 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];
    },

    // Déchiffrer avec l'ancien algorithme DES
    decryptDES: function (payload) {
        try {
            var encryptedBuffer = Buffer.from(payload, '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 decrypted.join('');
        } catch (error) {
            throw error;
        }
    },

    // Chiffrer avec le nouvel algorithme AES
    encryptAES: function (payload) {
        try {
            var kiv = this.getKeyIV(this.password, this.salt, this.iterations);
            var cipher = crypto.createCipheriv('aes-256-cbc', kiv[0], kiv[1]);
            var encrypted = [];
            encrypted.push(cipher.update(payload, 'utf-8', 'hex'));
            encrypted.push(cipher.final('hex'));
            return Buffer.from(encrypted.join(''), 'hex').toString('base64');
        } catch (error) {
            throw error;
        }
    }
};

async function startupMigration() {
    console.log('🚀 Début de la migration au démarrage...\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`);

        let migratedCount = 0;
        let errorCount = 0;
        let skippedCount = 0;

        for (const user of users) {
            try {
                // Vérifier si le mot de passe est déjà en AES (nouveau format)
                if (!user.password || user.password.length < 10) {
                    console.log(`⚠️  Utilisateur ${user.login}: Mot de passe vide ou trop court, ignoré`);
                    skippedCount++;
                    continue;
                }

                // Essayer de déchiffrer avec l'ancien algorithme DES
                try {
                    const plainPassword = cryptoConfig.decryptDES(user.password);

                    // Re-chiffrer avec le nouvel algorithme AES
                    const newEncryptedPassword = cryptoConfig.encryptAES(plainPassword);

                    // Mettre à jour l'utilisateur
                    await Utilisateurs.updateOne({ id: user.id })
                        .set({ password: newEncryptedPassword });

                    console.log(`✅ Utilisateur ${user.login}: Mot de passe migré avec succès`);
                    migratedCount++;

                } catch (decryptError) {
                    // Si le déchiffrement DES échoue, le mot de passe est peut-être déjà en AES
                    console.log(`ℹ️  Utilisateur ${user.login}: Mot de passe déjà en format AES ou invalide`);
                    skippedCount++;
                }

            } catch (error) {
                console.log(`❌ Erreur pour l'utilisateur ${user.login}:`, error.message);
                errorCount++;
            }
        }

        // Résumé de la migration
        console.log('\n📊 Résumé de la migration au démarrage:');
        console.log('='.repeat(50));
        console.log(`✅ Migrés avec succès: ${migratedCount}`);
        console.log(`⚠️  Ignorés: ${skippedCount}`);
        console.log(`❌ Erreurs: ${errorCount}`);
        console.log(`📈 Total traité: ${users.length}`);

        if (migratedCount > 0) {
            console.log('\n🎉 Migration au démarrage terminée avec succès !');
            console.log('💡 Les utilisateurs peuvent maintenant se connecter avec Node.js 17+');
        } else {
            console.log('\nℹ️  Aucun mot de passe n\'a été migré au démarrage');
            console.log('💡 La migration se fera automatiquement lors des connexions');
        }

        return {
            migratedCount,
            skippedCount,
            errorCount,
            totalUsers: users.length
        };

    } catch (error) {
        console.error('❌ Erreur lors de la migration au démarrage:', error);
        throw error;
    }
}

// Exporter la fonction pour utilisation dans bootstrap.js
module.exports = startupMigration;

// Si le script est exécuté directement
if (require.main === module) {
    startupMigration()
        .then(() => {
            console.log('\n✅ Script de migration au démarrage terminé');
            process.exit(0);
        })
        .catch((error) => {
            console.error('\n❌ Erreur fatale:', error);
            process.exit(1);
        });
}
