const updateTemplates = require('./email/update-reminder'); // Nouveau template
const templates = require('./email/login-reminder');

module.exports.cron = {
    //ceci pour la vérification et création liste d'attente chaque minute
    //startupUserCheck: {
    // schedule: '0 */1 * * * *', // Toutes les minutes (pour les tests)
    /* runOnStartup: true,
     onTick: async () => {
         try {
             // Vérifier si le traitement est déjà en cours
             if (sails.config.startupCheckRunning) return;
             sails.config.startupCheckRunning = true;

             sails.log.info('Démarrage: Vérification des utilisateurs non mis à jour...');
             await sails.helpers.processStartupReminders();

             sails.config.startupCheckRunning = false;
         } catch (err) {
             sails.config.startupCheckRunning = false;
             sails.log.error('Startup reminder error:', err);
         }
     }
 },*/

    //Ceci pour l'ancer la vérification chaque debut de mois et créer l'attente
    monthlyUserCheck: {
        active: false,
        schedule: '0 0 1 * *',
        onTick: async () => {
            sails.log.info('Monthly check running...');
            try {
                await sails.helpers.processMonthlyReminders();
            } catch (err) {
                sails.log.error('Monthly reminder error:', err);
            }
        }
    },

    //Ceci pour l'envoi chaque heure de la notification en attente
    hourlySender: {
        schedule: '0 * * * *',
        onTick: async () => {
            try {
                await sails.helpers.processHourlyReminders();
            } catch (err) {
                sails.log.error('Hourly sender error:', err);
            }
        }
    },

    // Ceci pour la suppression de la liste de notification a la fin du mois pour en générer autre
    cleanupNotifications: {
        schedule: '0 0 1 * *',
        onTick: async () => {
            try {
                await sails.helpers.cleanupOldNotifications();
            } catch (err) {
                sails.log.error('Cleanup error:', err);
            }
        }
    },

    // Traitement des notifications d'abonnement toutes les 15 minutes
    abonnementNotifications: {
        schedule: '*/15 * * * *', // Toutes les 15 minutes
        onTick: async () => {
            try {
                sails.log.info('Démarrage du traitement des notifications d\'abonnement...');
                await sails.helpers.processAbonnementNotifications();
            } catch (err) {
                sails.log.error('Erreur traitement notifications abonnement:', err);
            }
        }
    },

    // Vérification quotidienne des abonnements expirés
    checkExpiredAbonnements: {
        schedule: '0 8 * * *', // Tous les jours à 8h00
        onTick: async () => {
            try {
                sails.log.info('Vérification des abonnements expirés...');

                const maintenant = new Date();
                const abonnementsActifs = await Abonnement.find({
                    statut: { in: ['actif', 'essai'] }
                });

                for (const abonnement of abonnementsActifs) {
                    const dateFin = new Date(abonnement.dateFin);

                    // Si l'abonnement a expiré
                    if (maintenant > dateFin) {
                        // Mettre à jour le statut
                        await Abonnement.updateOne({ codeAbonnement: abonnement.codeAbonnement })
                            .set({ statut: 'expire' });

                        // Créer une notification d'expiration
                        await NotificationAbonnement.create({
                            codeEcole: abonnement.codeEcole,
                            codeAbonnement: abonnement.codeAbonnement,
                            codeParent: abonnement.codeParent,
                            typeNotification: 'expiration',
                            titre: 'Abonnement expiré',
                            message: 'Votre abonnement a expiré. Veuillez le renouveler pour continuer à bénéficier de nos services.',
                            priorite: 'haute',
                            statut: 'non_lue'
                        });

                        sails.log.info(`Abonnement ${abonnement.codeAbonnement} marqué comme expiré`);
                    }
                    // Si l'abonnement expire dans 7 jours ou moins
                    else {
                        const joursRestants = Math.ceil((dateFin - maintenant) / (1000 * 60 * 60 * 24));

                        if (joursRestants <= 7 && joursRestants > 0) {
                            // Vérifier si une notification d'expiration proche a déjà été envoyée
                            const notificationExistante = await NotificationAbonnement.findOne({
                                codeEcole: abonnement.codeEcole,
                                codeAbonnement: abonnement.codeAbonnement,
                                typeNotification: 'expiration_proche',
                                statut: 'envoyee'
                            });

                            if (!notificationExistante) {
                                await NotificationAbonnement.create({
                                    codeEcole: abonnement.codeEcole,
                                    codeAbonnement: abonnement.codeAbonnement,
                                    codeParent: abonnement.codeParent,
                                    typeNotification: 'expiration_proche',
                                    titre: 'Expiration proche',
                                    message: `Votre abonnement expire dans ${joursRestants} jour(s). Pensez à le renouveler !`,
                                    priorite: 'normale',
                                    statut: 'non_lue'
                                });

                                sails.log.info(`Notification d'expiration proche créée pour l'abonnement ${abonnement.codeAbonnement}`);
                            }
                        }
                    }
                }

                sails.log.info('Vérification des abonnements expirés terminée');
            } catch (err) {
                sails.log.error('Erreur vérification abonnements expirés:', err);
            }
        }
    },

    /// Ceci pour l'envoi chaque minutes
    //immediateReminders: {
    //schedule: '*/1 * * * *', // Toutes les minutes
    /* onTick: async () => {
         try {
             const now = new Date();
             const pending = await PendingNotification.find({
                 where: {
                     status: 'pending',
                     scheduledDate: { '<=': now }
                 },
                 limit: 20
             }).populate('user');

             // ... même logique d'envoi que process-hourly-reminders
             /*for (const notif of pending) {
                 console.log('USER CONCERNE', notif, notif.user)
                 const user = await Utilisateurs.findOne({ id: notif.user.id });
                 if (!user) continue;
                 try {
                     const baseUrl = sails.config.externalApis.baseUrl;

                     // CAS SPÉCIFIQUE POUR LES RAPPELS DE MISE À JOUR
                     if (notif.type === 'update_reminder') {
                         if (notif.channel === 'email' && notif.user.email) {
                             const { subject, html } = templates.emailTemplate(notif.user, baseUrl);
                             await sails.helpers.sendMailjetEmail.with({
                                 to: notif.user.email,
                                 subject,
                                 html,
                                 nameDestinataire: notif.user.nom
                             });
                         }
                         else if (notif.channel === 'whatsapp' && notif.user.telephone1) {
                             const { text } = templates.whatsappTemplate(notif.user, baseUrl);
                             await sails.helpers.sendWhatsappMessage.with({
                                 to: notif.user.telephone1,
                                 text
                             });
                         }

                         // Marquer l'utilisateur comme notifié
                         await Utilisateurs.updateOne({ id: notif.user.id })
                             .set({ lastUpdateReminderSentAt: new Date() });
                     }
                     // CAS ORIGINAL POUR LES AUTRES NOTIFICATIONS
                     else {
                         if (notif.channel === 'email' && notif.user.email) {
                             const { subject, html, nameDestinataire } = templates.emailTemplate(notif.user, baseUrl);
                             await sails.helpers.sendMailjetEmail.with({
                                 to: notif.user.email,
                                 subject,
                                 html,
                                 nameDestinataire
                             });
                         }
                         else if (notif.channel === 'whatsapp' && notif.user.telephone1) {
                             const { text } = templates.whatsappTemplate(notif.user, baseUrl);
                             await sails.helpers.sendWhatsappMessage.with({
                                 to: notif.user.telephone1,
                                 text
                             });
                         }

                         await Utilisateurs.updateOne({ id: notif.user.id })
                             .set({ lastReminderSentAt: new Date() });
                     }

                     // Mettre à jour la notification dans tous les cas
                     await PendingNotification.updateOne({ id: notif.id })
                         .set({ status: 'sent' });

                 } catch (err) {
                     await PendingNotification.updateOne({ id: notif.id })
                         .set({ status: 'failed' });

                     sails.log.error(`Échec envoi ${notif.channel} à ${notif.user.id}:`, err);
                 }
             }/

         } catch (err) {
             sails.log.error('Immediate reminder error:', err);
         }
     }
 }*/
};