package dev.lions.unionflow.client.view;

import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.stream.Collectors;

import org.eclipse.microprofile.rest.client.inject.RestClient;
import org.jboss.logging.Logger;

import dev.lions.unionflow.server.api.dto.membre.response.MembreResponse;
import dev.lions.unionflow.server.api.dto.common.PagedResponse;
import dev.lions.unionflow.server.api.dto.organisation.response.OrganisationResponse;
import dev.lions.unionflow.server.api.dto.organisation.response.OrganisationSummaryResponse;
import dev.lions.unionflow.server.api.dto.common.PagedResponse;
import dev.lions.unionflow.server.api.dto.finance.request.*;
import dev.lions.unionflow.server.api.dto.common.PagedResponse;
import dev.lions.unionflow.server.api.dto.finance.response.*;
import dev.lions.unionflow.server.api.dto.common.PagedResponse;
import dev.lions.unionflow.client.service.AdhesionService;
import dev.lions.unionflow.client.service.OrganisationService;
import dev.lions.unionflow.client.service.ErrorHandlerService;
import dev.lions.unionflow.client.service.MembreService;
import dev.lions.unionflow.client.service.RetryService;
import jakarta.annotation.PostConstruct;
import jakarta.enterprise.context.SessionScoped;
import jakarta.faces.model.SelectItem;
import jakarta.inject.Inject;
import jakarta.inject.Named;

/**
 * Bean JSF pour la gestion des adhésions
 * Utilise directement MembreResponse et se connecte au backend
 * 
 * @author UnionFlow Team
 * @version 1.0
 */
@Named("adhesionsBean")
@SessionScoped
public class AdhesionsBean implements Serializable {

    private static final long serialVersionUID = 1L;
    private static final Logger LOG = Logger.getLogger(AdhesionsBean.class);

    @Inject
    @RestClient
    private AdhesionService adhesionService;

    @Inject
    @RestClient
    private MembreService membreService;

    @Inject
    @RestClient
    private OrganisationService organisationService;

    @Inject
    ErrorHandlerService errorHandler;

    @Inject
    RetryService retryService;

    // Listes de référence pour les select
    private List<MembreResponse> listeMembres;
    private List<OrganisationSummaryResponse> listeAssociations;

    // Données principales
    private List<AdhesionResponse> toutesLesAdhesions;
    private List<AdhesionResponse> adhesionsFiltrees;
    private List<AdhesionResponse> adhesionsSelectionnees;
    private AdhesionResponse adhesionSelectionnee;

    // Formulaire nouvelle adhésion
    private NouvelleAdhesion nouvelleAdhesion;

    // Paiement partiel
    private BigDecimal montantPaiementPartiel;

    // Filtres
    private FiltresAdhesion filtres;

    // Statistiques
    private StatistiquesAdhesion statistiques;

    @PostConstruct
    public void init() {
        initializeFiltres();
        chargerMembresEtAssociations();
        chargerAdhesions();
        chargerStatistiques();
        initializeNouvelleAdhesion();
        appliquerFiltres();
    }

    /**
     * Charge les listes de membres et d'associations depuis le backend
     */
    private void chargerMembresEtAssociations() {
        listeMembres = new ArrayList<>();
        listeAssociations = new ArrayList<>();

        try {
            listeMembres = retryService.executeWithRetrySupplier(
                    () -> membreService.listerActifs(),
                    "chargement des membres actifs");
            LOG.infof("Membres actifs chargés: %d membres", listeMembres.size());
        } catch (Exception e) {
            LOG.warnf(e, "Impossible de charger les membres");
            errorHandler.handleException(e, "lors du chargement des membres", null);
        }

        try {
            PagedResponse<OrganisationSummaryResponse> response = retryService.executeWithRetrySupplier(
                    () -> organisationService.listerToutes(0, 1000),
                    "chargement des associations");
            listeAssociations = (response != null && response.getData() != null) ? response.getData()
                    : new ArrayList<OrganisationSummaryResponse>();
            LOG.infof("Associations chargées: %d associations", listeAssociations.size());
        } catch (Exception e) {
            LOG.warnf(e, "Impossible de charger les associations");
            errorHandler.handleException(e, "lors du chargement des associations", null);
        }
    }

    /**
     * Retourne la liste des membres pour les SelectItem
     */
    public List<SelectItem> getMembresSelectItems() {
        List<SelectItem> items = new ArrayList<>();
        items.add(new SelectItem(null, "Sélectionner un membre"));
        if (listeMembres != null) {
            for (MembreResponse membre : listeMembres) {
                String label = membre.getPrenom() + " " + membre.getNom();
                if (membre.getNumeroMembre() != null) {
                    label += " (" + membre.getNumeroMembre() + ")";
                }
                items.add(new SelectItem(membre.getId(), label));
            }
        }
        return items;
    }

    /**
     * Retourne la liste des associations pour les SelectItem
     */
    public List<SelectItem> getAssociationsSelectItems() {
        List<SelectItem> items = new ArrayList<>();
        items.add(new SelectItem(null, "Sélectionner une organisation"));
        if (listeAssociations != null) {
            for (OrganisationSummaryResponse assoc : listeAssociations) {
                String label = assoc.getNom();
                if (assoc.getTypeOrganisation() != null) {
                    label += " (" + assoc.getTypeOrganisation() + ")";
                }
                items.add(new SelectItem(assoc.getId(), label));
            }
        }
        return items;
    }

    private void initializeFiltres() {
        filtres = new FiltresAdhesion();
        adhesionsSelectionnees = new ArrayList<>();
    }

    /**
     * Charge les adhésions depuis le backend
     */
    private void chargerAdhesions() {
        toutesLesAdhesions = new ArrayList<>();
        try {
            toutesLesAdhesions = retryService.executeWithRetrySupplier(
                    () -> adhesionService.listerToutes(0, 1000),
                    "chargement des adhésions");
            LOG.infof("Adhésions chargées: %d adhésions", toutesLesAdhesions.size());
        } catch (Exception e) {
            LOG.errorf(e, "Erreur lors du chargement des adhésions");
            errorHandler.handleException(e, "lors du chargement des adhésions", null);
        }
    }

    /**
     * Charge les statistiques depuis le backend
     */
    private void chargerStatistiques() {
        statistiques = new StatistiquesAdhesion();
        try {
            Map<String, Object> statsBackend = adhesionService.obtenirStatistiques();

            // Extraction des statistiques du backend
            Long totalAdhesions = ((Number) statsBackend.getOrDefault("totalAdhesions", 0L)).longValue();
            Long adhesionsApprouvees = ((Number) statsBackend.getOrDefault("adhesionsApprouvees", 0L)).longValue();
            Long adhesionsEnAttente = ((Number) statsBackend.getOrDefault("adhesionsEnAttente", 0L)).longValue();
            Long adhesionsPayees = ((Number) statsBackend.getOrDefault("adhesionsPayees", 0L)).longValue();
            Double tauxApprobation = ((Number) statsBackend.getOrDefault("tauxApprobation", 0.0)).doubleValue();
            Double tauxPaiement = ((Number) statsBackend.getOrDefault("tauxPaiement", 0.0)).doubleValue();

            // Calcul des montants depuis les adhésions réelles
            BigDecimal totalCollecte = toutesLesAdhesions.stream()
                    .filter(a -> "PAYEE".equals(a.getStatut()) || "EN_PAIEMENT".equals(a.getStatut()))
                    .map(a -> a.getMontantPaye() != null ? a.getMontantPaye() : BigDecimal.ZERO)
                    .reduce(BigDecimal.ZERO, BigDecimal::add);

            BigDecimal totalFrais = toutesLesAdhesions.stream()
                    .map(a -> a.getFraisAdhesion() != null ? a.getFraisAdhesion() : BigDecimal.ZERO)
                    .reduce(BigDecimal.ZERO, BigDecimal::add);

            statistiques.setTotalAdhesions(totalAdhesions.intValue());
            statistiques.setAdhesionsApprouvees(adhesionsApprouvees.intValue());
            statistiques.setAdhesionsEnAttente(adhesionsEnAttente.intValue());
            statistiques.setAdhesionsPayees(adhesionsPayees.intValue());
            statistiques.setTauxApprobation(tauxApprobation);
            statistiques.setTauxPaiement(tauxPaiement);
            statistiques.setTotalCollecte(totalCollecte);
            statistiques.setTotalFrais(totalFrais);

            LOG.infof("Statistiques chargées: Total=%d, Approuvées=%d", totalAdhesions, adhesionsApprouvees);
        } catch (Exception e) {
            LOG.errorf(e, "Erreur lors du chargement des statistiques");
            errorHandler.handleException(e, "lors du chargement des statistiques", null);
            initialiserStatistiquesParDefaut();
        }
    }

    private void initialiserStatistiquesParDefaut() {
        statistiques.setTotalAdhesions(0);
        statistiques.setAdhesionsApprouvees(0);
        statistiques.setAdhesionsEnAttente(0);
        statistiques.setAdhesionsPayees(0);
        statistiques.setTauxApprobation(0.0);
        statistiques.setTauxPaiement(0.0);
        statistiques.setTotalCollecte(BigDecimal.ZERO);
        statistiques.setTotalFrais(BigDecimal.ZERO);
    }

    /**
     * Applique les filtres en utilisant la recherche backend
     */
    private void appliquerFiltres() {
        try {
            // Utiliser la recherche backend
            if (filtres.getStatut() != null && !filtres.getStatut().isEmpty()) {
                adhesionsFiltrees = adhesionService.obtenirParStatut(filtres.getStatut(), 0, 1000);
            } else {
                adhesionsFiltrees = new ArrayList<>(toutesLesAdhesions);
            }

            // Appliquer les filtres supplémentaires côté client si nécessaire
            if (filtres.getNomMembre() != null && !filtres.getNomMembre().trim().isEmpty()) {
                adhesionsFiltrees = adhesionsFiltrees.stream()
                        .filter(a -> a.getNomMembre() != null
                                && a.getNomMembre().toLowerCase().contains(filtres.getNomMembre().toLowerCase()))
                        .collect(Collectors.toList());
            }

            if (filtres.getDateDebut() != null) {
                adhesionsFiltrees = adhesionsFiltrees.stream()
                        .filter(a -> a.getDateDemande() != null
                                && !a.getDateDemande().isBefore(filtres.getDateDebut()))
                        .collect(Collectors.toList());
            }

            if (filtres.getDateFin() != null) {
                adhesionsFiltrees = adhesionsFiltrees.stream()
                        .filter(a -> a.getDateDemande() != null
                                && !a.getDateDemande().isAfter(filtres.getDateFin()))
                        .collect(Collectors.toList());
            }
        } catch (Exception e) {
            LOG.errorf(e, "Erreur lors de l'application des filtres");
            errorHandler.handleException(e, "lors de l'application des filtres", null);
            adhesionsFiltrees = new ArrayList<>();
        }
    }

    // Actions

    /**
     * Recherche avec filtres
     */
    public void rechercher() {
        appliquerFiltres();
        errorHandler.showInfo("Recherche", adhesionsFiltrees.size() + " adhésion(s) trouvée(s)");
    }

    /**
     * Réinitialise les filtres
     */
    public void reinitialiserFiltres() {
        filtres = new FiltresAdhesion();
        chargerAdhesions();
        appliquerFiltres();
    }

    /**
     * Enregistre une nouvelle adhésion via le backend
     */
    public void enregistrerAdhesion() {
        try {
            // Validation des champs requis
            if (nouvelleAdhesion.getMembreId() == null) {
                errorHandler.showWarning("Erreur", "Veuillez sélectionner un membre");
                return;
            }
            if (nouvelleAdhesion.getOrganisationId() == null) {
                errorHandler.showWarning("Erreur", "Veuillez sélectionner une organisation");
                return;
            }

            CreateAdhesionRequest request = CreateAdhesionRequest.builder()
                    .numeroReference("ADH-" + System.currentTimeMillis())
                    .membreId(nouvelleAdhesion.getMembreId())
                    .organisationId(nouvelleAdhesion.getOrganisationId())
                    .dateDemande(LocalDate.now())
                    .fraisAdhesion(nouvelleAdhesion.getFraisAdhesion() != null
                            ? nouvelleAdhesion.getFraisAdhesion()
                            : BigDecimal.ZERO)
                    .codeDevise("XOF")
                    .observations(nouvelleAdhesion.getObservations())
                    .build();

            AdhesionResponse adhesionCreee = retryService.executeWithRetrySupplier(
                    () -> adhesionService.creer(request),
                    "création d'une adhésion");

            // Recharger les données depuis le backend
            chargerAdhesions();
            chargerStatistiques();
            appliquerFiltres();
            initializeNouvelleAdhesion();

            LOG.infof("Nouvelle adhésion créée: %s", adhesionCreee.getId());
            errorHandler.showSuccess("Succès", "Adhésion créée avec succès");
        } catch (Exception e) {
            LOG.errorf(e, "Erreur lors de la création de l'adhésion");
            errorHandler.handleException(e, "lors de la création d'une adhésion", null);
        }
    }

    /**
     * Approuve une adhésion
     */
    public void approuverAdhesion() {
        if (adhesionSelectionnee == null || adhesionSelectionnee.getId() == null) {
            errorHandler.showWarning("Erreur", "Aucune adhésion sélectionnée");
            return;
        }

        try {
            retryService.executeWithRetrySupplier(
                    () -> {
                        adhesionService.approuver(adhesionSelectionnee.getId(), "Admin");
                        return null;
                    },
                    "approbation d'une adhésion");

            // Recharger les données depuis le backend
            chargerAdhesions();
            chargerStatistiques();
            appliquerFiltres();

            LOG.infof("Adhésion approuvée: %s", adhesionSelectionnee.getId());
            errorHandler.showSuccess("Succès", "Adhésion approuvée avec succès");
        } catch (Exception e) {
            LOG.errorf(e, "Erreur lors de l'approbation");
            errorHandler.handleException(e, "lors de l'approbation d'une adhésion", null);
        }
    }

    /**
     * Rejette une adhésion
     */
    public void rejeterAdhesion(String motifRejet) {
        if (adhesionSelectionnee == null || adhesionSelectionnee.getId() == null) {
            errorHandler.showWarning("Erreur", "Aucune adhésion sélectionnée");
            return;
        }

        if (motifRejet == null || motifRejet.trim().isEmpty()) {
            errorHandler.showWarning("Erreur", "Veuillez indiquer un motif de rejet");
            return;
        }

        try {
            retryService.executeWithRetrySupplier(
                    () -> {
                        adhesionService.rejeter(adhesionSelectionnee.getId(), motifRejet);
                        return null;
                    },
                    "rejet d'une adhésion");

            // Recharger les données depuis le backend
            chargerAdhesions();
            chargerStatistiques();
            appliquerFiltres();

            // Réinitialiser le motif de rejet
            adhesionSelectionnee.setMotifRejet(null);

            LOG.infof("Adhésion rejetée: %s - Motif: %s", adhesionSelectionnee.getId(), motifRejet);
            errorHandler.showSuccess("Succès", "Adhésion rejetée avec succès");
        } catch (Exception e) {
            LOG.errorf(e, "Erreur lors du rejet");
            errorHandler.handleException(e, "lors du rejet d'une adhésion", null);
        }
    }

    /**
     * Enregistre un paiement complet pour une adhésion
     */
    public void enregistrerPaiement(BigDecimal montantPaye, String methodePaiement, String referencePaiement) {
        if (adhesionSelectionnee == null || adhesionSelectionnee.getId() == null) {
            errorHandler.showWarning("Erreur", "Aucune adhésion sélectionnée");
            return;
        }

        if (montantPaye == null || montantPaye.compareTo(BigDecimal.ZERO) <= 0) {
            errorHandler.showWarning("Erreur", "Le montant doit être supérieur à zéro");
            return;
        }

        try {
            retryService.executeWithRetrySupplier(
                    () -> {
                        adhesionService.enregistrerPaiement(
                                adhesionSelectionnee.getId(),
                                montantPaye,
                                methodePaiement != null ? methodePaiement : "ESPECES",
                                referencePaiement);
                        return null;
                    },
                    "enregistrement d'un paiement d'adhésion");

            // Recharger les données depuis le backend
            chargerAdhesions();
            chargerStatistiques();
            appliquerFiltres();

            LOG.infof("Paiement enregistré pour l'adhésion: %s - Montant: %s",
                    adhesionSelectionnee.getId(), montantPaye);
            errorHandler.showSuccess("Succès", "Paiement enregistré avec succès");
        } catch (Exception e) {
            LOG.errorf(e, "Erreur lors de l'enregistrement du paiement");
            errorHandler.handleException(e, "lors de l'enregistrement d'un paiement", null);
        }
    }

    /**
     * Enregistre un paiement partiel pour une adhésion
     */
    public void enregistrerPaiementPartiel() {
        if (adhesionSelectionnee == null || adhesionSelectionnee.getId() == null) {
            errorHandler.showWarning("Erreur", "Aucune adhésion sélectionnée");
            return;
        }

        if (montantPaiementPartiel == null || montantPaiementPartiel.compareTo(BigDecimal.ZERO) <= 0) {
            errorHandler.showWarning("Erreur", "Le montant du paiement partiel doit être supérieur à zéro");
            return;
        }

        // Vérifier que le montant ne dépasse pas le montant restant
        BigDecimal montantRestant = adhesionSelectionnee.getFraisAdhesion()
                .subtract(adhesionSelectionnee.getMontantPaye() != null ? adhesionSelectionnee.getMontantPaye()
                        : BigDecimal.ZERO);

        if (montantPaiementPartiel.compareTo(montantRestant) > 0) {
            errorHandler.showWarning("Erreur",
                    "Le montant du paiement partiel ne peut pas dépasser le montant restant: "
                            + montantRestant + " FCFA");
            return;
        }

        try {
            BigDecimal montantAEnregistrer = montantPaiementPartiel;

            retryService.executeWithRetrySupplier(
                    () -> {
                        adhesionService.enregistrerPaiement(
                                adhesionSelectionnee.getId(),
                                montantAEnregistrer,
                                adhesionSelectionnee.getMethodePaiement() != null
                                        ? adhesionSelectionnee.getMethodePaiement()
                                        : "ESPECES",
                                adhesionSelectionnee.getReferencePaiement());
                        return null;
                    },
                    "enregistrement d'un paiement partiel d'adhésion");

            // Recharger les données depuis le backend
            chargerAdhesions();
            chargerStatistiques();
            appliquerFiltres();

            // Réinitialiser le montant du paiement partiel
            montantPaiementPartiel = null;

            LOG.infof("Paiement partiel enregistré pour l'adhésion: %s - Montant: %s",
                    adhesionSelectionnee.getId(), montantAEnregistrer);
            errorHandler.showSuccess("Succès", "Paiement partiel enregistré avec succès");
        } catch (Exception e) {
            LOG.errorf(e, "Erreur lors de l'enregistrement du paiement partiel");
            errorHandler.handleException(e, "lors de l'enregistrement d'un paiement partiel", null);
        }
    }

    /**
     * Sélectionne une adhésion pour afficher ses détails
     */
    public void selectionnerAdhesion(AdhesionResponse adhesion) {
        this.adhesionSelectionnee = adhesion;
    }

    /**
     * Actualise les données depuis le backend
     */
    public void actualiser() {
        chargerAdhesions();
        chargerStatistiques();
        appliquerFiltres();
        errorHandler.showSuccess("Actualisation", "Données actualisées");
    }

    /**
     * Charge les adhésions en attente depuis le backend
     */
    public void chargerAdhesionsEnAttente() {
        try {
            toutesLesAdhesions = retryService.executeWithRetrySupplier(
                    () -> adhesionService.obtenirEnAttente(0, 1000),
                    "chargement des adhésions en attente");
            appliquerFiltres();
            LOG.infof("Adhésions en attente chargées: %d adhésions", toutesLesAdhesions.size());
        } catch (Exception e) {
            LOG.errorf(e, "Erreur lors du chargement des adhésions en attente");
            errorHandler.handleException(e, "lors du chargement des adhésions en attente", null);
        }
    }

    private void initializeNouvelleAdhesion() {
        nouvelleAdhesion = new NouvelleAdhesion();
    }

    // Getters et Setters

    public List<AdhesionResponse> getToutesLesAdhesions() {
        return toutesLesAdhesions;
    }

    public void setToutesLesAdhesions(List<AdhesionResponse> toutesLesAdhesions) {
        this.toutesLesAdhesions = toutesLesAdhesions;
    }

    public List<AdhesionResponse> getAdhesionsFiltrees() {
        return adhesionsFiltrees;
    }

    public void setAdhesionsFiltrees(List<AdhesionResponse> adhesionsFiltrees) {
        this.adhesionsFiltrees = adhesionsFiltrees;
    }

    public List<AdhesionResponse> getAdhesionsSelectionnees() {
        return adhesionsSelectionnees;
    }

    public void setAdhesionsSelectionnees(List<AdhesionResponse> adhesionsSelectionnees) {
        this.adhesionsSelectionnees = adhesionsSelectionnees;
    }

    public AdhesionResponse getAdhesionSelectionnee() {
        return adhesionSelectionnee;
    }

    public void setAdhesionSelectionnee(AdhesionResponse adhesionSelectionnee) {
        this.adhesionSelectionnee = adhesionSelectionnee;
    }

    public NouvelleAdhesion getNouvelleAdhesion() {
        return nouvelleAdhesion;
    }

    public void setNouvelleAdhesion(NouvelleAdhesion nouvelleAdhesion) {
        this.nouvelleAdhesion = nouvelleAdhesion;
    }

    public FiltresAdhesion getFiltres() {
        return filtres;
    }

    public void setFiltres(FiltresAdhesion filtres) {
        this.filtres = filtres;
    }

    public StatistiquesAdhesion getStatistiques() {
        return statistiques;
    }

    public void setStatistiques(StatistiquesAdhesion statistiques) {
        this.statistiques = statistiques;
    }

    public BigDecimal getMontantPaiementPartiel() {
        return montantPaiementPartiel;
    }

    public void setMontantPaiementPartiel(BigDecimal montantPaiementPartiel) {
        this.montantPaiementPartiel = montantPaiementPartiel;
    }

    // Classes internes pour les formulaires et filtres

    public static class NouvelleAdhesion implements Serializable {
        private static final long serialVersionUID = 1L;
        private UUID membreId;
        private UUID organisationId;
        private BigDecimal fraisAdhesion;
        private String observations;

        // Getters et Setters
        public UUID getMembreId() {
            return membreId;
        }

        public void setMembreId(UUID membreId) {
            this.membreId = membreId;
        }

        public UUID getOrganisationId() {
            return organisationId;
        }

        public void setOrganisationId(UUID organisationId) {
            this.organisationId = organisationId;
        }

        public BigDecimal getFraisAdhesion() {
            return fraisAdhesion;
        }

        public void setFraisAdhesion(BigDecimal fraisAdhesion) {
            this.fraisAdhesion = fraisAdhesion;
        }

        public String getObservations() {
            return observations;
        }

        public void setObservations(String observations) {
            this.observations = observations;
        }
    }

    public static class FiltresAdhesion implements Serializable {
        private static final long serialVersionUID = 1L;
        private String statut;
        private String nomMembre;
        private LocalDate dateDebut;
        private LocalDate dateFin;

        // Getters et Setters
        public String getStatut() {
            return statut;
        }

        public void setStatut(String statut) {
            this.statut = statut;
        }

        public String getNomMembre() {
            return nomMembre;
        }

        public void setNomMembre(String nomMembre) {
            this.nomMembre = nomMembre;
        }

        public LocalDate getDateDebut() {
            return dateDebut;
        }

        public void setDateDebut(LocalDate dateDebut) {
            this.dateDebut = dateDebut;
        }

        public LocalDate getDateFin() {
            return dateFin;
        }

        public void setDateFin(LocalDate dateFin) {
            this.dateFin = dateFin;
        }
    }

    public static class StatistiquesAdhesion implements Serializable {
        private static final long serialVersionUID = 1L;
        private int totalAdhesions;
        private int adhesionsApprouvees;
        private int adhesionsEnAttente;
        private int adhesionsPayees;
        private double tauxApprobation;
        private double tauxPaiement;
        private BigDecimal totalCollecte;
        private BigDecimal totalFrais;

        // Getters et Setters
        public int getTotalAdhesions() {
            return totalAdhesions;
        }

        public void setTotalAdhesions(int totalAdhesions) {
            this.totalAdhesions = totalAdhesions;
        }

        public int getAdhesionsApprouvees() {
            return adhesionsApprouvees;
        }

        public void setAdhesionsApprouvees(int adhesionsApprouvees) {
            this.adhesionsApprouvees = adhesionsApprouvees;
        }

        public int getAdhesionsEnAttente() {
            return adhesionsEnAttente;
        }

        public void setAdhesionsEnAttente(int adhesionsEnAttente) {
            this.adhesionsEnAttente = adhesionsEnAttente;
        }

        public int getAdhesionsPayees() {
            return adhesionsPayees;
        }

        public void setAdhesionsPayees(int adhesionsPayees) {
            this.adhesionsPayees = adhesionsPayees;
        }

        public double getTauxApprobation() {
            return tauxApprobation;
        }

        public void setTauxApprobation(double tauxApprobation) {
            this.tauxApprobation = tauxApprobation;
        }

        public double getTauxPaiement() {
            return tauxPaiement;
        }

        public void setTauxPaiement(double tauxPaiement) {
            this.tauxPaiement = tauxPaiement;
        }

        public BigDecimal getTotalCollecte() {
            return totalCollecte;
        }

        public void setTotalCollecte(BigDecimal totalCollecte) {
            this.totalCollecte = totalCollecte;
        }

        public BigDecimal getTotalFrais() {
            return totalFrais;
        }

        public void setTotalFrais(BigDecimal totalFrais) {
            this.totalFrais = totalFrais;
        }

        // Méthodes utilitaires pour l'affichage
        public String getTotalCollecteFormatte() {
            if (totalCollecte == null)
                return "0 FCFA";
            return String.format("%,.0f FCFA", totalCollecte.doubleValue());
        }

        public String getTotalFraisFormatte() {
            if (totalFrais == null)
                return "0 FCFA";
            return String.format("%,.0f FCFA", totalFrais.doubleValue());
        }

        public int getTauxApprobationInt() {
            return (int) Math.round(tauxApprobation);
        }

        public int getTauxPaiementInt() {
            return (int) Math.round(tauxPaiement);
        }
    }
}
