package dev.lions.user.manager.client.view;

import dev.lions.user.manager.client.service.UserServiceClient;
import dev.lions.user.manager.dto.user.UserDTO;
import jakarta.annotation.PostConstruct;
import jakarta.faces.application.FacesMessage;
import jakarta.faces.context.FacesContext;
import jakarta.faces.view.ViewScoped;
import jakarta.inject.Inject;
import jakarta.inject.Named;
import lombok.Data;
import org.eclipse.microprofile.rest.client.inject.RestClient;

import java.io.Serializable;
import java.util.logging.Logger;

/**
 * Bean JSF pour le profil et l'édition d'un utilisateur
 * 
 * @author Lions User Manager
 * @version 1.0.0
 */
@Named("userProfilBean")
@ViewScoped
@Data
public class UserProfilBean implements Serializable {

    private static final long serialVersionUID = 1L;
    private static final Logger LOGGER = Logger.getLogger(UserProfilBean.class.getName());

    @Inject
    @RestClient
    private UserServiceClient userServiceClient;

    @Inject
    private RoleGestionBean roleGestionBean;

    private UserDTO user;
    private String userId;
    // Par défaut, utiliser le realm lions-user-manager où les utilisateurs sont configurés
    private String realmName = "lions-user-manager";
    private boolean editMode = false;

    // Pour la réinitialisation de mot de passe
    private String newPassword;
    private String newPasswordConfirm;

    @PostConstruct
    public void init() {
        // Récupérer l'ID et le realm depuis les paramètres de requête
        FacesContext facesContext = FacesContext.getCurrentInstance();
        java.util.Map<String, String> params = facesContext.getExternalContext().getRequestParameterMap();
        
        userId = params.get("userId");
        String realmParam = params.get("realm");
        
        if (realmParam != null && !realmParam.isEmpty()) {
            realmName = realmParam;
        }

        LOGGER.info("Initialisation de UserProfilBean avec userId: " + userId + ", realm: " + realmName);

        if (userId != null && !userId.isEmpty()) {
            loadUser();
            // Charger les rôles disponibles
            if (roleGestionBean != null) {
                roleGestionBean.setRealmName(realmName);
                roleGestionBean.loadRealmRoles();
            }
        } else {
            LOGGER.warning("Aucun userId fourni dans les paramètres de requête");
            addErrorMessage("Aucun ID d'utilisateur fourni. Accédez à cette page depuis la liste des utilisateurs.");
        }
    }

    /**
     * Charger l'utilisateur
     */
    public void loadUser() {
        try {
            user = userServiceClient.getUserById(userId, realmName);
            if (user != null) {
                LOGGER.info("Utilisateur chargé: " + user.getUsername());
            }
        } catch (dev.lions.user.manager.client.service.RestClientExceptionMapper.NotFoundException e) {
            LOGGER.warning("Utilisateur non trouvé: " + userId);
            addErrorMessage("Utilisateur non trouvé dans le realm " + realmName);
            user = null;
        } catch (Exception e) {
            LOGGER.severe("Erreur lors du chargement de l'utilisateur: " + e.getMessage());
            addErrorMessage("Erreur lors du chargement de l'utilisateur: " + e.getMessage());
        }
    }

    /**
     * Activer le mode édition
     */
    public void enableEditMode() {
        editMode = true;
    }

    /**
     * Désactiver le mode édition
     */
    public void cancelEdit() {
        editMode = false;
        loadUser(); // Recharger les données originales
    }

    /**
     * Mettre à jour l'utilisateur
     */
    public void updateUser() {
        try {
            LOGGER.info("Mise à jour de l'utilisateur: " + userId + " dans le realm: " + realmName);
            user = userServiceClient.updateUser(userId, user, realmName);
            editMode = false;
            addSuccessMessage("Utilisateur mis à jour avec succès");
            // Recharger les données pour s'assurer qu'elles sont à jour
            loadUser();
        } catch (Exception e) {
            LOGGER.severe("Erreur lors de la mise à jour: " + e.getMessage());
            LOGGER.log(java.util.logging.Level.SEVERE, "Exception complète", e);
            addErrorMessage("Erreur lors de la mise à jour: " + e.getMessage());
        }
    }

    /**
     * Réinitialiser le mot de passe
     */
    public void resetPassword() {
        if (newPassword == null || newPassword.isEmpty()) {
            addErrorMessage("Le mot de passe ne peut pas être vide");
            return;
        }

        if (!newPassword.equals(newPasswordConfirm)) {
            addErrorMessage("Les mots de passe ne correspondent pas");
            return;
        }

        try {
            UserServiceClient.PasswordResetRequest request = new UserServiceClient.PasswordResetRequest();
            request.password = newPassword;
            request.temporary = true;
            userServiceClient.resetPassword(userId, realmName, request);
            newPassword = null;
            newPasswordConfirm = null;
            addSuccessMessage("Mot de passe réinitialisé avec succès");
        } catch (Exception e) {
            LOGGER.severe("Erreur lors de la réinitialisation: " + e.getMessage());
            addErrorMessage("Erreur lors de la réinitialisation: " + e.getMessage());
        }
    }

    /**
     * Activer l'utilisateur
     */
    public void activateUser() {
        try {
            userServiceClient.activateUser(userId, realmName);
            loadUser(); // Recharger pour mettre à jour le statut
            addSuccessMessage("Utilisateur activé avec succès");
        } catch (Exception e) {
            LOGGER.severe("Erreur lors de l'activation: " + e.getMessage());
            addErrorMessage("Erreur lors de l'activation: " + e.getMessage());
        }
    }

    /**
     * Désactiver l'utilisateur
     */
    public void deactivateUser() {
        try {
            userServiceClient.deactivateUser(userId, realmName);
            loadUser(); // Recharger pour mettre à jour le statut
            addSuccessMessage("Utilisateur désactivé avec succès");
        } catch (Exception e) {
            LOGGER.severe("Erreur lors de la désactivation: " + e.getMessage());
            addErrorMessage("Erreur lors de la désactivation: " + e.getMessage());
        }
    }

    /**
     * Envoyer un email de vérification
     */
    public void sendVerificationEmail() {
        try {
            userServiceClient.sendVerificationEmail(userId, realmName);
            addSuccessMessage("Email de vérification envoyé");
        } catch (Exception e) {
            LOGGER.severe("Erreur lors de l'envoi: " + e.getMessage());
            addErrorMessage("Erreur lors de l'envoi: " + e.getMessage());
        }
    }

    /**
     * Déconnecter toutes les sessions
     */
    public void logoutAllSessions() {
        try {
            userServiceClient.logoutAllSessions(userId, realmName);
            addSuccessMessage("Toutes les sessions ont été déconnectées");
        } catch (Exception e) {
            LOGGER.severe("Erreur lors de la déconnexion: " + e.getMessage());
            addErrorMessage("Erreur lors de la déconnexion: " + e.getMessage());
        }
    }

    // Méthodes utilitaires
    private void addSuccessMessage(String message) {
        FacesContext.getCurrentInstance().addMessage(null,
            new FacesMessage(FacesMessage.SEVERITY_INFO, "Succès", message));
    }

    private void addErrorMessage(String message) {
        FacesContext.getCurrentInstance().addMessage(null,
            new FacesMessage(FacesMessage.SEVERITY_ERROR, "Erreur", message));
    }
}

