/**
 * find.js
 *
 * @description :: Rechercher les offres d'abonnement avec filtres
 * @help        :: Voir http://sailsjs.com/#!/documentation/concepts/Controllers
 */

module.exports = {
    friendlyName: 'Rechercher les offres d\'abonnement',

    description: 'Rechercher les offres d\'abonnement avec différents filtres',

    inputs: {
        codeEcole: {
            type: 'string',
            allowNull: true,
            description: 'Filtrer par code école'
        },
        typeAbonnement: {
            type: 'string',
            isIn: ['gratuit', 'mensuel', 'trimestriel', 'semestriel', 'annuel', 'essai'],
            allowNull: true,
            description: 'Filtrer par type d\'abonnement'
        },
        actif: {
            type: 'boolean',
            allowNull: true,
            description: 'Filtrer par statut actif'
        },
        montantMin: {
            type: 'number',
            allowNull: true,
            description: 'Montant minimum'
        },
        montantMax: {
            type: 'number',
            allowNull: true,
            description: 'Montant maximum'
        },
        devise: {
            type: 'string',
            allowNull: true,
            description: 'Filtrer par devise'
        },
        limit: {
            type: 'number',
            defaultsTo: 50,
            description: 'Nombre maximum de résultats'
        },
        skip: {
            type: 'number',
            defaultsTo: 0,
            description: 'Nombre de résultats à ignorer'
        },
        sort: {
            type: 'string',
            defaultsTo: 'ordreAffichage ASC',
            description: 'Ordre de tri'
        }
    },

    exits: {
        success: {
            description: 'Offres trouvées avec succès',
            responseType: 'ok'
        },
        forbidden: {
            description: 'Accès non autorisé',
            responseType: 'forbidden'
        },
        badRequest: {
            description: 'Requête 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) {
            return exits.badRequest({ message: "Veuillez préciser le code Ecole pour accéder à cette ressource." })
        }
        const ecoleVerif = await Ecoles.find({ codeEcole: user.codeEcole }).then(_.first)
        if (!ecoleVerif) {
            return exits.forbidden({ message: "Cet utilisateur n'est attribué à aucune école!" })
        }
        // FIN VERIF CODE ECOLE  
        let userCodeEcole;
        if (user.typeUser === 'ADMINISTRATION' || user.typeUser === 'SECRETARIAT' || user.typeUser === 'PARENT') {
            userCodeEcole = user.codeEcole
        } else if (user.typeUser === 'ADMIN') {
            userCodeEcole = undefined
        } else {
            return exits.forbidden({ message: "Vous n'êtes pas autorisé à accéder à cette page!" })
        }
        try {
            // Construire les critères de recherche
            const criteria = {};

            if (user.codeEcole !== undefined) {
                // Si codeEcole est null, chercher les offres valables pour toutes les écoles
                // Sinon, chercher les offres spécifiques à cette école OU valables pour toutes
                if (user.codeEcole === null) {
                    return exits.notFound({ message: "Vous n'etes pas autoriser a accéder a cette page!" })
                    //criteria.codeEcole = null;
                } else {
                    ///criteria.codeEcole = user.codeEcole; //avant on faisait par code Ecole maitenant c'est général
                    /*criteria.or = [
                        { codeEcole: user.codeEcole },
                        // { codeEcole: null }
                    ];*/
                }
            }


            if (inputs.typeAbonnement) {
                criteria.typeAbonnement = inputs.typeAbonnement;
            }

            if (inputs.actif !== undefined) {
                criteria.actif = inputs.actif;
            }

            if (inputs.devise) {
                criteria.devise = inputs.devise;
            }

            // Si l'utilisateur est un parent et a déjà utilisé un essai, on masque les offres d'essai
            if (user.typeUser === 'PARENT' && !inputs.typeAbonnement) {
                const trialCount = await Abonnement.count({
                    codeParent: user.codeUser,
                    codeEcole: user.codeEcole,
                    typeAbonnement: 'essai'
                });
                if (trialCount > 0) {
                    criteria.typeAbonnement = { '!=': 'essai' };
                }
            }

            // Filtres sur le montant
            if (inputs.montantMin !== undefined || inputs.montantMax !== undefined) {
                criteria.montant = {};

                if (inputs.montantMin !== undefined) {
                    criteria.montant['>='] = inputs.montantMin;
                }

                if (inputs.montantMax !== undefined) {
                    criteria.montant['<='] = inputs.montantMax;
                }
            }

            // Vérifier la validité temporelle
            const maintenant = new Date();
            criteria.or = criteria.or || [];
            criteria.or.push(
                { dateDebutValidite: null, dateFinValidite: null }, // Pas de restriction temporelle
                { dateDebutValidite: null, dateFinValidite: { '>=': maintenant } }, // Pas de début, fin future
                { dateDebutValidite: { '<=': maintenant }, dateFinValidite: null }, // Début passé, pas de fin
                { dateDebutValidite: { '<=': maintenant }, dateFinValidite: { '>=': maintenant } } // Période valide
            );

            // Rechercher les offres
            const offres = await OffreAbonnement.find(criteria)
                .sort(inputs.sort)
                .limit(inputs.limit)
                .skip(inputs.skip);

            // Compter le total
            const total = await OffreAbonnement.count(criteria);

            // Enrichir les données avec les informations de l'école
            const offresEnrichies = await Promise.all(offres.map(async (offre) => {
                let ecole = null;
                if (offre.codeEcole) {
                    ecole = await Ecoles.findOne({ codeEcole: offre.codeEcole });
                }

                return {
                    ...offre,
                    ecole: ecole ? {
                        codeEcole: ecole.codeEcole,
                        nom: ecole.nom,
                        ville: ecole.ville
                    } : null
                };
            }));

            const responsePayload = {
                message: 'Offres d\'abonnement trouvées avec succès',
                data: {
                    offres: offresEnrichies,
                    pagination: {
                        total: total,
                        limit: inputs.limit,
                        skip: inputs.skip,
                        page: Math.floor(inputs.skip / inputs.limit) + 1,
                        totalPages: Math.ceil(total / inputs.limit)
                    }
                }
            };

            // sails.log.info('OFFRES_FIND_RESPONSE:', JSON.stringify(responsePayload));
            return exits.success(responsePayload);

        } catch (error) {
            sails.log.error('Erreur lors de la recherche des offres d\'abonnement:', error);
            return exits.error({
                message: 'Erreur interne du serveur',
                error: error.message
            });
        }
    }
}; 