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

import dev.lions.user.manager.client.service.RealmServiceClient;
import dev.lions.user.manager.client.service.UserServiceClient;
import dev.lions.user.manager.dto.user.UserDTO;
import dev.lions.user.manager.enums.user.StatutUser;
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.config.inject.ConfigProperty;
import org.eclipse.microprofile.rest.client.inject.RestClient;

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

/**
 * Bean JSF pour la création d'un nouvel utilisateur
 * 
 * @author Lions User Manager
 * @version 1.0.0
 */
@Named("userCreationBean")
@ViewScoped
@Data
public class UserCreationBean implements Serializable {

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

    @Inject
    @RestClient
    private UserServiceClient userServiceClient;

    @Inject
    @RestClient
    private RealmServiceClient realmServiceClient;

    @ConfigProperty(name = "lions.user.manager.default.realm", defaultValue = "lions-user-manager")
    String defaultRealm;

    private UserDTO newUser = UserDTO.builder().build();
    private String realmName;
    private String password;
    private String passwordConfirm;
    private boolean creationSuccess;

    // Options pour les selects
    private List<StatutUser> statutOptions = List.of(StatutUser.values());
    private List<String> availableRealms = new ArrayList<>();

    @PostConstruct
    public void init() {
        this.realmName = defaultRealm;
        loadRealms();
        // Initialiser les valeurs par défaut
        newUser.setEnabled(true);
        newUser.setEmailVerified(false);
        newUser.setStatut(StatutUser.ACTIF);
    }

    /**
     * Créer un nouvel utilisateur
     */
    public void createUser() {
        if (password == null || password.isEmpty()) {
            addErrorMessage("Le mot de passe est obligatoire");
            return;
        }

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

        if (password.length() < 8) {
            addErrorMessage("Le mot de passe doit contenir au moins 8 caractères");
            return;
        }

        try {
            jakarta.ws.rs.core.Response response = userServiceClient.createUser(newUser, realmName);
            UserDTO createdUser = response.readEntity(UserDTO.class);

            dev.lions.user.manager.dto.user.PasswordResetRequestDTO request = new dev.lions.user.manager.dto.user.PasswordResetRequestDTO(
                    password, false);
            userServiceClient.resetPassword(createdUser.getId(), realmName, request);

            addSuccessMessage("Utilisateur '" + createdUser.getUsername() + "' créé avec succès !");
            creationSuccess = true;
            resetForm();
        } catch (Exception e) {
            LOGGER.severe("Erreur lors de la création: " + e.getMessage());
            addErrorMessage("Erreur lors de la création : " + e.getMessage());
        }
    }

    /**
     * Réinitialiser le formulaire
     */
    public void resetForm() {
        newUser = UserDTO.builder().build();
        password = null;
        passwordConfirm = null;
        creationSuccess = false;
        newUser.setEnabled(true);
        newUser.setEmailVerified(false);
        newUser.setStatut(StatutUser.ACTIF);
    }

    /**
     * Annuler la création — redirige vers la liste
     */
    public void cancel() {
        try {
            FacesContext.getCurrentInstance().getExternalContext()
                    .redirect(FacesContext.getCurrentInstance().getExternalContext()
                            .getRequestContextPath() + "/pages/user-manager/users/list.xhtml");
        } catch (Exception e) {
            LOGGER.severe("Erreur lors de la redirection: " + e.getMessage());
        }
    }

    /**
     * Charger les realms disponibles
     */
    private void loadRealms() {
        try {
            LOGGER.info("Chargement des realms disponibles pour la création d'utilisateur");
            List<String> realms = realmServiceClient.getAllRealms();

            if (realms == null || realms.isEmpty()) {
                LOGGER.warning("Aucun realm disponible lors du chargement des realms");
                availableRealms = new ArrayList<>();
            } else {
                availableRealms = new ArrayList<>(realms);
            }
        } catch (Exception e) {
            LOGGER.severe("Erreur lors du chargement des realms: " + e.getMessage());
            addErrorMessage("Erreur lors du chargement des realms: " + e.getMessage());
            // Fallback: liste vide plutôt que valeurs codées en dur
            availableRealms = new ArrayList<>();
        }
    }

    // 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));
    }
}
