package com.lions.dev.resource;

import com.lions.dev.dto.request.users.UserAuthenticateRequestDTO;
import com.lions.dev.dto.request.users.UserRequestDTO;
import com.lions.dev.dto.response.users.UserAuthenticateResponseDTO;
import com.lions.dev.dto.response.users.UserResponseDTO;
import com.lions.dev.entity.users.Users;
import com.lions.dev.service.UserService;
import jakarta.inject.Inject;
import jakarta.transaction.Transactional;
import jakarta.ws.rs.*;
import jakarta.ws.rs.core.Response;
import java.util.UUID;
import org.eclipse.microprofile.openapi.annotations.Operation;
import org.eclipse.microprofile.openapi.annotations.tags.Tag;
import org.jboss.logging.Logger;

/**
 * Ressource REST pour la gestion des utilisateurs dans le système AfterWork. Cette classe expose
 * des endpoints pour créer, authentifier, récupérer et supprimer des utilisateurs.
 *
 * <p>Tous les logs nécessaires pour la traçabilité sont intégrés.
 */
@Path("/users")
@Produces("application/json")
@Consumes("application/json")
@Tag(name = "Users", description = "Opérations liées à la gestion des utilisateurs")
public class UsersResource {

  @Inject UserService userService;

  private static final Logger LOG = Logger.getLogger(UsersResource.class);

  /**
   * Endpoint pour créer un nouvel utilisateur.
   *
   * @param userRequestDTO Le DTO contenant les informations de l'utilisateur à créer.
   * @return Une réponse HTTP contenant l'utilisateur créé ou un message d'erreur.
   */
  @POST
  @Transactional
  @Operation(
      summary = "Créer un nouvel utilisateur",
      description = "Crée un nouvel utilisateur et retourne les détails")
  public Response createUser(UserRequestDTO userRequestDTO) {
    LOG.info(
        "Tentative de création d'un nouvel utilisateur avec l'email : "
            + userRequestDTO.getEmail());

    // Utilisation de UserService pour créer l'utilisateur
    Users user = userService.createUser(userRequestDTO);

    UserResponseDTO responseDTO = new UserResponseDTO(user);
    return Response.status(Response.Status.CREATED).entity(responseDTO).build();
  }

  /**
   * Endpoint pour authentifier un utilisateur.
   *
   * @param userAuthenticateRequestDTO Le DTO contenant les informations d'authentification.
   * @return Une réponse HTTP indiquant si l'authentification a réussi ou échoué.
   */
  @POST
  @Path("/authenticate")
  @Operation(
      summary = "Authentifier un utilisateur",
      description = "Vérifie les informations de connexion de l'utilisateur")
  public Response authenticateUser(UserAuthenticateRequestDTO userAuthenticateRequestDTO) {
    LOG.info(
        "Tentative d'authentification pour l'utilisateur avec l'email : "
            + userAuthenticateRequestDTO.getEmail());

    // Utilisation de UserService pour authentifier l'utilisateur
    Users user =
        userService.authenticateUser(
            userAuthenticateRequestDTO.getEmail(), userAuthenticateRequestDTO.getMotDePasse());

    LOG.info("Authentification réussie pour l'utilisateur : " + user.getEmail());

    // Création du DTO de réponse avec les informations supplémentaires de l'utilisateur
    UserAuthenticateResponseDTO responseDTO =
        new UserAuthenticateResponseDTO(
            user.getId(), user.getPrenoms(), user.getNom(), user.getEmail(), user.getRole());

    responseDTO.logResponseDetails();

    return Response.ok(responseDTO).build();
  }

  /**
   * Endpoint pour récupérer les détails d'un utilisateur par ID.
   *
   * @param id L'ID de l'utilisateur.
   * @return Une réponse HTTP contenant les informations de l'utilisateur.
   */
  @GET
  @Path("/{id}")
  @Operation(
      summary = "Récupérer un utilisateur par ID",
      description = "Retourne les détails de l'utilisateur demandé")
  public Response getUserById(@PathParam("id") UUID id) {
    LOG.info("Récupération de l'utilisateur avec l'ID : " + id);

    // Utilisation de UserService pour récupérer l'utilisateur
    Users user = userService.getUserById(id);

    UserResponseDTO responseDTO = new UserResponseDTO(user);
    LOG.info("Utilisateur trouvé : " + user.getEmail());
    return Response.ok(responseDTO).build();
  }

  /**
   * Endpoint pour supprimer un utilisateur par ID.
   *
   * @param id L'ID de l'utilisateur à supprimer.
   * @return Une réponse HTTP indiquant le succès ou l'échec de la suppression.
   */
  @DELETE
  @Path("/{id}")
  @Transactional
  @Operation(
      summary = "Supprimer un utilisateur",
      description = "Supprime un utilisateur de la base de données")
  public Response deleteUser(@PathParam("id") UUID id) {
    LOG.info("Tentative de suppression de l'utilisateur avec l'ID : " + id);

    // Utilisation de UserService pour supprimer l'utilisateur
    boolean deleted = userService.deleteUser(id);

    if (deleted) {
      LOG.info("Utilisateur supprimé avec succès.");
      return Response.noContent().build();
    } else {
      LOG.warn("Échec de la suppression : utilisateur introuvable avec l'ID : " + id);
      return Response.status(Response.Status.NOT_FOUND).entity("Utilisateur non trouvé.").build();
    }
  }
}