/**
 * Helper pour traiter les notifications d'abonnement en attente
 */

module.exports = {
    friendlyName: 'Process abonnement notifications',

    inputs: {
        limit: {
            type: 'number',
            defaultsTo: 20,
            description: 'Nombre maximum de notifications à traiter'
        }
    },

    exits: {
        success: {
            description: 'Notifications traitées avec succès'
        },
        error: {
            description: 'Erreur lors du traitement'
        }
    },

    fn: async function ({ limit }, exits) {
        try {
            sails.log.info('Début du traitement des notifications d\'abonnement...');

            // === RÉCUPÉRATION DES NOTIFICATIONS EN ATTENTE (APPROCHE HYBRIDE) ===
            // Priorité 1: Notifications qui ont échoué lors de l'envoi immédiat
            // Priorité 2: Notifications non traitées
            const notificationsEnAttente = await NotificationAbonnement.find({
                statut: 'non_lue',
                nombreTentatives: { '<': 3 } // Maximum 3 tentatives
            })
                .populate('abonnement')
                .limit(limit)
                .sort('dateEnvoi ASC');

            if (notificationsEnAttente.length === 0) {
                sails.log.info('Aucune notification d\'abonnement en attente');
                return exits.success({
                    message: 'Aucune notification à traiter',
                    processed: 0
                });
            }

            sails.log.info(`${notificationsEnAttente.length} notifications d'abonnement à traiter`);

            let processedCount = 0;
            let successCount = 0;
            let errorCount = 0;

            for (const notification of notificationsEnAttente) {
                try {
                    // Récupérer les données nécessaires
                    const abonnement = await Abonnement.findOne({
                        codeAbonnement: notification.codeAbonnement,
                        codeEcole: notification.codeEcole
                    });

                    if (!abonnement) {
                        sails.log.warn(`Abonnement non trouvé pour la notification ${notification.codeNotification}`);
                        await NotificationAbonnement.updateOne({ codeNotification: notification.codeNotification })
                            .set({
                                statut: 'echoue',
                                erreurEnvoi: 'Abonnement non trouvé',
                                nombreTentatives: notification.nombreTentatives + 1
                            });
                        errorCount++;
                        continue;
                    }

                    const parent = await Parents.findOne({
                        codeParent: notification.codeParent,
                        codeEcole: notification.codeEcole
                    });

                    if (!parent) {
                        sails.log.warn(`Parent non trouvé pour la notification ${notification.codeNotification}`);
                        await NotificationAbonnement.updateOne({ codeNotification: notification.codeNotification })
                            .set({
                                statut: 'echoue',
                                erreurEnvoi: 'Parent non trouvé',
                                nombreTentatives: notification.nombreTentatives + 1
                            });
                        errorCount++;
                        continue;
                    }

                    const offre = await OffreAbonnement.findOne({
                        codeOffre: abonnement.codeOffre,
                       // codeEcole: notification.codeEcole
                    });

                    if (!offre) {
                        sails.log.warn(`Offre non trouvée pour la notification ${notification.codeNotification}`);
                        await NotificationAbonnement.updateOne({ codeNotification: notification.codeNotification })
                            .set({
                                statut: 'echoue',
                                erreurEnvoi: 'Offre non trouvée',
                                nombreTentatives: notification.nombreTentatives + 1
                            });
                        errorCount++;
                        continue;
                    }

                    // Récupérer la transaction si c'est une notification de paiement
                    let transaction = null;
                    if (notification.typeNotification === 'paiement_reussi') {
                        const transactions = await TransactionAbonnement.find({
                            codeEcole: notification.codeEcole,
                            codeAbonnement: notification.codeAbonnement,
                            typeTransaction: 'paiement',
                            statut: 'reussi'
                        }).sort('dateTransaction DESC').limit(1);
                        transaction = transactions[0] || null;
                    }

                    // Calculer les jours restants si c'est une notification d'expiration proche
                    let joursRestants = null;
                    if (notification.typeNotification === 'expiration_proche') {
                        const maintenant = new Date();
                        const dateFin = new Date(abonnement.dateFin);
                        joursRestants = Math.ceil((dateFin - maintenant) / (1000 * 60 * 60 * 24));
                    }

                    // === ENVOI DIFFÉRÉ DE LA NOTIFICATION (APPROCHE HYBRIDE) ===
                    sails.log.info(`Tentative d'envoi différé de la notification ${notification.codeNotification} (tentative ${notification.nombreTentatives + 1}/3)...`);

                    await sails.helpers.sendAbonnementNotification.with({
                        notification: notification,
                        parent: parent,
                        abonnement: abonnement,
                        offre: offre,
                        transaction: transaction,
                        joursRestants: joursRestants
                    });

                    successCount++;
                    sails.log.info(`✅ Notification ${notification.codeNotification} envoyée avec succès (traitement différé)`);

                } catch (error) {
                    errorCount++;
                    sails.log.error(`Erreur lors du traitement de la notification ${notification.codeNotification}:`, error);

                    // Mettre à jour le statut d'erreur
                    await NotificationAbonnement.updateOne({ codeNotification: notification.codeNotification })
                        .set({
                            statut: 'echoue',
                            erreurEnvoi: error.message,
                            nombreTentatives: notification.nombreTentatives + 1,
                            dateDerniereTentative: new Date()
                        });
                }

                processedCount++;
            }

            sails.log.info(`Traitement terminé: ${processedCount} traitées, ${successCount} succès, ${errorCount} erreurs`);

            return exits.success({
                message: 'Traitement des notifications terminé',
                processed: processedCount,
                success: successCount,
                errors: errorCount
            });

        } catch (error) {
            sails.log.error('Erreur dans process-abonnement-notifications:', error);
            return exits.error(error);
        }
    }
}; 