package com.lions.dev.resource;

import com.lions.dev.entity.users.Users;
import com.lions.dev.repository.UsersRepository;
import com.lions.dev.dto.request.users.UserRequestDTO;
import com.lions.dev.dto.response.users.UserResponseDTO;
import com.lions.dev.exception.UserNotFoundException;
import jakarta.inject.Inject;
import jakarta.transaction.Transactional;
import jakarta.ws.rs.*;
import jakarta.ws.rs.core.Response;
import java.time.LocalDateTime;
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.
 *
 * 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
    UsersRepository usersRepository;

    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());

        if (usersRepository.existsByEmail(userRequestDTO.getEmail())) {
            LOG.warn("Un utilisateur avec cet email existe déjà : " + userRequestDTO.getEmail());
            return Response.status(Response.Status.CONFLICT)
                .entity("Un utilisateur avec cet email existe déjà.").build();
        }

        Users user = new Users();
        user.setNom(userRequestDTO.getNom());
        user.setPrenoms(userRequestDTO.getPrenoms());
        user.setEmail(userRequestDTO.getEmail());
        user.setMotDePasse(userRequestDTO.getMotDePasse()); // Hachage automatique dans l'entité
        // Assigner un rôle par défaut si non fourni (par exemple : USER)
        if (user.getRole() == null) {
            user.setRole("USER");  // Définir le rôle par défaut
        }

        usersRepository.persist(user);
        LOG.info("Utilisateur créé avec succès : " + user.getEmail() + " à " + LocalDateTime.now());

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

    /**
     * Endpoint pour authentifier un utilisateur.
     *
     * @param userRequestDTO 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(UserRequestDTO userRequestDTO) {
        LOG.info("Tentative d'authentification pour l'utilisateur avec l'email : " + userRequestDTO.getEmail());

        Users user = usersRepository.findByEmail(userRequestDTO.getEmail())
            .orElseThrow(() -> new UserNotFoundException("Utilisateur non trouvé avec l'email : " + userRequestDTO.getEmail()));

        if (!user.verifierMotDePasse(userRequestDTO.getMotDePasse())) {
            LOG.warn("Échec de l'authentification : mot de passe incorrect pour l'email : " + userRequestDTO.getEmail());
            return Response.status(Response.Status.UNAUTHORIZED).entity("Mot de passe incorrect.").build();
        }

        LOG.info("Authentification réussie pour l'utilisateur : " + user.getEmail());
        UserResponseDTO responseDTO = new UserResponseDTO(user);
        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);

        Users user = usersRepository.findById(id);
        if (user == null) {
            LOG.warn("Utilisateur non trouvé avec l'ID : " + id);
            return Response.status(Response.Status.NOT_FOUND)
                .entity("Utilisateur non trouvé.").build();
        }

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

        boolean deleted = usersRepository.deleteById(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();
        }
    }
}