/**
 * test-notification.js
 *
 * @description :: Tester l'envoi des notifications d'abonnement
 * @help        :: Voir http://sailsjs.com/#!/documentation/concepts/Controllers
 */

module.exports = {
    friendlyName: 'Tester les notifications d\'abonnement',

    description: 'Tester l\'envoi des notifications d\'abonnement',

    inputs: {
        codeAbonnement: {
            type: 'string',
            required: true,
            description: 'Code de l\'abonnement à tester'
        },
        typeNotification: {
            type: 'string',
            isIn: ['paiement_reussi', 'expiration_proche', 'expiration', 'essai_commence', 'abonnement_active'],
            required: true,
            description: 'Type de notification à tester'
        },
        canaux: {
            type: 'json',
            defaultsTo: ['email', 'whatsapp'],
            description: 'Canaux d\'envoi à tester'
        }
    },

    exits: {
        success: {
            description: 'Test de notification réussi',
            responseType: 'ok'
        },
        abonnementNonTrouve: {
            description: 'L\'abonnement spécifié n\'existe pas',
            responseType: 'notFound'
        }
    },

    fn: async function (inputs, exits) {
        try {
            const { id, user } = this.req.token;

            // Vérification du code école
            if (user.codeEcole === '' || user.codeEcole === null || user.codeEcole === undefined) {
                return exits.notFound({ message: "Veuillez préciser le code Ecole pour cet utilisateur pour accéder à cette page!" });
            }

            const ecoleVerif = await Ecoles.find({ codeEcole: user.codeEcole }).then(_.first);
            if (!ecoleVerif) {
                return exits.notFound({ message: "Cet utilisateur n'est attribué à aucune école!" });
            }

            // Vérifier que l'abonnement existe
            const abonnement = await Abonnement.findOne({
                codeAbonnement: inputs.codeAbonnement,
                codeEcole: user.codeEcole
            });
            if (!abonnement) {
                return exits.abonnementNonTrouve({
                    message: 'Abonnement non trouvé',
                    code: 'SUBSCRIPTION_NOT_FOUND'
                });
            }

            // Récupérer les données nécessaires
            const parent = await Parents.findOne({
                codeParent: abonnement.codeParent,
                codeEcole: user.codeEcole
            });
            if (!parent) {
                return exits.abonnementNonTrouve({
                    message: 'Parent non trouvé',
                    code: 'PARENT_NOT_FOUND'
                });
            }

            const offre = await OffreAbonnement.findOne({
                codeOffre: abonnement.codeOffre,
                codeEcole: user.codeEcole
            });
            if (!offre) {
                return exits.abonnementNonTrouve({
                    message: 'Offre non trouvée',
                    code: 'OFFRE_NOT_FOUND'
                });
            }

            // Récupérer la transaction si nécessaire
            let transaction = null;
            if (inputs.typeNotification === 'paiement_reussi') {
                transaction = await TransactionAbonnement.findOne({
                    codeAbonnement: inputs.codeAbonnement,
                    typeTransaction: 'paiement',
                    statut: 'reussi'
                }).sort('dateTransaction DESC');
            }

            // Calculer les jours restants si nécessaire
            let joursRestants = null;
            if (inputs.typeNotification === 'expiration_proche') {
                const maintenant = new Date();
                const dateFin = new Date(abonnement.dateFin);
                joursRestants = Math.ceil((dateFin - maintenant) / (1000 * 60 * 60 * 24));
            }

            // Créer la notification de test
            const notification = await NotificationAbonnement.create({
                codeEcole: user.codeEcole,
                codeAbonnement: inputs.codeAbonnement,
                codeParent: abonnement.codeParent,
                typeNotification: inputs.typeNotification,
                titre: `Test - ${inputs.typeNotification}`,
                message: `Ceci est un test de notification pour ${inputs.typeNotification}`,
                priorite: 'normale',
                statut: 'non_lue',
                canauxEnvoi: inputs.canaux,
                dateEnvoi: new Date(), // Champ requis manquant
                statutEnvoi: { // Valeur par défaut
                    push: 'non_envoye',
                    email: 'non_envoye',
                    sms: 'non_envoye'
                }
            }).fetch();

            // Envoyer la notification
            const resultat = await sails.helpers.sendAbonnementNotification.with({
                notification: notification,
                parent: parent,
                abonnement: abonnement,
                offre: offre,
                transaction: transaction,
                joursRestants: joursRestants
            });

            return exits.success({
                message: 'Test de notification réussi',
                data: {
                    notification: notification,
                    resultat: resultat,
                    parent: {
                        nom: parent.nom,
                        prenom: parent.prenom,
                        email: parent.email,
                        telephone1: parent.telephone1,
                        indicatif1: parent.indicatif1
                    },
                    abonnement: {
                        codeAbonnement: abonnement.codeAbonnement,
                        typeAbonnement: abonnement.typeAbonnement,
                        statut: abonnement.statut,
                        dateDebut: abonnement.dateDebut,
                        dateFin: abonnement.dateFin
                    },
                    offre: {
                        nom: offre.nom,
                        typeAbonnement: offre.typeAbonnement,
                        montant: offre.montant,
                        devise: offre.devise
                    }
                }
            });

        } catch (error) {
            sails.log.error('Erreur lors du test de notification:', error);
            return exits.error({
                message: 'Erreur interne du serveur',
                error: error.message
            });
        }
    }
}; 