package dev.lions.unionflow.client.security;

import dev.lions.unionflow.client.view.UserSession;
import jakarta.inject.Inject;
import jakarta.servlet.*;
import jakarta.servlet.annotation.WebFilter;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.logging.Logger;

/**
 * Filtre d'authentification pour vérifications supplémentaires
 * Note: Avec Keycloak OIDC, l'authentification principale est gérée par Quarkus
 * Ce filtre peut être utilisé pour des vérifications de permissions supplémentaires
 * 
 * @author UnionFlow Team
 * @version 2.0
 */
@WebFilter(urlPatterns = {"/pages/secure/*", "/pages/admin/*", "/pages/super-admin/*", "/pages/membre/*"})
public class AuthenticationFilter implements Filter {
    
    private static final Logger LOGGER = Logger.getLogger(AuthenticationFilter.class.getName());
    
    @Inject
    private UserSession userSession;
    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
            throws IOException, ServletException {
        
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;
        
        String requestURI = httpRequest.getRequestURI();
        
        // Laisser Quarkus OIDC appliquer l'authentification (rediriger vers Keycloak si nécessaire)
        // Ici, si l'utilisateur n'est pas encore authentifié, on ne force PAS une redirection custom
        // pour éviter les boucles / conflits. On délègue au mécanisme Quarkus défini via
        // quarkus.http.auth.permission.* et quarkus.oidc.*
        if (!isAuthenticated()) {
            LOGGER.fine("Requête non authentifiée sur " + requestURI + ", délégation à Quarkus OIDC.");
            chain.doFilter(request, response);
            return;
        }
        
        // Vérifier les autorisations spécifiques basées sur les rôles
        // Note: /pages/secure/access-denied.xhtml est autorisé car elle fait partie de /pages/secure/
        // qui est accessible à tous les utilisateurs authentifiés
        if (!hasRequiredPermissions(requestURI)) {
            LOGGER.warning("Permissions insuffisantes pour: " + requestURI + 
                          " (Utilisateur: " + (userSession != null ? userSession.getUsername() : "null") + 
                          ", Type: " + (userSession != null ? userSession.getTypeCompte() : "null") +
                          ", Rôles: " + (userSession != null && userSession.getRoles() != null ? userSession.getRoles() : "null") + ")");
            httpResponse.sendRedirect(httpRequest.getContextPath() + "/pages/secure/access-denied.xhtml");
            return;
        }
        
        // Continuer la chaîne de filtres
        chain.doFilter(request, response);
    }
    
    private boolean isAuthenticated() {
        // Avec Keycloak OIDC, UserSession vérifie automatiquement l'authentification via JsonWebToken
        return userSession != null && userSession.isAuthenticated();
    }
    
    private boolean hasRequiredPermissions(String requestURI) {
        // Vérifier que userSession est disponible
        if (userSession == null) {
            LOGGER.warning("UserSession est null lors de la vérification des permissions pour: " + requestURI);
            return false;
        }
        
        // Pages super-admin : nécessitent le rôle SUPER_ADMIN
        if (requestURI.contains("/pages/super-admin/")) {
            boolean isSuperAdmin = userSession.isSuperAdmin();
            LOGGER.fine("Vérification SUPER_ADMIN pour " + requestURI + ": " + isSuperAdmin + 
                       " (Type: " + userSession.getTypeCompte() + ", Rôles: " + userSession.getRoles() + ")");
            return isSuperAdmin;
        }
        
        // Pages admin : nécessitent ADMIN_ENTITE ou SUPER_ADMIN
        if (requestURI.contains("/pages/admin/")) {
            boolean isAdmin = userSession.isAdmin();
            LOGGER.fine("Vérification ADMIN pour " + requestURI + ": " + isAdmin + 
                       " (Type: " + userSession.getTypeCompte() + ", Rôles: " + userSession.getRoles() + ")");
            return isAdmin;
        }
        
        // Pages membre : nécessitent le rôle MEMBRE ou tout utilisateur authentifié
        if (requestURI.contains("/pages/membre/")) {
            boolean isMembre = userSession.isMembre();
            LOGGER.fine("Vérification MEMBRE pour " + requestURI + ": " + isMembre + 
                       " (Type: " + userSession.getTypeCompte() + ", Rôles: " + userSession.getRoles() + ")");
            return isMembre;
        }
        
        // Pages sécurisées générales - tout utilisateur authentifié peut y accéder
        if (requestURI.contains("/pages/secure/")) {
            LOGGER.fine("Accès autorisé à la page sécurisée générale: " + requestURI);
            return true;
        }
        
        LOGGER.warning("URI non reconnue dans hasRequiredPermissions: " + requestURI);
        return false;
    }
    
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        LOGGER.info("Filtre d'authentification initialisé");
    }
    
    @Override
    public void destroy() {
        LOGGER.info("Filtre d'authentification détruit");
    }
}