const _ = require('lodash');
require('dotenv').config();
module.exports = {
    friendlyName: 'Create Multi NatureRecette',
    description: 'Création multiple de natures de recette via logiciel.',

    inputs: {
        listeElementAjout: {
            type: 'ref'
        },
        logiUsername: {
            type: 'string',
            require: true
        },
        key: {
            type: 'string',
            require: true
        },
        logiPassword: {
            type: 'string',
            require: true
        },
    },

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

    fn: async function (inputs, exits) {
        // Authentification
        let user = await Utilisateurs.find({ login: inputs.logiUsername, codeUser: inputs.logiPassword }).then(_.first)
        if (!user) {
            return exits.notFound('Utilisateur non trouvé')
        }
        let keyVerify = process.env.KEYVERIFY
        if (keyVerify !== inputs.key) {
            return exits.notFound({ message: "Token non valide" })
        }

        const successes = [];
        const failures = [];
        const existings = [];
        const now = Date.now();

        try {
            // Préparer les clés uniques à rechercher
            const keysToFind = inputs.listeElementAjout.map(item => ({
                codeEcole: item.codeEcole,
                anneeScolaire: item.anneeScolaire,
                codeNatureRecette: item.codeNatureRecette
            }));

            // Récupérer toutes les natures existantes
            const existingNatures = await NatureRecette.find({
                or: keysToFind
            }).then(natures => _.keyBy(natures, n => `${n.codeEcole}-${n.anneeScolaire}-${n.codeNatureRecette}`));

            // Déterminer les natures à créer
            const naturesToCreate = [];
            for (const item of inputs.listeElementAjout) {
                const key = `${item.codeEcole}-${item.anneeScolaire}-${item.codeNatureRecette}`;
                if (!existingNatures[key]) {
                    naturesToCreate.push({ ...item });
                } else {
                    existings.push(existingNatures[key]);
                }
            }

            // Création avec validation préventive + transaction optimisée
            if (naturesToCreate.length > 0) {
                // 1. Validation préventive de tous les éléments
                const validItems = [];
                const invalidItems = [];

                for (const item of naturesToCreate) {
                    if (item.codeEcole && item.anneeScolaire && item.codeNatureRecette && item.libelleNatureRecette) {
                        validItems.push(item);
                    } else {
                        const missingFields = [];
                        if (!item.codeEcole) missingFields.push('codeEcole');
                        if (!item.anneeScolaire) missingFields.push('anneeScolaire');
                        if (!item.codeNatureRecette) missingFields.push('codeNatureRecette');
                        if (!item.libelleNatureRecette) missingFields.push('libelleNatureRecette');

                        invalidItems.push({
                            id: `${item.codeEcole || 'N/A'}-${item.anneeScolaire || 'N/A'}-${item.codeNatureRecette || 'N/A'}`,
                            message: `Champs requis manquants : ${missingFields.join(', ')}`,
                            item: item
                        });
                    }
                }

                // 2. Traitement en lot des éléments valides
                if (validItems.length > 0) {
                    try {
                        const createdRecords = await NatureRecette.createEach(validItems).fetch();
                        successes.push(...createdRecords);
                    } catch (createError) {
                        sails.log.error('Échec de la création en lot, passage au traitement individuel:', createError);

                        // En cas d'échec, traiter individuellement
                        for (const item of validItems) {
                            try {
                                const createdRecord = await NatureRecette.create(item).fetch();
                                successes.push(createdRecord);
                            } catch (individualError) {
                                sails.log.error(`Erreur lors de la création individuelle de la nature de recette ${item.codeNatureRecette}:`, individualError);

                                // Analyser l'erreur pour donner un message plus précis
                                let errorMessage = 'Erreur lors de la création';
                                if (individualError.code === 'E_INVALID_NEW_RECORDS') {
                                    errorMessage = 'Données invalides pour la création';
                                } else if (individualError.code === 'E_UNIQUE') {
                                    errorMessage = 'Violation de contrainte d\'unicité';
                                } else if (individualError.code === 'E_FOREIGN_KEY') {
                                    errorMessage = 'Référence invalide (école inexistante)';
                                }

                                failures.push({
                                    id: `${item.codeEcole || 'N/A'}-${item.anneeScolaire || 'N/A'}-${item.codeNatureRecette || 'N/A'}`,
                                    message: errorMessage,
                                    error: individualError.message,
                                    item: item
                                });
                            }
                        }
                    }
                }

                // 3. Ajouter les éléments invalides aux échecs
                failures.push(...invalidItems);
            }

            // Statut global
            let overallStatus = 'success';
            let message = 'Le traitement par lot des natures de recette est terminé.';
            if (failures.length > 0 && successes.length === 0 && existings.length === 0) {
                overallStatus = 'failure';
                message = 'Le traitement par lot a échoué pour tous les éléments.';
            } else if (successes.length > 0 && failures.length === 0 && existings.length === 0) {
                overallStatus = 'success';
                message = 'Toutes les nouvelles natures de recette ont été ajoutées avec succès.';
            } else if (inputs.listeElementAjout.length === 0) {
                message = 'Aucune nature de recette fournie pour le traitement.';
            } else {
                overallStatus = 'partial_success';
                message = 'Le traitement par lot est terminé avec des succès, des échecs et/ou des éléments existants.';
            }

            return exits.success({
                status: overallStatus,
                message: message,
                successes: successes,
                failures: failures,
                existings: existings,
                createdAt: now,
            });
        } catch (err) {
            sails.log.error('Error processing batch create NatureRecette:', err);
            return exits.serverError({
                status: 'error',
                message: 'Une erreur interne du serveur est survenue lors du traitement par lot des natures de recette.',
                error: err.message,
                createdAt: now,
            });
        }
    }
}; 