package dev.lions.unionflow.client.view;

import dev.lions.unionflow.client.service.DashboardService;
import dev.lions.unionflow.server.api.dto.dashboard.DashboardDataResponse;
import dev.lions.unionflow.server.api.dto.dashboard.DashboardStatsResponse;
import dev.lions.unionflow.server.api.dto.dashboard.RecentActivityResponse;
import dev.lions.unionflow.server.api.dto.dashboard.UpcomingEventResponse;
import jakarta.faces.view.ViewScoped;
import jakarta.inject.Named;
import jakarta.inject.Inject;
import jakarta.annotation.PostConstruct;
import org.eclipse.microprofile.rest.client.inject.RestClient;
import org.jboss.logging.Logger;
import dev.lions.unionflow.client.service.ErrorHandlerService;
import dev.lions.unionflow.client.service.RetryService;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

/**
 * Bean JSF pour les tableaux de bord analytiques
 * 
 * @author UnionFlow Team
 * @version 1.0
 */
@Named("tableauxBordBean")
@ViewScoped
public class TableauxBordBean implements Serializable {
    
    private static final long serialVersionUID = 1L;
    private static final Logger LOG = Logger.getLogger(TableauxBordBean.class);
    
    @Inject
    @RestClient
    private DashboardService dashboardService;
    
    @Inject
    private UserSession userSession;
    
    @Inject
    ErrorHandlerService errorHandler;
    
    @Inject
    RetryService retryService;
    
    // Données
    private DashboardDataResponse dashboardData;
    private DashboardStatsResponse stats;
    private List<RecentActivityResponse> activitesRecentes = new ArrayList<>();
    private List<UpcomingEventResponse> evenementsAvenir = new ArrayList<>();
    
    // Paramètres
    private String organisationId;
    private String userId;
    private int limiteActivites = 10;
    private int limiteEvenements = 5;
    
    @PostConstruct
    public void init() {
        try {
            if (userSession != null) {
                if (userSession.getEntite() != null && userSession.getEntite().getId() != null) {
                    organisationId = userSession.getEntite().getId().toString();
                }
                if (userSession.getCurrentUser() != null && userSession.getCurrentUser().getId() != null) {
                    userId = userSession.getCurrentUser().getId().toString();
                }
            } else {
                LOG.warn("UserSession est null, chargement des données sans filtres organisation/user");
            }
            chargerDonnees();
        } catch (Exception e) {
            LOG.errorf(e, "Erreur lors de l'initialisation du TableauxBordBean");
            initValeursParDefaut();
        }
    }
    
    public void chargerDonnees() {
        try {
            if (organisationId != null && userId != null) {
                dashboardData = retryService.executeWithRetrySupplier(
                    () -> dashboardService.getDashboardData(organisationId, userId),
                    "chargement des données du tableau de bord"
                );
                if (dashboardData != null) {
                    stats = dashboardData.getStats();
                    activitesRecentes = dashboardData.getRecentActivities() != null ? dashboardData.getRecentActivities() : new ArrayList<>();
                    evenementsAvenir = dashboardData.getUpcomingEvents() != null ? dashboardData.getUpcomingEvents() : new ArrayList<>();
                }
                
                // Charger aussi les statistiques séparément si nécessaire
                if (stats == null) {
                    stats = retryService.executeWithRetrySupplier(
                        () -> dashboardService.getDashboardStats(organisationId, userId),
                        "chargement des statistiques du tableau de bord"
                    );
                }
                
                LOG.infof("Données du tableau de bord chargées pour organisation: %s, user: %s", organisationId, userId);
            } else {
                LOG.warn("OrganisationId ou UserId manquant, chargement des données globales");
                // Essayer de charger les données globales si disponibles
                try {
                    stats = retryService.executeWithRetrySupplier(
                        () -> dashboardService.getDashboardStats(null, null),
                        "chargement des statistiques globales"
                    );
                    dashboardData = retryService.executeWithRetrySupplier(
                        () -> dashboardService.getDashboardData(null, null),
                        "chargement des données globales"
                    );
                    if (dashboardData != null) {
                        activitesRecentes = dashboardData.getRecentActivities() != null ? dashboardData.getRecentActivities() : new ArrayList<>();
                        evenementsAvenir = dashboardData.getUpcomingEvents() != null ? dashboardData.getUpcomingEvents() : new ArrayList<>();
                    }
                } catch (Exception e2) {
                    LOG.warnf(e2, "Impossible de charger les données globales");
                    initValeursParDefaut();
                }
            }
        } catch (Exception e) {
            LOG.errorf(e, "Erreur lors du chargement des données du tableau de bord");
            errorHandler.handleException(e, "lors du chargement des données du tableau de bord", null);
            initValeursParDefaut();
        }
    }
    
    public void rafraichir() {
        try {
            if (organisationId != null && userId != null) {
                retryService.executeWithRetrySupplier(
                    () -> {
                        dashboardService.refreshDashboard(organisationId, userId);
                        return null;
                    },
                    "rafraîchissement du tableau de bord"
                );
                chargerDonnees();
                errorHandler.showSuccess("Succès", "Données rafraîchies avec succès");
            }
        } catch (Exception e) {
            LOG.errorf(e, "Erreur lors du rafraîchissement");
            errorHandler.handleException(e, "lors du rafraîchissement du tableau de bord", null);
        }
    }
    
    private void initValeursParDefaut() {
        stats = DashboardStatsResponse.builder().build();
        activitesRecentes = new ArrayList<>();
        evenementsAvenir = new ArrayList<>();
    }
    
    // Getters et Setters
    public DashboardDataResponse getDashboardData() { return dashboardData; }
    public void setDashboardData(DashboardDataResponse dashboardData) { this.dashboardData = dashboardData; }
    
    public DashboardStatsResponse getStats() { return stats; }
    public void setStats(DashboardStatsResponse stats) { this.stats = stats; }
    
    public List<RecentActivityResponse> getActivitesRecentes() { return activitesRecentes; }
    public void setActivitesRecentes(List<RecentActivityResponse> activitesRecentes) { this.activitesRecentes = activitesRecentes; }
    
    public List<UpcomingEventResponse> getEvenementsAvenir() { return evenementsAvenir; }
    public void setEvenementsAvenir(List<UpcomingEventResponse> evenementsAvenir) { this.evenementsAvenir = evenementsAvenir; }
    
    public int getLimiteActivites() { return limiteActivites; }
    public void setLimiteActivites(int limiteActivites) { 
        this.limiteActivites = limiteActivites;
        chargerDonnees();
    }
    
    public int getLimiteEvenements() { return limiteEvenements; }
    public void setLimiteEvenements(int limiteEvenements) { 
        this.limiteEvenements = limiteEvenements;
        chargerDonnees();
    }
    
}

