const sanitizeHtml = require('sanitize-html');

module.exports = {
    friendlyName: 'Get app configuration',

    description: 'Get application configuration with school-specific overrides',

    inputs: {
        schoolIdentifier: {
            type: 'string',
            required: true,
            description: 'School identifier code (e.g., E00015)'
        }
    },

    exits: {
        success: {
            description: 'Configuration retrieved successfully',
            responseType: 'ok'
        },
        badRequest: {
            description: 'Invalid school identifier format',
            statusCode: 400
        },
        notFound: {
            description: 'School not found',
            statusCode: 404
        },
        notModified: {
            description: 'Configuration not modified',
            statusCode: 304
        }
    },

    fn: async function (inputs, exits) {
        try {
            const { schoolIdentifier } = inputs;

            // Validation stricte du format du code école
            if (!schoolIdentifier || typeof schoolIdentifier !== 'string') {
                return exits.badRequest({
                    error: 'INVALID_SCHOOL_IDENTIFIER',
                    message: 'Le code école est requis et doit être une chaîne de caractères'
                });
            }

            // Format attendu: E suivi de 5 chiffres
            const schoolCodePattern = /^E\d{5}$/;
            if (!schoolCodePattern.test(schoolIdentifier)) {
                return exits.badRequest({
                    error: 'INVALID_FORMAT',
                    message: 'Le code école doit être au format E00000 (E suivi de 5 chiffres)'
                });
            }

            // Vérifier que l'école existe
            const schoolsConfig = sails.config.appContent.schools;
            if (!schoolsConfig || !schoolsConfig[schoolIdentifier]) {
                sails.log.warn(`School not found for config: ${schoolIdentifier}`);
                return exits.notFound({
                    error: 'SCHOOL_NOT_FOUND',
                    message: 'École non trouvée avec ce code'
                });
            }

            // Récupérer la configuration par défaut
            const defaultConfig = sails.config.appContent.defaultConfig || {};

            // Récupérer les overrides spécifiques à l'école
            const schoolConfigs = sails.config.appContent.schoolConfigs || {};
            const schoolOverrides = schoolConfigs[schoolIdentifier] || {};

            // Fusionner la configuration (overrides école > config par défaut)
            const mergedConfig = await sails.helpers.mergeDeep(defaultConfig, schoolOverrides);

            // Ajouter les métadonnées de l'école
            const schoolInfo = schoolsConfig[schoolIdentifier];
            mergedConfig.school = {
                identifier: schoolIdentifier,
                name: schoolInfo.name,
                logoUrl: schoolInfo.logoUrl || null,
                whatsapp: schoolInfo.whatsapp || null
            };

            // Générer un hash stable pour l'ETag
            const configHashResult = await sails.helpers.stableJsonHash(mergedConfig);
            const configHash = configHashResult.hash;

            // Vérifier l'ETag pour le cache
            const ifNoneMatch = this.req.headers['if-none-match'];
            if (ifNoneMatch && ifNoneMatch === `"${configHash}"`) {
                return exits.notModified();
            }

            // Sanitiser le contenu HTML si présent
            if (mergedConfig.profile && mergedConfig.profile.sections) {
                mergedConfig.profile.sections = await Promise.all(
                    mergedConfig.profile.sections.map(async (section) => {
                        if (section.content && typeof section.content === 'string') {
                            section.content = await sails.helpers.sanitizeHtml.with({ html: section.content });
                        }
                        return section;
                    })
                );
            }

            // Ajouter les métadonnées de la réponse
            const response = {
                data: mergedConfig,
                metadata: {
                    schoolIdentifier,
                    lastUpdated: new Date().toISOString(),
                    ttlSeconds: 21600, // 6 heures
                    version: configHash.substring(0, 8)
                }
            };

            // Définir les headers de cache
            this.res.set({
                'ETag': `"${configHash}"`,
                'Cache-Control': 'public, max-age=21600, must-revalidate',
                'Last-Modified': new Date().toUTCString()
            });

            // Log de l'accès à la configuration
            sails.log.info(`App config accessed for school: ${schoolIdentifier}`);
            //console.log("APP CONFIG response", response);
            return exits.success(response);

        } catch (error) {
            sails.log.error('Error in app config retrieval:', error);
            return exits.error({
                error: 'INTERNAL_ERROR',
                message: 'Erreur interne du serveur'
            });
        }
    }
};


