/**
 * update.js
 *
 * @description :: Mettre à jour un abonnement existant
 * @help        :: Voir http://sailsjs.com/#!/documentation/concepts/Controllers
 */

module.exports = {
    friendlyName: 'Mettre à jour un abonnement',

    description: 'Mettre à jour un abonnement existant',

    inputs: {
        codeAbonnement: {
            type: 'string',
            required: true,
            description: 'Code de l\'abonnement à mettre à jour'
        },
        statut: {
            type: 'string',
            isIn: ['actif', 'expire', 'suspendu', 'annule', 'en_attente_paiement', 'essai'],
            allowNull: true,
            description: 'Nouveau statut de l\'abonnement'
        },
        dateFin: {
            type: 'string',
            allowNull: true,
            description: 'Nouvelle date de fin (format YYYY-MM-DD)'
        },
        renouvellementAuto: {
            type: 'boolean',
            allowNull: true,
            description: 'Activer/désactiver le renouvellement automatique'
        },
        methodePaiement: {
            type: 'string',
            isIn: ['mobile_money', 'carte_bancaire', 'virement', 'especes', 'gratuit'],
            allowNull: true,
            description: 'Nouvelle méthode de paiement'
        },
        referencePaiement: {
            type: 'string',
            allowNull: true,
            description: 'Référence de paiement'
        },
        datePaiement: {
            type: 'string',
            allowNull: true,
            description: 'Date de paiement (format YYYY-MM-DD)'
        },
        commentaires: {
            type: 'string',
            allowNull: true,
            description: 'Nouveaux commentaires'
        }
    },

    exits: {
        success: {
            description: 'Abonnement mis à jour avec succès',
            responseType: 'ok'
        },
        abonnementNonTrouve: {
            description: 'L\'abonnement spécifié n\'existe pas',
            responseType: 'notFound'
        },
        invalidDate: {
            description: 'Format de date invalide',
            responseType: 'badRequest'
        },
        statutInvalide: {
            description: 'Transition de statut invalide',
            responseType: 'badRequest'
        }
    },

    fn: async function (inputs, exits) {
        const { id, user } = this.req.token;
        // console.log("ID", id, user.login, user.typeUser, user.codeEcole)
        // VERIFICATION DU CODE ECOLE
        if (user.codeEcole === '' || user.codeEcole === null || user.codeEcole === undefined) {
            return exits.notFound({ message: "Veuillez préciser le code Ecole pour cet utulisateur pour a accéder a cette page!" })
        }
        ecoleVerif = await Ecoles.find({ codeEcole: user.codeEcole }).then(_.first)
        if (!ecoleVerif) {
            return exits.notFound({ message: "Cet utilisateur n'est attribué a aucune classe!" })
        }
        // FIN VERIF CODE ECOLE
        let userCodeEcole;
        if (user.typeUser === 'ADMINISTRATION' || user.typeUser === 'SECRETARIAT') {
            userCodeEcole = user.codeEcole
        } else if (user.typeUser === 'ADMIN') {
            userCodeEcole = undefined
        } else {
            return exits.notFound({ message: "Vous n'etes pas autoriser a accéder a cette page!" })

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

            // Préparer les données de mise à jour
            const updateData = {};

            // Gestion du statut
            if (inputs.statut && inputs.statut !== abonnement.statut) {
                // Vérifier les transitions de statut autorisées
                const transitionsAutorisees = {
                    'en_attente_paiement': ['actif', 'annule'],
                    'essai': ['actif', 'expire', 'annule'],
                    'actif': ['suspendu', 'expire', 'annule'],
                    'suspendu': ['actif', 'expire', 'annule'],
                    'expire': ['actif', 'annule'],
                    'annule': [] // Aucune transition possible depuis annulé
                };

                const transitionsPossibles = transitionsAutorisees[abonnement.statut] || [];
                if (!transitionsPossibles.includes(inputs.statut)) {
                    return exits.statutInvalide({
                        message: `Transition de statut non autorisée de ${abonnement.statut} vers ${inputs.statut}`,
                        code: 'INVALID_STATUS_TRANSITION',
                        transitionsAutorisees: transitionsPossibles
                    });
                }

                updateData.statut = inputs.statut;
            }

            // Gestion de la date de fin
            if (inputs.dateFin) {
                try {
                    const nouvelleDateFin = new Date(inputs.dateFin);
                    if (nouvelleDateFin <= abonnement.dateDebut) {
                        return exits.invalidDate({
                            message: 'La date de fin doit être postérieure à la date de début',
                            code: 'INVALID_END_DATE'
                        });
                    }
                    updateData.dateFin = nouvelleDateFin;
                } catch (error) {
                    return exits.invalidDate({
                        message: 'Format de date de fin invalide',
                        code: 'INVALID_END_DATE_FORMAT'
                    });
                }
            }

            // Gestion de la date de paiement
            if (inputs.datePaiement) {
                try {
                    updateData.datePaiement = new Date(inputs.datePaiement);
                } catch (error) {
                    return exits.invalidDate({
                        message: 'Format de date de paiement invalide',
                        code: 'INVALID_PAYMENT_DATE_FORMAT'
                    });
                }
            }

            // Autres champs
            if (inputs.renouvellementAuto !== undefined) {
                updateData.renouvellementAuto = inputs.renouvellementAuto;
            }

            if (inputs.methodePaiement) {
                updateData.methodePaiement = inputs.methodePaiement;
            }

            if (inputs.referencePaiement) {
                updateData.referencePaiement = inputs.referencePaiement;
            }

            if (inputs.commentaires !== undefined) {
                updateData.commentaires = inputs.commentaires;
            }

            // Mettre à jour l'abonnement
            const abonnementMisAJour = await Abonnement.updateOne({ codeAbonnement: inputs.codeAbonnement, codeEcole: userCodeEcole })
                .set(updateData);

            // Créer une notification si le statut a changé
            if (inputs.statut && inputs.statut !== abonnement.statut) {
                let typeNotification, titre, message;

                switch (inputs.statut) {
                    case 'actif':
                        typeNotification = 'paiement_reussi';
                        titre = 'Abonnement activé';
                        message = 'Votre abonnement a été activé avec succès.';
                        break;
                    case 'expire':
                        typeNotification = 'expiration';
                        titre = 'Abonnement expiré';
                        message = 'Votre abonnement a expiré. Veuillez le renouveler pour continuer à bénéficier de nos services.';
                        break;
                    case 'suspendu':
                        typeNotification = 'suspension';
                        titre = 'Abonnement suspendu';
                        message = 'Votre abonnement a été suspendu. Veuillez contacter le support pour plus d\'informations.';
                        break;
                    case 'annule':
                        typeNotification = 'annulation';
                        titre = 'Abonnement annulé';
                        message = 'Votre abonnement a été annulé.';
                        break;
                }

                if (typeNotification) {
                    await NotificationAbonnement.create({
                        codeEcole: userCodeEcole,
                        codeAbonnement: inputs.codeAbonnement,
                        codeParent: abonnement.codeParent,
                        typeNotification: typeNotification,
                        titre: titre,
                        message: message,
                        priorite: inputs.statut === 'actif' ? 'normale' : 'haute',
                        dateEnvoi: new Date(), // Champ requis manquant
                        canauxEnvoi: ['push', 'email', 'sms'], // Valeur par défaut
                        statutEnvoi: { // Valeur par défaut
                            push: 'non_envoye',
                            email: 'non_envoye',
                            sms: 'non_envoye'
                        }
                    });
                }
            }

            // Enrichir la réponse avec les informations de l'offre
            const offre = await OffreAbonnement.findOne({ codeOffre: abonnementMisAJour.codeOffre });

            return exits.success({
                message: 'Abonnement mis à jour avec succès',
                data: {
                    ...abonnementMisAJour,
                    offre: offre || null
                }
            });

        } catch (error) {
            sails.log.error('Erreur lors de la mise à jour de l\'abonnement:', error);
            return exits.error({
                message: 'Erreur interne du serveur',
                error: error.message
            });
        }
    }
}; 