let moment = require('moment')

module.exports = {
    friendlyName: "Find Absence Enfant",

    description: "Find absence de l'enfant pour un parent.",

    inputs: {
        matricule: {
            type: "string",
            required: true
        },
        startDate: {
            type: 'string'
        },
        endDate: {
            type: 'string'
        },
        anneeScolaire: {
            type: "string",
            required: true
        }
    },

    exits: {
        notFound: {
            statusCode: 404
        }
    },

    fn: async function (inputs, exits) {
        const { id, user } = this.req.token;
        console.log("inputs", inputs)
        // 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 utilisateur pour accéder a cette page!" })
        }

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

        // VERIFICATION DES PERMISSIONS
        if (user.typeUser !== 'PARENT') {
            return exits.notFound({ message: "Vous n'êtes pas autorisé à accéder a cette page!" })
        }

        // VERIFICATION DU MATRICULE
        if (inputs.matricule === '' || inputs.matricule === null || inputs.matricule === undefined) {
            return exits.notFound({ message: "Veuillez préciser le matricule de l'enfant!" })
        }

        // VERIFICATION SI L'ENFANT APPARTIENT AU PARENT
        let filiation = await Filiation.find({
            codeEcole: user.codeEcole,
            matricule: inputs.matricule,
            codeParent: user.codeUser
        }).then(_.first)

        if (!filiation) {
            return exits.notFound({ message: "Cet enfant ne vous appartient pas ou n'est pas inscrit dans cette école!" })
        }

        // VERIFICATION SI L'ENFANT EXISTE
        let eleve = await Eleves.find({
            matricule: inputs.matricule,
            codeEcole: user.codeEcole
        }).then(_.first)

        if (!eleve) {
            return exits.notFound({ message: "Enfant non trouvé!" })
        }

        // VERIFICATION DE L'ANNEE SCOLAIRE
        if (inputs.anneeScolaire === '' || inputs.anneeScolaire === null || inputs.anneeScolaire === undefined) {
            return exits.notFound({ message: "Veuillez préciser une année scolaire!" })
        }

        // TRAITEMENT DES DATES
        if (inputs.startDate === '' || inputs.startDate === undefined || inputs.startDate === null || inputs.startDate === 'undefined') {
            // Si pas de date de début, on prend le début de l'année scolaire
            inputs.startDate = moment().startOf('year').format('YYYY-MM-DD')
        } else {
            inputs.startDate = moment(inputs.startDate, 'YYYYMMDD').format('YYYY-MM-DD')
        }

        if (inputs.endDate === '' || inputs.endDate === undefined || inputs.endDate === null || inputs.endDate === 'undefined') {
            // Si pas de date de fin, on prend la date actuelle
            inputs.endDate = moment().format('YYYY-MM-DD')
        } else {
            inputs.endDate = moment(inputs.endDate, 'YYYYMMDD').format('YYYY-MM-DD')
        }

        // CONFIGURATION DE LA PAGINATION
        this.req.query.limit = this.req.query.limit || "500";
        this.req.query.skip = this.req.query.skip || "0";

        // CONSTRUCTION DES CONDITIONS DE RECHERCHE
        let fixedAttr = ["codeEcole", "anneeScolaire", "matricule"];

        let cond = {
            codeEcole: user.codeEcole,
            anneeScolaire: inputs.anneeScolaire,
            matricule: inputs.matricule,
            //dateCours: { '>=': inputs.startDate, '<=': inputs.endDate }
        };

        let options = {
            ...this.req.query,
            fixCond: _.pick(cond, fixedAttr),
            sort: "id DESC",
        };

        // RECUPERATION DES ABSENCES DE L'ENFANT
        let absences = await sails.helpers.paginator(AbscencePresenceDetails, cond, options)
            .then(async (absences) => {
                absences.data = await Promise.all(
                    absences.data.map(async (absence) => {
                        // Récupération des informations de l'absence principale
                        let absencePrincipale = await AbscencePresence.find({
                            codeAbscence: absence.codeAbscence,
                            codeEcole: user.codeEcole
                        }).then(_.first)

                        if (absencePrincipale) {
                            absence.codeClasse = absencePrincipale.codeClasse
                            absence.codeMatiere = absencePrincipale.codeMatiere
                            absence.dateCours = absencePrincipale.dateCours
                            absence.codeEnseignant = absencePrincipale.codeEnseignant
                            absence.heureDebutCours = absencePrincipale.heureDebutCours
                            absence.heureFinCours = absencePrincipale.heureFinCours
                        }

                        // Récupération des informations de la classe
                        if (absence.codeClasse) {
                            let classe = await Classe.find({ codeClasse: absence.codeClasse }).then(_.first)
                            if (classe) {
                                absence.nomClasse = classe.libelleClasse
                            }
                        }

                        // Récupération des informations de la matière
                        if (absence.codeMatiere) {
                            let matiere = await AttributionMatiere.find({
                                codeClasse: absence.codeClasse,
                                codeMatiere: absence.codeMatiere
                            }).then(_.first)
                            if (matiere) {
                                absence.nomMatiere = matiere.libelleCourt
                            }
                        }

                        // Récupération des informations de l'enseignant
                        if (absence.codeEnseignant) {
                            let enseignant = await Enseignants.find({
                                codeEnseignant: absence.codeEnseignant
                            }).then(_.first)
                            if (enseignant) {
                                absence.nomEnseignant = enseignant.nom
                                absence.prenomEnseignant = enseignant.prenom
                            }
                        }

                        // Formatage de la date
                        if (absence.dateCours) {
                            absence.dateCoursFormatted = moment(absence.dateCours).format('DD/MM/YYYY')
                        }

                        return absence
                    })
                );
                return absences
            });
        console.log(absences)
        // All done.
        return exits.success(absences);
    },
}; 