package de.oaa.xxx.aufgaben;

import java.util.UUID;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import de.oaa.xxx.framework.request.RequestChecker;
import jakarta.annotation.Resource;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.transaction.SystemException;
import jakarta.transaction.UserTransaction;
import jakarta.ws.rs.Consumes;
import jakarta.ws.rs.DELETE;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.POST;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.PathParam;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.QueryParam;
import jakarta.ws.rs.core.Context;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
import jakarta.ws.rs.core.Response.Status;
import jakarta.ws.rs.core.UriInfo;

@Path("gruppe")
@ApplicationScoped
public class AufgabenGruppeResource {
	
	private Logger LOGGER = LoggerFactory.getLogger(getClass());
	
	@PersistenceContext(name = "aufgaben")
	private EntityManager entityManager;
	@Resource
	private UserTransaction transaction;
		
	@Path("all")
	@GET
	@Produces(MediaType.APPLICATION_JSON)
	public Response getAll(@QueryParam("search") String search, @Context HttpServletRequest req) throws IllegalStateException, SecurityException, SystemException {
		try {
			UUID userId = RequestChecker.checkRequest(req).getUserId();
			transaction.begin();
			AufgabenGruppeList list = new AufgabenGruppeList();
			list.setGruppen(new AufgabenGruppeDAO(entityManager).list(userId, search).stream().map(entity -> entity.toAufgabenGruppeDisplay()).toList());
			transaction.commit();
			return Response.ok(list).build();
		} catch (Exception exception) {
			LOGGER.error(exception.getMessage(), exception);
			transaction.rollback();
			return Response.serverError().build();
		}
	}

	@Path("own")
	@GET
	@Produces(MediaType.APPLICATION_JSON)
	public Response getOwn(@QueryParam("userId") UUID userId, @Context HttpServletRequest req) throws IllegalStateException, SecurityException, SystemException {
		try {
			RequestChecker.checkRequest(req);
			if (userId != null) {
				transaction.begin();
				AufgabenGruppeList list = new AufgabenGruppeList();
				list.setGruppen(new AufgabenGruppeDAO(entityManager).listOwn(userId).stream()
						.map(entity -> entity.toAufgabenGruppeDisplay()).toList());
				transaction.commit();
				return Response.ok(list).build();
			} else {
				return Response.status(Status.BAD_REQUEST).build();
			}
		} catch (Exception exception) {
			LOGGER.error(exception.getMessage(), exception);
			transaction.rollback();
			return Response.serverError().build();
		}
	}
	
	@Path("{gruppeId}")
	@GET
	@Produces(MediaType.APPLICATION_JSON)
	public Response get(@PathParam("gruppeId") UUID gruppeId, @Context HttpServletRequest req) throws IllegalStateException, SecurityException, SystemException {
		try {
			RequestChecker.checkRequest(req);
			transaction.begin();
			AufgabenGruppeEntity entity = new AufgabenGruppeDAO(entityManager).findById(gruppeId);
			if (entity != null) {
				AufgabenGruppe aufgabenGruppe = entity.toAufgabenGruppe();
				transaction.commit();
				return Response.ok(aufgabenGruppe).build();
			} else {
				transaction.commit();
				return Response.noContent().build();
			}
		} catch (Exception exception) {
			LOGGER.error(exception.getMessage(), exception);
			transaction.rollback();
			return Response.serverError().build();
		}
	}
	
	@POST
	@Consumes(MediaType.APPLICATION_JSON)
	public Response post(AufgabenGruppe gruppe, @Context UriInfo uriInfo, @Context HttpServletRequest req) throws IllegalStateException, SecurityException, SystemException {
		try {
			RequestChecker.checkRequest(req);
			transaction.begin();
			AufgabenGruppeEntity entity = AufgabenGruppeEntity.create(gruppe);
			new AufgabenGruppeDAO(entityManager).persist(entity);
			transaction.commit();
			return Response.created(uriInfo.getAbsolutePathBuilder().path(entity.getGruppenId().toString()).build())
					.build();
		} catch (Exception exception) {
			LOGGER.error(exception.getMessage(), exception);
			transaction.rollback();
			return Response.serverError().build();
		}
	}
	
	@DELETE
	@Consumes(MediaType.APPLICATION_JSON)
	public Response delete(AufgabenGruppe gruppe, @Context HttpServletRequest req) throws IllegalStateException, SecurityException, SystemException {
		try {
			RequestChecker.checkRequest(req);
			transaction.begin();
			AufgabenGruppeDAO dao = new AufgabenGruppeDAO(entityManager);
			AufgabenGruppeEntity entity = dao.findById(gruppe.getGruppenId());
			dao.remove(entity);
			transaction.commit();
			return Response.accepted().build();
		} catch (Exception exception) {
			LOGGER.error(exception.getMessage(), exception);
			transaction.rollback();
			return Response.serverError().build();
		}
	}
	
	@GET
	public Response orderRelevanz() {
		return Response.notModified().build();
	}
}
