/**
 * Helper pour envoyer les notifications d'abonnement
 */

module.exports = {
    friendlyName: 'Send abonnement notification',

    inputs: {
        notification: {
            type: 'ref',
            required: true,
            description: 'Objet notification d\'abonnement'
        },
        // Utilisateur (prioritaire pour coordonnées)
        user: {
            type: 'ref',
            description: 'Objet Utilisateurs (coordonnées à jour)'
        },
        // Parent (fallback si user absent)
        parent: {
            type: 'ref',
            description: 'Objet Parents (fallback coordonnées)'
        },
        abonnement: {
            type: 'ref',
            required: true,
            description: 'Objet abonnement'
        },
        offre: {
            type: 'ref',
            required: true,
            description: 'Objet offre d\'abonnement'
        },
        transaction: {
            type: 'ref',
            description: 'Objet transaction (pour les notifications de paiement)'
        },
        joursRestants: {
            type: 'number',
            description: 'Nombre de jours restants (pour les notifications d\'expiration)'
        }
    },

    exits: {
        success: {
            description: 'Notification envoyée avec succès'
        },
        error: {
            description: 'Erreur lors de l\'envoi'
        }
    },

    fn: async function ({ notification, user, parent, abonnement, offre, transaction, joursRestants }, exits) {
        try {
            const templates = sails.config.abonnementTemplates;
            let emailSent = false;
            let whatsappSent = false;
            let smsSent = false;

            const person = user || parent || {};
            const contactEmail = person.email || null;
            const phoneIndicatif = person.indicatif1 || '';
            const phoneNumberRaw = person.telephone1 || null;
            const phoneFull = phoneNumberRaw ? `${phoneIndicatif}${phoneNumberRaw}` : null;
            const displayNom = [person.nom, person.prenom].filter(Boolean).join(' ').trim() || 'Client';

            // Déterminer le type de notification
            let templateType;
            switch (notification.typeNotification) {
                case 'paiement_reussi':
                    templateType = 'paiementReussi';
                    break;
                case 'expiration_proche':
                    templateType = 'expirationProche';
                    break;
                case 'expiration':
                    templateType = 'abonnementExpire';
                    break;
                case 'essai_commence':
                    templateType = 'essaiCommence';
                    break;
                case 'abonnement_active':
                    templateType = 'abonnementActive';
                    break;
                default:
                    sails.log.warn(`Type de notification non géré: ${notification.typeNotification}`);
                    return exits.success();
            }

            // Envoyer par email si disponible
            if (contactEmail && notification.canauxEnvoi.includes('email')) {
                try {
                    const emailTemplate = templates.email[templateType];
                    let emailData;

                    if (templateType === 'paiementReussi') {
                        emailData = emailTemplate(person, abonnement, offre, transaction);
                    } else if (templateType === 'expirationProche') {
                        emailData = emailTemplate(person, abonnement, offre, joursRestants);
                    } else {
                        emailData = emailTemplate(person, abonnement, offre);
                    }

                    await sails.helpers.sendMailjetEmail.with({
                        to: contactEmail,
                        subject: emailData.subject,
                        html: emailData.html,
                        nameDestinataire: displayNom
                    });

                    emailSent = true;
                    sails.log.info(`Email d'abonnement envoyé à ${contactEmail} pour ${notification.typeNotification}`);
                } catch (emailError) {
                    sails.log.error(`Erreur envoi email abonnement à ${contactEmail}:`, emailError);
                }
            }

            // Envoyer par WhatsApp si dispo (priorité sur SMS)
            if (phoneFull && notification.canauxEnvoi.includes('whatsapp')) {
                try {
                    const whatsappTemplate = templates.whatsapp[templateType];
                    let whatsappText;

                    if (templateType === 'paiementReussi') {
                        whatsappText = whatsappTemplate(person, abonnement, offre, transaction);
                    } else if (templateType === 'expirationProche') {
                        whatsappText = whatsappTemplate(person, abonnement, offre, joursRestants);
                    } else {
                        whatsappText = whatsappTemplate(person, abonnement, offre);
                    }

                    await sails.helpers.sendWhatsappMessage.with({
                        to: phoneFull,
                        text: whatsappText
                    });

                    whatsappSent = true;
                    sails.log.info(`WhatsApp d'abonnement envoyé à ${phoneFull} pour ${notification.typeNotification}`);
                } catch (whatsappError) {
                    sails.log.error(`Erreur envoi WhatsApp abonnement à ${phoneFull}:`, whatsappError);
                }
            }

            // Envoyer par SMS si WhatsApp non envoyé
            if (!whatsappSent && phoneFull && notification.canauxEnvoi.includes('sms')) {
                try {
                    const smsTemplate = templates.sms[templateType];
                    let smsText;

                    if (templateType === 'paiementReussi') {
                        smsText = smsTemplate(person, abonnement, offre, transaction);
                    } else if (templateType === 'expirationProche') {
                        smsText = smsTemplate(person, abonnement, offre, joursRestants);
                    } else {
                        smsText = smsTemplate(person, abonnement, offre);
                    }

                    if (sails.helpers.sendTwilioSms) {
                        await sails.helpers.sendTwilioSms.with({
                            to: phoneFull,
                            message: smsText
                        });
                    } else {
                        sails.log.warn('Helper SMS non disponible, SMS non envoyé');
                    }

                    smsSent = true;
                    sails.log.info(`SMS d'abonnement envoyé à ${phoneFull} pour ${notification.typeNotification}`);
                } catch (smsError) {
                    sails.log.error(`Erreur envoi SMS abonnement à ${phoneFull}:`, smsError);
                }
            }

            // Mettre à jour le statut de la notification
            const statutEnvoi = {
                email: emailSent ? 'envoye' : 'non_envoye',
                whatsapp: whatsappSent ? 'envoye' : 'non_envoye',
                sms: smsSent ? 'envoye' : 'non_envoye'
            };

            const statutGlobal = emailSent || whatsappSent || smsSent ? 'envoyee' : 'echoue';

            await NotificationAbonnement.updateOne({ codeNotification: notification.codeNotification })
                .set({
                    statut: statutGlobal,
                    statutEnvoi: statutEnvoi,
                    dateDerniereTentative: new Date(),
                    nombreTentatives: (notification.nombreTentatives || 0) + 1
                });

            if (statutGlobal === 'envoyee') {
                return exits.success({
                    message: 'Notification envoyée avec succès',
                    channels: {
                        email: emailSent,
                        whatsapp: whatsappSent,
                        sms: smsSent
                    }
                });
            } else {
                return exits.error({
                    message: 'Aucun canal d\'envoi disponible ou tous les envois ont échoué',
                    channels: {
                        email: emailSent,
                        whatsapp: whatsappSent,
                        sms: smsSent
                    }
                });
            }

        } catch (error) {
            sails.log.error('Erreur dans send-abonnement-notification:', error);

            try {
                await NotificationAbonnement.updateOne({ codeNotification: notification.codeNotification })
                    .set({
                        statut: 'echoue',
                        erreurEnvoi: error.message,
                        dateDerniereTentative: new Date(),
                        nombreTentatives: (notification.nombreTentatives || 0) + 1
                    });
            } catch (e) { }

            return exits.error(error);
        }
    }
}; 