tpjpa/src/main/java/fr/istic/taa/jaxrs/rest/UtilisateurResource.java

package fr.istic.taa.jaxrs.rest;

import fr.istic.taa.jaxrs.DAO.SessionDAO;
import fr.istic.taa.jaxrs.DAO.UtilisateurDAO;
import fr.istic.taa.jaxrs.DTO.SessionDTO;
import fr.istic.taa.jaxrs.DTO.UtilisateurDTO;
import fr.istic.taa.jaxrs.Mapper.SessionMapper;
import fr.istic.taa.jaxrs.Mapper.UtilisateurMapper;
import fr.istic.taa.jaxrs.metier.Session;
import fr.istic.taa.jaxrs.metier.Utilisateur;
import jakarta.ws.rs.*;
import jakarta.ws.rs.core.Response;

import java.util.List;

@Path("utilisateur")
@Consumes({"application/json", "application/xml"})
@Produces({"application/json", "application/xml"})
public class UtilisateurResource {
    private final UtilisateurDAO utilisateurDAO = new UtilisateurDAO();
    private final UtilisateurMapper mapper = UtilisateurMapper.INSTANCE;
    @GET
    public List<Utilisateur> listUtilisateur() {
        List<Utilisateur> utilisateurs = utilisateurDAO.findAll();
        return utilisateurs;
    }

    @POST
    @Path("/register")
    public Response registerUtilisateur(UtilisateurDTO dto) {
        String email_verification = dto.getEmail();
        Utilisateur existing = utilisateurDAO.findByEmail(email_verification);

        //VERIFACTION S'IL EXISTE DANS BDD
        if (existing != null) {
            return Response.status(Response.Status.CONFLICT).entity("Email est déjà registré").build();
        }

        Utilisateur utilisateur = mapper.toEntity(dto);
        utilisateurDAO.create(utilisateur);

        return Response.status(Response.Status.CREATED).entity("Registration succès").build();
    }

    @POST
    @Path("/login")
    public Response loginUtilisateur(UtilisateurDTO dto) {
        Utilisateur utilisateur = utilisateurDAO.findByEmail(dto.getEmail());

        if (utilisateur == null) {
            return Response.status(Response.Status.NOT_FOUND).entity("Email n'existe pas").build();
        } else if (!utilisateur.getPassword().equals(dto.getPassword())) {
            return Response.status(Response.Status.UNAUTHORIZED).entity("Mauvais mdp").build();
        }
        UtilisateurDTO result = mapper.toDTO(utilisateur);

        return Response.status(Response.Status.OK).entity(result).build();
    }

    @GET
    @Path("/{id}")
    public Response getUtilisateur(@PathParam("id") Integer id) {
        Utilisateur utilisateur = utilisateurDAO.findById(id);
        if (utilisateur == null) {
            return Response.status(Response.Status.NOT_FOUND).build();
        }
        UtilisateurDTO result = mapper.toDTO(utilisateur);
        return Response.ok(result).build();
    }

    @PUT
    @Path("/{user_id}/add_session/{session_id}")
    public Response addSession(@PathParam("user_id") Integer user_id, @PathParam("session_id") Integer session_id) {
        SessionDAO sessionDAO = new SessionDAO();

        Session existingSession = sessionDAO.findById(session_id);
        Utilisateur utilisateur = utilisateurDAO.findById(user_id);

        if (existingSession == null || utilisateur == null) {
            return Response.status(Response.Status.NOT_FOUND).build();
        }
        //If user already joined
        if (utilisateur.getSession().contains(existingSession)) {
            return Response.status(Response.Status.CONFLICT).build();
        }
        utilisateurDAO.addToSession(user_id, session_id);
        utilisateurDAO.update(utilisateur);

        // We update it so have to return new DTO
        UtilisateurDTO dto = mapper.toDTO(utilisateur);

        return Response.status(Response.Status.OK).entity(dto).build();
    }

    @GET
    @Path("{user_id}/session")
    public Response listSession(@PathParam("user_id") Integer user_id) {
        Utilisateur utilisateur = utilisateurDAO.findById(user_id);
        if (utilisateur == null) {
            return Response.status(Response.Status.NOT_FOUND).build();
        }
        List<Session> sess= utilisateur.getSession();
        List<SessionDTO> dtos= SessionMapper.INSTANCE.toDTOs(sess);
        return Response.status(Response.Status.OK).entity(dtos).build();
    }

    @DELETE
    @Path("{user_id}/delete")
    public Response deleteUtilisateur(@PathParam("user_id") Integer user_id) {
        Utilisateur existing = utilisateurDAO.findById(user_id);
        if (existing == null) {
            return Response.status(Response.Status.NOT_FOUND).build();
        }
        utilisateurDAO.delete(existing);
        return Response.status(Response.Status.OK).build();
    }
}