/**
 * find-one.js
 *
 * @description :: Récupérer les détails d'un abonnement spécifique
 * @help        :: Voir http://sailsjs.com/#!/documentation/concepts/Controllers
 */

module.exports = {
    friendlyName: 'Récupérer un abonnement',

    description: 'Récupérer les détails complets d\'un abonnement par son code',

    inputs: {
        codeAbonnement: {
            type: 'string',
            required: true,
            description: 'Code de l\'abonnement à récupérer'
        }
    },

    exits: {
        success: {
            description: 'Abonnement récupéré avec succès',
            responseType: 'ok'
        },
        notFound: {
            description: 'Abonnement non trouvé',
            responseType: 'notFound'
        },
        unauthorized: {
            description: 'Accès non autorisé à cet abonnement',
            responseType: 'forbidden'
        }
    },

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

        try {
            // Vérifier que l'utilisateur a un code école
            if (!user.codeEcole) {
                return exits.unauthorized({
                    message: 'Code école manquant',
                    code: 'MISSING_SCHOOL_CODE'
                });
            }

            // Récupérer l'abonnement avec toutes ses relations
            const abonnement = await Abonnement.findOne({
                codeAbonnement: inputs.codeAbonnement,
                codeEcole: user.codeEcole,
                codeParent: user.codeUser
            }).populate('offre');

            if (!abonnement) {
                return exits.notFound({
                    message: 'Abonnement non trouvé',
                    code: 'SUBSCRIPTION_NOT_FOUND',
                    codeAbonnement: inputs.codeAbonnement
                });
            }

            // Vérifier que l'utilisateur peut accéder à cet abonnement
            if (abonnement.codeParent !== user.codeUser) {
                return exits.unauthorized({
                    message: 'Accès non autorisé à cet abonnement',
                    code: 'UNAUTHORIZED_ACCESS'
                });
            }

            // Récupérer la promotion si elle existe
            let promotion = null;
            if (abonnement.codePromotion) {
                promotion = await PromotionAbonnement.findOne({
                    codePromotion: abonnement.codePromotion,
                    codeEcole: user.codeEcole
                });
            }

            // Récupérer les transactions associées
            const transactions = await TransactionAbonnement.find({
                codeAbonnement: abonnement.codeAbonnement,
                codeEcole: user.codeEcole
            }).sort('createdAt DESC');

            // Récupérer les notifications associées
            const notifications = await NotificationAbonnement.find({
                codeAbonnement: abonnement.codeAbonnement,
                codeEcole: user.codeEcole
            }).sort('createdAt DESC').limit(10); // Limiter à 10 dernières notifications

            // Récupérer les informations du parent
            const parent = await Parents.findOne({
                codeParent: abonnement.codeParent,
                codeEcole: user.codeEcole
            });

            // Récupérer les informations de l'utilisateur
            const utilisateur = await Utilisateurs.findOne({
                codeUser: abonnement.codeParent,
                codeEcole: user.codeEcole
            });

            // Calculer le statut de l'abonnement
            const maintenant = new Date();

            // S'assurer que les dates sont des objets Date valides
            let dateFin = null;
            let dateDebut = null;
            let datePaiement = null;

            // Conversion de dateFin
            if (abonnement.dateFin) {
                try {
                    dateFin = new Date(abonnement.dateFin);
                    if (isNaN(dateFin.getTime())) {
                        dateFin = null;
                        sails.log.warn(`⚠️  Date de fin invalide pour l'abonnement ${abonnement.codeAbonnement}: ${abonnement.dateFin}`);
                    }
                } catch (error) {
                    dateFin = null;
                    sails.log.warn(`⚠️  Erreur lors de la conversion de la date de fin pour l'abonnement ${abonnement.codeAbonnement}:`, error.message);
                }
            }

            // Conversion de dateDebut
            if (abonnement.dateDebut) {
                try {
                    dateDebut = new Date(abonnement.dateDebut);
                    if (isNaN(dateDebut.getTime())) {
                        dateDebut = null;
                        sails.log.warn(`⚠️  Date de début invalide pour l'abonnement ${abonnement.codeAbonnement}: ${abonnement.dateDebut}`);
                    }
                } catch (error) {
                    dateDebut = null;
                    sails.log.warn(`⚠️  Erreur lors de la conversion de la date de début pour l'abonnement ${abonnement.codeAbonnement}:`, error.message);
                }
            }

            // Conversion de datePaiement
            if (abonnement.datePaiement) {
                try {
                    datePaiement = new Date(abonnement.datePaiement);
                    if (isNaN(datePaiement.getTime())) {
                        datePaiement = null;
                        sails.log.warn(`⚠️  Date de paiement invalide pour l'abonnement ${abonnement.codeAbonnement}: ${abonnement.datePaiement}`);
                    }
                } catch (error) {
                    datePaiement = null;
                    sails.log.warn(`⚠️  Erreur lors de la conversion de la date de paiement pour l'abonnement ${abonnement.codeAbonnement}:`, error.message);
                }
            }

            let statutDetaille = {
                actif: abonnement.statut === 'actif',
                enEssai: abonnement.statut === 'essai',
                enAttentePaiement: abonnement.statut === 'en_attente_paiement',
                expire: abonnement.statut === 'expire',
                suspendu: abonnement.statut === 'suspendu',
                annule: abonnement.statut === 'annule'
            };

            // Vérifier si l'abonnement est expiré
            if (dateFin && dateFin < maintenant && abonnement.statut === 'actif') {
                statutDetaille.expire = true;
                statutDetaille.actif = false;
            }

            // Calculer les jours restants
            let joursRestants = 0;
            if (dateFin && abonnement.statut === 'actif') {
                const difference = dateFin.getTime() - maintenant.getTime();
                joursRestants = Math.ceil(difference / (1000 * 3600 * 24));
            }

            // Préparer la réponse
            const response = {
                abonnement: {
                    id: abonnement.id,
                    codeAbonnement: abonnement.codeAbonnement,
                    statut: abonnement.statut,
                    statutDetaille: statutDetaille,
                    typeAbonnement: abonnement.typeAbonnement,
                    dateDebut: dateDebut || abonnement.dateDebut,
                    dateFin: dateFin || abonnement.dateFin,
                    joursRestants: Math.max(0, joursRestants),
                    montant: abonnement.montant,
                    devise: abonnement.devise,
                    montantReduction: abonnement.montantReduction,
                    montantFinal: abonnement.montantFinal,
                    methodePaiement: abonnement.methodePaiement,
                    referencePaiement: abonnement.referencePaiement,
                    renouvellementAuto: abonnement.renouvellementAuto,
                    commentaires: abonnement.commentaires,
                    datePaiement: datePaiement || abonnement.datePaiement,
                    createdAt: abonnement.createdAt,
                    updatedAt: abonnement.updatedAt
                },
                offre: abonnement.offre ? {
                    id: abonnement.offre.id,
                    codeOffre: abonnement.offre.codeOffre,
                    nom: abonnement.offre.nom,
                    description: abonnement.offre.description,
                    typeAbonnement: abonnement.offre.typeAbonnement,
                    dureeJours: abonnement.offre.dureeJours,
                    montant: abonnement.offre.montant,
                    devise: abonnement.offre.devise,
                    actif: abonnement.offre.actif,
                    caracteristiques: abonnement.offre.caracteristiques || []
                } : null,
                promotion: promotion ? {
                    id: promotion.id,
                    codePromotion: promotion.codePromotion,
                    nom: promotion.nom,
                    description: promotion.description,
                    typeReduction: promotion.typeReduction,
                    valeurReduction: promotion.valeurReduction,
                    dateDebut: promotion.dateDebut,
                    dateFin: promotion.dateFin
                } : null,
                parent: parent ? {
                    codeParent: parent.codeParent,
                    nom: parent.nom,
                    prenom: parent.prenom,
                    email: parent.email,
                    telephone: parent.telephone
                } : null,
                utilisateur: utilisateur ? {
                    codeUser: utilisateur.codeUser,
                    nom: utilisateur.nom,
                    prenom: utilisateur.prenom,
                    email: utilisateur.email,
                    telephone: utilisateur.telephone
                } : null,
                transactions: transactions.map(t => ({
                    id: t.id,
                    typeTransaction: t.typeTransaction,
                    statut: t.statut,
                    montant: t.montant,
                    devise: t.devise,
                    methodePaiement: t.methodePaiement,
                    operateur: t.operateur,
                    numeroTelephone: t.numeroTelephone,
                    fraisTransaction: t.fraisTransaction,
                    montantNet: t.montantNet,
                    description: t.description,
                    dateTransaction: t.dateTransaction,
                    dateConfirmation: t.dateConfirmation,
                    createdAt: t.createdAt
                })),
                notifications: notifications.map(n => ({
                    id: n.id,
                    codeNotification: n.codeNotification,
                    typeNotification: n.typeNotification,
                    titre: n.titre,
                    message: n.message,
                    statut: n.statut,
                    dateEnvoi: n.dateEnvoi,
                    dateLecture: n.dateLecture,
                    priorite: n.priorite,
                    createdAt: n.createdAt
                })),
                resume: {
                    totalTransactions: transactions.length,
                    totalNotifications: notifications.length,
                    montantTotalPaye: transactions
                        .filter(t => t.statut === 'reussi')
                        .reduce((sum, t) => sum + (t.montant || 0), 0),
                    derniereTransaction: transactions.length > 0 ? transactions[0] : null,
                    derniereNotification: notifications.length > 0 ? notifications[0] : null
                }
            };

            return exits.success({
                message: 'Abonnement récupéré avec succès',
                data: response
            });

        } catch (error) {
            sails.log.error('Erreur lors de la récupération de l\'abonnement:', error);
            return exits.error(new Error('Erreur interne du serveur'));
        }
    }
};
