package dev.lions.unionflow.server.resource;

import dev.lions.unionflow.server.api.dto.solidarite.aide.AideDTO;
import dev.lions.unionflow.server.api.enums.solidarite.StatutAide;
import dev.lions.unionflow.server.api.enums.solidarite.TypeAide;
import dev.lions.unionflow.server.service.AideService;
import jakarta.annotation.security.RolesAllowed;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.validation.Valid;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotNull;
import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
import org.eclipse.microprofile.openapi.annotations.Operation;
import org.eclipse.microprofile.openapi.annotations.media.Content;
import org.eclipse.microprofile.openapi.annotations.media.Schema;
import org.eclipse.microprofile.openapi.annotations.parameters.Parameter;
import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;
import org.eclipse.microprofile.openapi.annotations.responses.APIResponses;
import org.eclipse.microprofile.openapi.annotations.tags.Tag;
import org.jboss.logging.Logger;

import java.math.BigDecimal;
import java.net.URI;
import java.time.LocalDate;
import java.util.List;
import java.util.Map;

/**
 * Resource REST pour la gestion des demandes d'aide et de solidarité
 * Expose les endpoints API pour les opérations CRUD et métier sur les aides
 * 
 * @author UnionFlow Team
 * @version 1.0
 * @since 2025-01-15
 */
@Path("/api/aides")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@ApplicationScoped
@Tag(name = "Aides", description = "Gestion des demandes d'aide et de solidarité")
public class AideResource {

    private static final Logger LOG = Logger.getLogger(AideResource.class);

    @Inject
    AideService aideService;

    // ===== OPÉRATIONS CRUD =====

    /**
     * Liste toutes les demandes d'aide actives avec pagination
     */
    @GET
    @Operation(summary = "Lister toutes les demandes d'aide actives", 
               description = "Récupère la liste paginée des demandes d'aide actives")
    @APIResponse(responseCode = "200", description = "Liste des demandes d'aide actives")
    @APIResponse(responseCode = "401", description = "Non authentifié")
    @RolesAllowed({"admin", "gestionnaire_aide", "evaluateur_aide", "membre"})
    public Response listerAides(
            @Parameter(description = "Numéro de page (0-based)", example = "0")
            @QueryParam("page") @DefaultValue("0") @Min(0) int page,
            
            @Parameter(description = "Taille de la page", example = "20")
            @QueryParam("size") @DefaultValue("20") @Min(1) int size) {
        
        try {
            LOG.infof("GET /api/aides - page: %d, size: %d", page, size);
            
            List<AideDTO> aides = aideService.listerAidesActives(page, size);
            
            LOG.infof("Récupération réussie de %d demandes d'aide", aides.size());
            return Response.ok(aides).build();
            
        } catch (Exception e) {
            LOG.errorf("Erreur lors de la récupération des demandes d'aide: %s", e.getMessage());
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity(Map.of("error", "Erreur lors de la récupération des demandes d'aide"))
                    .build();
        }
    }

    /**
     * Récupère une demande d'aide par son ID
     */
    @GET
    @Path("/{id}")
    @Operation(summary = "Récupérer une demande d'aide par ID")
    @APIResponse(responseCode = "200", description = "Demande d'aide trouvée")
    @APIResponse(responseCode = "404", description = "Demande d'aide non trouvée")
    @RolesAllowed({"admin", "gestionnaire_aide", "evaluateur_aide", "membre"})
    public Response obtenirAide(
            @Parameter(description = "ID de la demande d'aide", required = true)
            @PathParam("id") Long id) {
        
        try {
            LOG.infof("GET /api/aides/%d", id);
            
            AideDTO aide = aideService.obtenirAideParId(id);
            
            return Response.ok(aide).build();
            
        } catch (jakarta.ws.rs.NotFoundException e) {
            LOG.warnf("Demande d'aide non trouvée: ID %d", id);
            return Response.status(Response.Status.NOT_FOUND)
                    .entity(Map.of("error", "Demande d'aide non trouvée"))
                    .build();
        } catch (Exception e) {
            LOG.errorf("Erreur lors de la récupération de la demande d'aide %d: %s", id, e.getMessage());
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity(Map.of("error", "Erreur lors de la récupération de la demande d'aide"))
                    .build();
        }
    }

    /**
     * Récupère une demande d'aide par son numéro de référence
     */
    @GET
    @Path("/reference/{numeroReference}")
    @Operation(summary = "Récupérer une demande d'aide par numéro de référence")
    @APIResponse(responseCode = "200", description = "Demande d'aide trouvée")
    @APIResponse(responseCode = "404", description = "Demande d'aide non trouvée")
    @RolesAllowed({"admin", "gestionnaire_aide", "evaluateur_aide", "membre"})
    public Response obtenirAideParReference(
            @Parameter(description = "Numéro de référence de la demande", required = true)
            @PathParam("numeroReference") String numeroReference) {
        
        try {
            LOG.infof("GET /api/aides/reference/%s", numeroReference);
            
            AideDTO aide = aideService.obtenirAideParReference(numeroReference);
            
            return Response.ok(aide).build();
            
        } catch (jakarta.ws.rs.NotFoundException e) {
            LOG.warnf("Demande d'aide non trouvée: référence %s", numeroReference);
            return Response.status(Response.Status.NOT_FOUND)
                    .entity(Map.of("error", "Demande d'aide non trouvée"))
                    .build();
        } catch (Exception e) {
            LOG.errorf("Erreur lors de la récupération de la demande d'aide %s: %s", numeroReference, e.getMessage());
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity(Map.of("error", "Erreur lors de la récupération de la demande d'aide"))
                    .build();
        }
    }

    /**
     * Crée une nouvelle demande d'aide
     */
    @POST
    @Operation(summary = "Créer une nouvelle demande d'aide")
    @APIResponses({
        @APIResponse(responseCode = "201", description = "Demande d'aide créée avec succès",
                    content = @Content(schema = @Schema(implementation = AideDTO.class))),
        @APIResponse(responseCode = "400", description = "Données invalides"),
        @APIResponse(responseCode = "404", description = "Membre ou organisation non trouvé")
    })
    @RolesAllowed({"admin", "gestionnaire_aide", "membre"})
    public Response creerAide(
            @Parameter(description = "Données de la demande d'aide à créer", required = true)
            @Valid AideDTO aideDTO) {
        
        try {
            LOG.infof("POST /api/aides - Création demande d'aide: %s", aideDTO.getTitre());
            
            AideDTO aideCree = aideService.creerAide(aideDTO);
            
            LOG.infof("Demande d'aide créée avec succès: %s", aideCree.getNumeroReference());
            return Response.status(Response.Status.CREATED)
                    .location(URI.create("/api/aides/" + aideCree.getId()))
                    .entity(aideCree)
                    .build();
                    
        } catch (jakarta.ws.rs.NotFoundException e) {
            LOG.warnf("Membre ou organisation non trouvé lors de la création: %s", e.getMessage());
            return Response.status(Response.Status.NOT_FOUND)
                    .entity(Map.of("error", "Membre ou organisation non trouvé"))
                    .build();
        } catch (IllegalArgumentException e) {
            LOG.warnf("Données invalides pour la création: %s", e.getMessage());
            return Response.status(Response.Status.BAD_REQUEST)
                    .entity(Map.of("error", "Données invalides", "message", e.getMessage()))
                    .build();
        } catch (Exception e) {
            LOG.errorf("Erreur lors de la création de la demande d'aide: %s", e.getMessage());
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity(Map.of("error", "Erreur lors de la création de la demande d'aide"))
                    .build();
        }
    }

    /**
     * Met à jour une demande d'aide existante
     */
    @PUT
    @Path("/{id}")
    @Operation(summary = "Mettre à jour une demande d'aide")
    @APIResponses({
        @APIResponse(responseCode = "200", description = "Demande d'aide mise à jour avec succès"),
        @APIResponse(responseCode = "400", description = "Données invalides"),
        @APIResponse(responseCode = "403", description = "Accès non autorisé"),
        @APIResponse(responseCode = "404", description = "Demande d'aide non trouvée")
    })
    @RolesAllowed({"admin", "gestionnaire_aide", "membre"})
    public Response mettreAJourAide(
            @Parameter(description = "ID de la demande d'aide", required = true)
            @PathParam("id") Long id,
            
            @Parameter(description = "Nouvelles données de la demande d'aide", required = true)
            @Valid AideDTO aideDTO) {
        
        try {
            LOG.infof("PUT /api/aides/%d", id);
            
            AideDTO aideMiseAJour = aideService.mettreAJourAide(id, aideDTO);
            
            LOG.infof("Demande d'aide mise à jour avec succès: %s", aideMiseAJour.getNumeroReference());
            return Response.ok(aideMiseAJour).build();
            
        } catch (jakarta.ws.rs.NotFoundException e) {
            LOG.warnf("Demande d'aide non trouvée pour mise à jour: ID %d", id);
            return Response.status(Response.Status.NOT_FOUND)
                    .entity(Map.of("error", "Demande d'aide non trouvée"))
                    .build();
        } catch (SecurityException e) {
            LOG.warnf("Accès non autorisé pour mise à jour: ID %d", id);
            return Response.status(Response.Status.FORBIDDEN)
                    .entity(Map.of("error", "Accès non autorisé"))
                    .build();
        } catch (IllegalStateException e) {
            LOG.warnf("État invalide pour mise à jour: %s", e.getMessage());
            return Response.status(Response.Status.BAD_REQUEST)
                    .entity(Map.of("error", "État invalide", "message", e.getMessage()))
                    .build();
        } catch (IllegalArgumentException e) {
            LOG.warnf("Données invalides pour mise à jour: %s", e.getMessage());
            return Response.status(Response.Status.BAD_REQUEST)
                    .entity(Map.of("error", "Données invalides", "message", e.getMessage()))
                    .build();
        } catch (Exception e) {
            LOG.errorf("Erreur lors de la mise à jour de la demande d'aide %d: %s", id, e.getMessage());
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity(Map.of("error", "Erreur lors de la mise à jour"))
                    .build();
        }
    }

    // ===== OPÉRATIONS MÉTIER SPÉCIALISÉES =====

    /**
     * Approuve une demande d'aide
     */
    @POST
    @Path("/{id}/approuver")
    @Operation(summary = "Approuver une demande d'aide")
    @APIResponses({
        @APIResponse(responseCode = "200", description = "Demande d'aide approuvée avec succès"),
        @APIResponse(responseCode = "400", description = "Données invalides"),
        @APIResponse(responseCode = "403", description = "Accès non autorisé"),
        @APIResponse(responseCode = "404", description = "Demande d'aide non trouvée")
    })
    @RolesAllowed({"admin", "gestionnaire_aide", "evaluateur_aide"})
    public Response approuverAide(
            @Parameter(description = "ID de la demande d'aide", required = true)
            @PathParam("id") Long id,

            @Parameter(description = "Données d'approbation", required = true)
            Map<String, Object> approbationData) {

        try {
            LOG.infof("POST /api/aides/%d/approuver", id);

            // Extraction des données d'approbation
            BigDecimal montantApprouve = new BigDecimal(approbationData.get("montantApprouve").toString());
            String commentaires = (String) approbationData.get("commentaires");

            AideDTO aideApprouvee = aideService.approuverAide(id, montantApprouve, commentaires);

            LOG.infof("Demande d'aide approuvée avec succès: %s", aideApprouvee.getNumeroReference());
            return Response.ok(aideApprouvee).build();

        } catch (jakarta.ws.rs.NotFoundException e) {
            LOG.warnf("Demande d'aide non trouvée pour approbation: ID %d", id);
            return Response.status(Response.Status.NOT_FOUND)
                    .entity(Map.of("error", "Demande d'aide non trouvée"))
                    .build();
        } catch (SecurityException e) {
            LOG.warnf("Accès non autorisé pour approbation: ID %d", id);
            return Response.status(Response.Status.FORBIDDEN)
                    .entity(Map.of("error", "Accès non autorisé"))
                    .build();
        } catch (IllegalStateException e) {
            LOG.warnf("État invalide pour approbation: %s", e.getMessage());
            return Response.status(Response.Status.BAD_REQUEST)
                    .entity(Map.of("error", "État invalide", "message", e.getMessage()))
                    .build();
        } catch (IllegalArgumentException e) {
            LOG.warnf("Données invalides pour approbation: %s", e.getMessage());
            return Response.status(Response.Status.BAD_REQUEST)
                    .entity(Map.of("error", "Données invalides", "message", e.getMessage()))
                    .build();
        } catch (Exception e) {
            LOG.errorf("Erreur lors de l'approbation de la demande d'aide %d: %s", id, e.getMessage());
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity(Map.of("error", "Erreur lors de l'approbation"))
                    .build();
        }
    }

    /**
     * Rejette une demande d'aide
     */
    @POST
    @Path("/{id}/rejeter")
    @Operation(summary = "Rejeter une demande d'aide")
    @APIResponses({
        @APIResponse(responseCode = "200", description = "Demande d'aide rejetée avec succès"),
        @APIResponse(responseCode = "400", description = "Données invalides"),
        @APIResponse(responseCode = "403", description = "Accès non autorisé"),
        @APIResponse(responseCode = "404", description = "Demande d'aide non trouvée")
    })
    @RolesAllowed({"admin", "gestionnaire_aide", "evaluateur_aide"})
    public Response rejeterAide(
            @Parameter(description = "ID de la demande d'aide", required = true)
            @PathParam("id") Long id,

            @Parameter(description = "Données de rejet", required = true)
            Map<String, String> rejetData) {

        try {
            LOG.infof("POST /api/aides/%d/rejeter", id);

            String raisonRejet = rejetData.get("raisonRejet");
            if (raisonRejet == null || raisonRejet.trim().isEmpty()) {
                return Response.status(Response.Status.BAD_REQUEST)
                        .entity(Map.of("error", "La raison du rejet est obligatoire"))
                        .build();
            }

            AideDTO aideRejetee = aideService.rejeterAide(id, raisonRejet);

            LOG.infof("Demande d'aide rejetée avec succès: %s", aideRejetee.getNumeroReference());
            return Response.ok(aideRejetee).build();

        } catch (jakarta.ws.rs.NotFoundException e) {
            LOG.warnf("Demande d'aide non trouvée pour rejet: ID %d", id);
            return Response.status(Response.Status.NOT_FOUND)
                    .entity(Map.of("error", "Demande d'aide non trouvée"))
                    .build();
        } catch (SecurityException e) {
            LOG.warnf("Accès non autorisé pour rejet: ID %d", id);
            return Response.status(Response.Status.FORBIDDEN)
                    .entity(Map.of("error", "Accès non autorisé"))
                    .build();
        } catch (IllegalStateException e) {
            LOG.warnf("État invalide pour rejet: %s", e.getMessage());
            return Response.status(Response.Status.BAD_REQUEST)
                    .entity(Map.of("error", "État invalide", "message", e.getMessage()))
                    .build();
        } catch (Exception e) {
            LOG.errorf("Erreur lors du rejet de la demande d'aide %d: %s", id, e.getMessage());
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity(Map.of("error", "Erreur lors du rejet"))
                    .build();
        }
    }

    /**
     * Marque une aide comme versée
     */
    @POST
    @Path("/{id}/verser")
    @Operation(summary = "Marquer une aide comme versée")
    @APIResponses({
        @APIResponse(responseCode = "200", description = "Aide marquée comme versée avec succès"),
        @APIResponse(responseCode = "400", description = "Données invalides"),
        @APIResponse(responseCode = "403", description = "Accès non autorisé"),
        @APIResponse(responseCode = "404", description = "Demande d'aide non trouvée")
    })
    @RolesAllowed({"admin", "gestionnaire_aide", "tresorier"})
    public Response marquerCommeVersee(
            @Parameter(description = "ID de la demande d'aide", required = true)
            @PathParam("id") Long id,

            @Parameter(description = "Données de versement", required = true)
            Map<String, Object> versementData) {

        try {
            LOG.infof("POST /api/aides/%d/verser", id);

            // Extraction des données de versement
            BigDecimal montantVerse = new BigDecimal(versementData.get("montantVerse").toString());
            String modeVersement = (String) versementData.get("modeVersement");
            String numeroTransaction = (String) versementData.get("numeroTransaction");

            AideDTO aideVersee = aideService.marquerCommeVersee(id, montantVerse, modeVersement, numeroTransaction);

            LOG.infof("Aide marquée comme versée avec succès: %s", aideVersee.getNumeroReference());
            return Response.ok(aideVersee).build();

        } catch (jakarta.ws.rs.NotFoundException e) {
            LOG.warnf("Demande d'aide non trouvée pour versement: ID %d", id);
            return Response.status(Response.Status.NOT_FOUND)
                    .entity(Map.of("error", "Demande d'aide non trouvée"))
                    .build();
        } catch (SecurityException e) {
            LOG.warnf("Accès non autorisé pour versement: ID %d", id);
            return Response.status(Response.Status.FORBIDDEN)
                    .entity(Map.of("error", "Accès non autorisé"))
                    .build();
        } catch (IllegalStateException e) {
            LOG.warnf("État invalide pour versement: %s", e.getMessage());
            return Response.status(Response.Status.BAD_REQUEST)
                    .entity(Map.of("error", "État invalide", "message", e.getMessage()))
                    .build();
        } catch (IllegalArgumentException e) {
            LOG.warnf("Données invalides pour versement: %s", e.getMessage());
            return Response.status(Response.Status.BAD_REQUEST)
                    .entity(Map.of("error", "Données invalides", "message", e.getMessage()))
                    .build();
        } catch (Exception e) {
            LOG.errorf("Erreur lors du versement de l'aide %d: %s", id, e.getMessage());
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity(Map.of("error", "Erreur lors du versement"))
                    .build();
        }
    }

    // ===== ENDPOINTS DE RECHERCHE ET FILTRAGE =====

    /**
     * Liste les demandes d'aide par statut
     */
    @GET
    @Path("/statut/{statut}")
    @Operation(summary = "Lister les demandes d'aide par statut")
    @APIResponse(responseCode = "200", description = "Liste des demandes d'aide par statut")
    @RolesAllowed({"admin", "gestionnaire_aide", "evaluateur_aide", "membre"})
    public Response listerAidesParStatut(
            @Parameter(description = "Statut des demandes d'aide", required = true)
            @PathParam("statut") StatutAide statut,

            @Parameter(description = "Numéro de page (0-based)", example = "0")
            @QueryParam("page") @DefaultValue("0") @Min(0) int page,

            @Parameter(description = "Taille de la page", example = "20")
            @QueryParam("size") @DefaultValue("20") @Min(1) int size) {

        try {
            LOG.infof("GET /api/aides/statut/%s - page: %d, size: %d", statut, page, size);

            List<AideDTO> aides = aideService.listerAidesParStatut(statut, page, size);

            LOG.infof("Récupération réussie de %d demandes d'aide avec statut %s", aides.size(), statut);
            return Response.ok(aides).build();

        } catch (Exception e) {
            LOG.errorf("Erreur lors de la récupération des demandes d'aide par statut %s: %s", statut, e.getMessage());
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity(Map.of("error", "Erreur lors de la récupération"))
                    .build();
        }
    }

    /**
     * Liste les demandes d'aide d'un membre
     */
    @GET
    @Path("/membre/{membreId}")
    @Operation(summary = "Lister les demandes d'aide d'un membre")
    @APIResponse(responseCode = "200", description = "Liste des demandes d'aide du membre")
    @APIResponse(responseCode = "404", description = "Membre non trouvé")
    @RolesAllowed({"admin", "gestionnaire_aide", "evaluateur_aide", "membre"})
    public Response listerAidesParMembre(
            @Parameter(description = "ID du membre", required = true)
            @PathParam("membreId") Long membreId,

            @Parameter(description = "Numéro de page (0-based)", example = "0")
            @QueryParam("page") @DefaultValue("0") @Min(0) int page,

            @Parameter(description = "Taille de la page", example = "20")
            @QueryParam("size") @DefaultValue("20") @Min(1) int size) {

        try {
            LOG.infof("GET /api/aides/membre/%d - page: %d, size: %d", membreId, page, size);

            List<AideDTO> aides = aideService.listerAidesParMembre(membreId, page, size);

            LOG.infof("Récupération réussie de %d demandes d'aide pour le membre %d", aides.size(), membreId);
            return Response.ok(aides).build();

        } catch (jakarta.ws.rs.NotFoundException e) {
            LOG.warnf("Membre non trouvé: ID %d", membreId);
            return Response.status(Response.Status.NOT_FOUND)
                    .entity(Map.of("error", "Membre non trouvé"))
                    .build();
        } catch (Exception e) {
            LOG.errorf("Erreur lors de la récupération des demandes d'aide du membre %d: %s", membreId, e.getMessage());
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity(Map.of("error", "Erreur lors de la récupération"))
                    .build();
        }
    }

    /**
     * Liste les demandes d'aide publiques
     */
    @GET
    @Path("/publiques")
    @Operation(summary = "Lister les demandes d'aide publiques")
    @APIResponse(responseCode = "200", description = "Liste des demandes d'aide publiques")
    @RolesAllowed({"admin", "gestionnaire_aide", "evaluateur_aide", "membre"})
    public Response listerAidesPubliques(
            @Parameter(description = "Numéro de page (0-based)", example = "0")
            @QueryParam("page") @DefaultValue("0") @Min(0) int page,

            @Parameter(description = "Taille de la page", example = "20")
            @QueryParam("size") @DefaultValue("20") @Min(1) int size) {

        try {
            LOG.infof("GET /api/aides/publiques - page: %d, size: %d", page, size);

            List<AideDTO> aides = aideService.listerAidesPubliques(page, size);

            LOG.infof("Récupération réussie de %d demandes d'aide publiques", aides.size());
            return Response.ok(aides).build();

        } catch (Exception e) {
            LOG.errorf("Erreur lors de la récupération des demandes d'aide publiques: %s", e.getMessage());
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity(Map.of("error", "Erreur lors de la récupération"))
                    .build();
        }
    }

    /**
     * Recherche textuelle dans les demandes d'aide
     */
    @GET
    @Path("/recherche")
    @Operation(summary = "Rechercher des demandes d'aide par texte")
    @APIResponse(responseCode = "200", description = "Résultats de la recherche")
    @RolesAllowed({"admin", "gestionnaire_aide", "evaluateur_aide", "membre"})
    public Response rechercherAides(
            @Parameter(description = "Terme de recherche", required = true)
            @QueryParam("q") @NotNull String recherche,

            @Parameter(description = "Numéro de page (0-based)", example = "0")
            @QueryParam("page") @DefaultValue("0") @Min(0) int page,

            @Parameter(description = "Taille de la page", example = "20")
            @QueryParam("size") @DefaultValue("20") @Min(1) int size) {

        try {
            LOG.infof("GET /api/aides/recherche?q=%s - page: %d, size: %d", recherche, page, size);

            List<AideDTO> aides = aideService.rechercherAides(recherche, page, size);

            LOG.infof("Recherche réussie: %d demandes d'aide trouvées pour '%s'", aides.size(), recherche);
            return Response.ok(aides).build();

        } catch (Exception e) {
            LOG.errorf("Erreur lors de la recherche de demandes d'aide: %s", e.getMessage());
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity(Map.of("error", "Erreur lors de la recherche"))
                    .build();
        }
    }

    /**
     * Statistiques globales des demandes d'aide
     */
    @GET
    @Path("/statistiques")
    @Operation(summary = "Obtenir les statistiques des demandes d'aide")
    @APIResponse(responseCode = "200", description = "Statistiques des demandes d'aide")
    @RolesAllowed({"admin", "gestionnaire_aide", "evaluateur_aide"})
    public Response obtenirStatistiques() {

        try {
            LOG.info("GET /api/aides/statistiques");

            Map<String, Object> statistiques = aideService.obtenirStatistiquesGlobales();

            LOG.info("Statistiques calculées avec succès");
            return Response.ok(statistiques).build();

        } catch (Exception e) {
            LOG.errorf("Erreur lors du calcul des statistiques: %s", e.getMessage());
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity(Map.of("error", "Erreur lors du calcul des statistiques"))
                    .build();
        }
    }

    /**
     * Demandes d'aide urgentes en attente
     */
    @GET
    @Path("/urgentes")
    @Operation(summary = "Lister les demandes d'aide urgentes en attente")
    @APIResponse(responseCode = "200", description = "Liste des demandes d'aide urgentes")
    @RolesAllowed({"admin", "gestionnaire_aide", "evaluateur_aide"})
    public Response listerAidesUrgentes() {

        try {
            LOG.info("GET /api/aides/urgentes");

            List<AideDTO> aides = aideService.listerAidesUrgentesEnAttente();

            LOG.infof("Récupération réussie de %d demandes d'aide urgentes", aides.size());
            return Response.ok(aides).build();

        } catch (Exception e) {
            LOG.errorf("Erreur lors de la récupération des demandes d'aide urgentes: %s", e.getMessage());
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity(Map.of("error", "Erreur lors de la récupération"))
                    .build();
        }
    }
}
