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

module.exports = {
    friendlyName: 'Rechercher les abonnements',

    description: 'Rechercher les abonnements avec différents filtres',

    inputs: {
       /* codeParent: {
            type: 'string',
            allowNull: true,
            description: 'Filtrer par code parent'
        },
        codeEcole: {
            type: 'string',
            allowNull: true,
            description: 'Filtrer par code école'
        },*/
        statut: {
            type: 'string',
            isIn: ['actif', 'expire', 'suspendu', 'annule', 'en_attente_paiement', 'essai'],
            allowNull: true,
            description: 'Filtrer par statut'
        },
        typeAbonnement: {
            type: 'string',
            isIn: ['gratuit', 'mensuel', 'trimestriel', 'semestriel', 'annuel', 'essai'],
            allowNull: true,
            description: 'Filtrer par type d\'abonnement'
        },
        dateDebut: {
            type: 'string',
            allowNull: true,
            description: 'Date de début pour filtrer (format YYYY-MM-DD)'
        },
        dateFin: {
            type: 'string',
            allowNull: true,
            description: 'Date de fin pour filtrer (format YYYY-MM-DD)'
        },
        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: 'dateDebut DESC',
            description: 'Ordre de tri'
        }
    },

    exits: {
        success: {
            description: 'Abonnements trouvés avec succès',
            responseType: 'ok'
        },
        invalidDate: {
            description: 'Format de date invalide',
            responseType: 'badRequest'
        },
        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
        this.req.query.limit = this.req.query.limit || "10";
        this.req.query.skip = this.req.query.skip || "0";

        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.typeUser === 'PARENT') {
                criteria.codeParent = user.codeUser;
            }

            if (user.codeEcole) {
                criteria.codeEcole = user.codeEcole;
            } else {
                return exits.notFound({ message: "Vous n'etes pas autoriser a accéder a cette page!" })
            }
            if (inputs.statut) {
                criteria.statut = inputs.statut;
            }

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

            // Gestion des dates
            if (inputs.dateDebut || inputs.dateFin) {
                criteria.dateDebut = {};

                if (inputs.dateDebut) {
                    try {
                        const dateDebut = new Date(inputs.dateDebut);
                        criteria.dateDebut['>='] = dateDebut;
                    } catch (error) {
                        return exits.invalidDate({
                            message: 'Format de date de début invalide',
                            code: 'INVALID_START_DATE'
                        });
                    }
                }

                if (inputs.dateFin) {
                    try {
                        const dateFin = new Date(inputs.dateFin);
                        dateFin.setHours(23, 59, 59, 999); // Fin de journée
                        criteria.dateDebut['<='] = dateFin;
                    } catch (error) {
                        return exits.invalidDate({
                            message: 'Format de date de fin invalide',
                            code: 'INVALID_END_DATE'
                        });
                    }
                }
            }

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

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

            // Enrichir les données avec les informations des offres
            const abonnementsEnrichis = await Promise.all(abonnements.map(async (abonnement) => {
                const offre = await OffreAbonnement.findOne({ codeOffre: abonnement.codeOffre });
                const parent = await Parents.findOne({ codeParent: abonnement.codeParent, codeEcole: user.codeEcole });
                const ecole = await Ecoles.findOne({ codeEcole: abonnement.codeEcole });

                return {
                    ...abonnement,
                    offre: offre || null,
                    parent: parent ? {
                        codeParent: parent.codeParent,
                        nom: parent.nom,
                        prenom: parent.prenom,
                        email: parent.email,
                        telephone1: parent.telephone1
                    } : null,
                    ecole: ecole ? {
                        codeEcole: ecole.codeEcole,
                        nom: ecole.nom,
                        ville: ecole.ville
                    } : null
                };
            }));

            const responsePayload = {
                message: 'Abonnements trouvés avec succès',
                data: {
                    abonnements: abonnementsEnrichis,
                    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('ABONNEMENTS_FIND_RESPONSE:', JSON.stringify(responsePayload));
            return exits.success(responsePayload);

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