package com.lions.dev.service;

import com.lions.dev.dto.request.users.UserCreateRequestDTO;
import com.lions.dev.entity.users.Users;
import com.lions.dev.exception.UserNotFoundException;
import com.lions.dev.repository.UsersRepository;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.transaction.Transactional;

import java.util.List;
import java.util.Optional;
import java.util.UUID;

/**
 * Service de gestion des utilisateurs.
 * Ce service contient la logique métier pour la création, récupération et suppression des utilisateurs.
 */
@ApplicationScoped
public class UsersService {

  @Inject
  UsersRepository usersRepository;

  /**
   * Crée un nouvel utilisateur dans le système.
   *
   * @param userCreateRequestDTO Le DTO contenant les informations de l'utilisateur à créer.
   * @return L'utilisateur créé.
   */
  public Users createUser(UserCreateRequestDTO userCreateRequestDTO) {
    Users user = new Users();
    user.setNom(userCreateRequestDTO.getNom());
    user.setPrenoms(userCreateRequestDTO.getPrenoms());
    user.setEmail(userCreateRequestDTO.getEmail());
    user.setMotDePasse(userCreateRequestDTO.getMotDePasse()); // Hachage automatique

    // Vérifier si le profile image est défini, sinon attribuer une image par défaut
    if (userCreateRequestDTO.getProfileImageUrl() == null
        || userCreateRequestDTO.getProfileImageUrl().isEmpty()) {
      user.setProfileImageUrl("https://via.placeholder.com/150"); // Assigner une image par défaut
    } else {
      user.setProfileImageUrl(userCreateRequestDTO.getProfileImageUrl());
    }

    // Vérifier si le rôle est défini, sinon attribuer un rôle par défaut
    if (userCreateRequestDTO.getRole() == null || userCreateRequestDTO.getRole().isEmpty()) {
      user.setRole("USER"); // Assigner un rôle par défaut
    } else {
      user.setRole(userCreateRequestDTO.getRole());
    }

    usersRepository.persist(user);
    System.out.println("[LOG] Utilisateur créé : " + user.getEmail());
    return user;
  }

  /**
   * Met à jour un utilisateur existant dans le système.
   *
   * @param id L'ID de l'utilisateur à mettre à jour.
   * @param userCreateRequestDTO Les nouvelles informations de l'utilisateur.
   * @return L'utilisateur mis à jour.
   * @throws UserNotFoundException Si l'utilisateur n'est pas trouvé.
   */
  @Transactional
  public Users updateUser(UUID id, UserCreateRequestDTO userCreateRequestDTO) {
    Users existingUser = usersRepository.findById(id);
    if (existingUser == null) {
      System.out.println("[ERROR] Utilisateur non trouvé avec l'ID : " + id);
      throw new UserNotFoundException("Utilisateur non trouvé avec l'ID : " + id);
    }

    // Mettre à jour les champs de l'utilisateur existant
    existingUser.setNom(userCreateRequestDTO.getNom());
    existingUser.setPrenoms(userCreateRequestDTO.getPrenoms());
    existingUser.setEmail(userCreateRequestDTO.getEmail());
    existingUser.setMotDePasse(userCreateRequestDTO.getMotDePasse()); // Hachage automatique si nécessaire
    existingUser.setRole(userCreateRequestDTO.getRole());
    existingUser.setProfileImageUrl(userCreateRequestDTO.getProfileImageUrl());

    usersRepository.persist(existingUser);
    System.out.println("[LOG] Utilisateur mis à jour avec succès : " + existingUser.getEmail());
    return existingUser;
  }
  /**
   * Met à jour l'image de profil d'un utilisateur existant dans le système.
   *
   * @param id L'ID de l'utilisateur à mettre à jour.
   * @param profileImageUrl Les nouvelles informations de l'utilisateur.
   * @return L'utilisateur mis à jour.
   * @throws UserNotFoundException Si l'utilisateur n'est pas trouvé.
   */
  @Transactional
  public Users updateUserProfileImage(UUID id, String profileImageUrl) {
    Users existingUser = usersRepository.findById(id);
    if (existingUser == null) {
      System.out.println("[ERROR] Utilisateur non trouvé avec l'ID : " + id);
      throw new UserNotFoundException("Utilisateur non trouvé avec l'ID : " + id);
    }

    // Mettre à jour les champs de l'utilisateur existant
    existingUser.setProfileImageUrl(profileImageUrl);

    usersRepository.persist(existingUser);
    System.out.println("[LOG] L'image de profile de l\'Utilisateur mis à jour avec succès : " + existingUser.getEmail());
    return existingUser;
  }

  /**
   * Liste tous les utilisateurs avec pagination.
   *
   * @param page Le numéro de la page à récupérer.
   * @param size Le nombre d'utilisateurs par page.
   * @return La liste des utilisateurs paginée.
   */
  public List<Users> listUsers(int page, int size) {
    return usersRepository.findAll().page(page - 1, size).list();
  }

  /**
   * Authentifie un utilisateur avec son email et son mot de passe.
   *
   * @param email L'email de l'utilisateur.
   * @param motDePasse Le mot de passe de l'utilisateur.
   * @return L'utilisateur authentifié.
   * @throws UserNotFoundException Si l'utilisateur n'est pas trouvé ou si le mot de passe est incorrect.
   */
  public Users authenticateUser(String email, String motDePasse) {
    Optional<Users> userOptional = usersRepository.findByEmail(email);
    if (userOptional.isEmpty() || !userOptional.get().verifierMotDePasse(motDePasse)) {
      System.out.println("[ERROR] Échec de l'authentification pour l'email : " + email);
      throw new UserNotFoundException("Utilisateur ou mot de passe incorrect.");
    }
    System.out.println("[LOG] Utilisateur authentifié : " + email);
    return userOptional.get();
  }

  /**
   * Récupère un utilisateur par son ID.
   *
   * @param id L'ID de l'utilisateur.
   * @return L'utilisateur trouvé.
   * @throws UserNotFoundException Si l'utilisateur n'est pas trouvé.
   */
  public Users getUserById(UUID id) {
    Users user = usersRepository.findById(id);
    if (user == null) {
      System.out.println("[ERROR] Utilisateur non trouvé avec l'ID : " + id);
      throw new UserNotFoundException("Utilisateur non trouvé avec l'ID : " + id);
    }
    System.out.println("[LOG] Utilisateur trouvé avec l'ID : " + id);
    return user;
  }

  /**
   * Réinitialise le mot de passe d'un utilisateur.
   *
   * @param id L'ID de l'utilisateur.
   * @param newPassword Le nouveau mot de passe à définir.
   * @throws UserNotFoundException Si l'utilisateur n'est pas trouvé.
   */
  @Transactional
  public void resetPassword(UUID id, String newPassword) {
    Users user = usersRepository.findById(id);
    if (user == null) {
      System.out.println("[ERROR] Utilisateur non trouvé avec l'ID : " + id);
      throw new UserNotFoundException("Utilisateur non trouvé.");
    }

    user.setMotDePasse(newPassword); // Hachage automatique
    usersRepository.persist(user);
    System.out.println("[LOG] Mot de passe réinitialisé pour l'utilisateur : " + user.getEmail());
  }

  /**
   * Supprime un utilisateur par son ID.
   *
   * @param id L'ID de l'utilisateur à supprimer.
   * @return true si l'utilisateur a été supprimé, false sinon.
   */
  public boolean deleteUser(UUID id) {
    boolean deleted = usersRepository.deleteById(id);
    if (deleted) {
      System.out.println("[LOG] Utilisateur supprimé avec succès : " + id);
    } else {
      System.out.println("[ERROR] Échec de la suppression de l'utilisateur avec l'ID : " + id);
    }
    return deleted;
  }
}