module.exports = {
    friendlyName: 'Resolve school by identifier',

    description: 'Resolve school information by identifier code',

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

    exits: {
        success: {
            description: 'School found successfully',
            responseType: 'ok'
        },
        badRequest: {
            description: 'Invalid school identifier format',
            statusCode: 400
        },
        notFound: {
            description: 'School not found',
            statusCode: 404
        },
        tooManyRequests: {
            description: 'Rate limit exceeded',
            statusCode: 429
        }
    },

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

            // Validation stricte du format du code école
            if (!identifier || typeof identifier !== 'string') {
                return exits.badRequest({
                    error: 'INVALID_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(identifier)) {
                return exits.badRequest({
                    error: 'INVALID_FORMAT',
                    message: 'Le code école doit être au format E00000 (E suivi de 5 chiffres)'
                });
            }

            // Rate limiting basique (1 requête par IP par seconde)
            const clientIP = this.req.ip || this.req.connection.remoteAddress;
            const rateLimitKey = `school_resolve:${clientIP}`;

            // Vérifier le rate limiting (utiliser Redis ou mémoire si disponible)
            if (sails.redis) {
                const currentCount = await sails.redis.get(rateLimitKey);
                if (currentCount && parseInt(currentCount) > 10) { // 10 requêtes par minute
                    return exits.tooManyRequests({
                        error: 'RATE_LIMIT_EXCEEDED',
                        message: 'Trop de requêtes. Veuillez réessayer dans 1 minute.'
                    });
                }
                await sails.redis.incr(rateLimitKey);
                await sails.redis.expire(rateLimitKey, 60); // Expire après 1 minute
            }

            // Log de la tentative de résolution
            sails.log.info(`School resolution attempt for identifier: ${identifier} from IP: ${clientIP}`);

            // Récupérer la configuration des écoles
            const schoolsConfig = sails.config.appContent.schools;

            if (!schoolsConfig || !schoolsConfig[identifier]) {
                sails.log.warn(`School not found: ${identifier}`);
                return exits.notFound({
                    error: 'SCHOOL_NOT_FOUND',
                    message: 'École non trouvée avec ce code'
                });
            }

            const schoolInfo = schoolsConfig[identifier];

            // Construire la réponse avec seulement les informations publiques
            const response = {
                identifier: identifier,
                name: schoolInfo.name,
                apiBaseUrl: schoolInfo.apiBaseUrl,
                logoUrl: schoolInfo.logoUrl || null,
                whatsapp: schoolInfo.whatsapp || null,
                // Ne pas exposer d'autres informations sensibles
            };

            // Log du succès
            sails.log.info(`School resolved successfully: ${identifier} -> ${schoolInfo.name}`);
            console.log("response", response);
            return exits.success({
                data: response
            });

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


