/**
 * Script d'import des données d'abonnement
 * Permet d'importer les offres et promotions depuis un fichier d'export
 */

module.exports = async function () {
    sails.log.info('📥 Import des données d\'abonnement...');

    try {
        const fs = require('fs');
        const path = require('path');

        // Chercher le fichier d'export le plus récent
        const exportDir = path.join(__dirname, '..', 'exports');
        if (!fs.existsSync(exportDir)) {
            throw new Error('Dossier exports non trouvé. Exécutez d\'abord le script d\'export.');
        }

        const files = fs.readdirSync(exportDir)
            .filter(file => file.startsWith('abonnements-export-') && file.endsWith('.json'))
            .sort()
            .reverse();

        if (files.length === 0) {
            throw new Error('Aucun fichier d\'export trouvé dans le dossier exports.');
        }

        const latestFile = files[0];
        const exportPath = path.join(exportDir, latestFile);
        sails.log.info(`📁 Fichier d'import: ${latestFile}`);

        // Lire le fichier d'export
        const exportData = JSON.parse(fs.readFileSync(exportPath, 'utf8'));

        sails.log.info(`📊 Données à importer:`);
        sails.log.info(`   - Offres: ${exportData.offres?.length || 0}`);
        sails.log.info(`   - Promotions: ${exportData.promotions?.length || 0}`);
        sails.log.info(`   - Version: ${exportData.metadata?.version || 'N/A'}`);
        sails.log.info(`   - Date: ${exportData.metadata?.timestamp || 'N/A'}`);

        // Demander confirmation (en mode interactif)
        if (process.env.NODE_ENV !== 'production') {
            sails.log.info('⚠️  Mode développement - import automatique');
        } else {
            sails.log.warn('⚠️  Mode production - vérifiez les données avant import');
        }

        // 1. Importer les offres
        if (exportData.offres && exportData.offres.length > 0) {
            sails.log.info('\n🏷️  Import des offres...');

            for (const offreData of exportData.offres) {
                try {
                    // Vérifier si l'offre existe déjà
                    const existingOffre = await OffreAbonnement.findOne({
                        nom: offreData.nom,
                        typeAbonnement: offreData.typeAbonnement
                    });

                    if (existingOffre) {
                        // Mettre à jour l'offre existante
                        await OffreAbonnement.updateOne({ id: existingOffre.id })
                            .set({
                                description: offreData.description,
                                dureeJours: offreData.dureeJours,
                                montant: offreData.montant,
                                devise: offreData.devise,
                                fonctionnalites: offreData.fonctionnalites,
                                icone: offreData.icone,
                                ordreAffichage: offreData.ordreAffichage,
                                couleur: offreData.couleur,
                                actif: offreData.actif,
                                updatedAt: new Date()
                            });
                        sails.log.info(`✅ Offre mise à jour: ${offreData.nom}`);
                    } else {
                        // Créer une nouvelle offre
                        const newOffre = await OffreAbonnement.create({
                            nom: offreData.nom,
                            description: offreData.description,
                            typeAbonnement: offreData.typeAbonnement,
                            dureeJours: offreData.dureeJours,
                            montant: offreData.montant,
                            devise: offreData.devise,
                            fonctionnalites: offreData.fonctionnalites,
                            icone: offreData.icone,
                            ordreAffichage: offreData.ordreAffichage,
                            couleur: offreData.couleur,
                            actif: offreData.actif
                        }).fetch();
                        sails.log.info(`🆕 Nouvelle offre créée: ${newOffre.nom} (${newOffre.codeOffre})`);
                    }
                } catch (error) {
                    sails.log.error(`❌ Erreur lors de l'import de l'offre ${offreData.nom}:`, error.message);
                }
            }
        }

        // 2. Importer les promotions
        if (exportData.promotions && exportData.promotions.length > 0) {
            sails.log.info('\n🎁 Import des promotions...');

            for (const promoData of exportData.promotions) {
                try {
                    // Vérifier si la promotion existe déjà
                    const existingPromo = await PromotionAbonnement.findOne({
                        nom: promoData.nom,
                        typeReduction: promoData.typeReduction
                    });

                    if (existingPromo) {
                        // Mettre à jour la promotion existante
                        await PromotionAbonnement.updateOne({ id: existingPromo.id })
                            .set({
                                description: promoData.description,
                                valeurReduction: promoData.valeurReduction,
                                devise: promoData.devise,
                                dateDebut: promoData.dateDebut,
                                dateFin: promoData.dateFin,
                                nombreUtilisationsMax: promoData.nombreUtilisationsMax,
                                nombreUtilisationsParParent: promoData.nombreUtilisationsParParent,
                                montantMinimum: promoData.montantMinimum,
                                couleur: promoData.couleur,
                                actif: promoData.actif,
                                updatedAt: new Date()
                            });
                        sails.log.info(`✅ Promotion mise à jour: ${promoData.nom}`);
                    } else {
                        // Créer une nouvelle promotion
                        const newPromo = await PromotionAbonnement.create({
                            nom: promoData.nom,
                            description: promoData.description,
                            typeReduction: promoData.typeReduction,
                            valeurReduction: promoData.valeurReduction,
                            devise: promoData.devise,
                            dateDebut: promoData.dateDebut,
                            dateFin: promoData.dateFin,
                            nombreUtilisationsMax: promoData.nombreUtilisationsMax,
                            nombreUtilisationsActuelles: 0,
                            nombreUtilisationsParParent: promoData.nombreUtilisationsParParent,
                            montantMinimum: promoData.montantMinimum,
                            couleur: promoData.couleur,
                            parentsUtilises: [],
                            actif: promoData.actif
                        }).fetch();
                        sails.log.info(`🆕 Nouvelle promotion créée: ${newPromo.nom} (${newPromo.codePromotion})`);
                    }
                } catch (error) {
                    sails.log.error(`❌ Erreur lors de l'import de la promotion ${promoData.nom}:`, error.message);
                }
            }
        }

        // 3. Vérification finale
        const totalOffres = await OffreAbonnement.count({ actif: true });
        const totalPromotions = await PromotionAbonnement.count({ actif: true });

        sails.log.info('\n🎉 Import terminé avec succès!');
        sails.log.info(`📊 Résumé final:`);
        sails.log.info(`   - Offres actives: ${totalOffres}`);
        sails.log.info(`   - Promotions actives: ${totalPromotions}`);

        return {
            success: true,
            importedOffres: exportData.offres?.length || 0,
            importedPromotions: exportData.promotions?.length || 0,
            totalOffres,
            totalPromotions
        };

    } catch (error) {
        sails.log.error('❌ Erreur lors de l\'import:', error);
        throw error;
    }
};

