package de.oaa.xxx.session.sperre;

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

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

import de.oaa.xxx.session.entity.AktiveSperreDAO;
import de.oaa.xxx.session.entity.AktiveSperreEntity;
import de.oaa.xxx.session.entity.MitspielerDAO;
import de.oaa.xxx.session.entity.SessionDAO;
import jakarta.annotation.Resource;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import jakarta.transaction.SystemException;
import jakarta.transaction.UserTransaction;
import jakarta.ws.rs.Consumes;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.POST;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.QueryParam;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
import jakarta.ws.rs.core.Response.Status;

@ApplicationScoped
@Path("sperre")
public class SperreResource {

	private Logger LOGGER = LoggerFactory.getLogger(getClass());
	
	@PersistenceContext(name = "aufgaben")
	private EntityManager entityManager;
	@Resource
	private UserTransaction transaction;
	
	@POST
	@Consumes(MediaType.APPLICATION_JSON)
	public Response sperren(SperreCallback callback) throws IllegalStateException, SecurityException, SystemException {
		try {
			transaction.begin();
			new SperreVerarbeiten().sperreAnwenden(callback, new SessionDAO(entityManager), new MitspielerDAO(entityManager), new AktiveSperreDAO(entityManager));
			transaction.commit();
			return Response.status(jakarta.ws.rs.core.Response.Status.CREATED).build();
		} catch (Exception exception) {
			LOGGER.error(exception.getMessage(), exception);
			transaction.rollback();
			return Response.serverError().build();
		}
	}
	
	@GET
	@Path("abgelaufene")
	@Produces(MediaType.TEXT_PLAIN)
	public Response getAbgelaufeneSperren(@QueryParam("sessionId") UUID sessionId) throws IllegalStateException, SecurityException, SystemException {
		try {
			if (sessionId == null) {
				return Response.status(Status.BAD_REQUEST).build();
			}
			transaction.begin();
			List<AktiveSperreEntity> abgelaufene = new AktiveSperreDAO(entityManager).findAbgelaufene(sessionId);
			StringBuilder builder = new StringBuilder();
			SperreVerarbeiten verarbeitun = new SperreVerarbeiten();
			if (abgelaufene != null && !abgelaufene.isEmpty()) {
				for (AktiveSperreEntity abgelaufen: abgelaufene) {					
					builder.append(verarbeitun.sperreAufheben(abgelaufen, 
							new AktiveSperreDAO(entityManager), new MitspielerDAO(entityManager)));
					builder.append(";");
				}
			}
			transaction.commit();
			return Response.ok(builder.toString()).build();
		} catch (Exception exception) {
			LOGGER.error(exception.getMessage(), exception);
			transaction.rollback();
			return Response.serverError().build();
		}
	}
	
	@POST
	@Path("verlaengern")
	@Consumes(MediaType.APPLICATION_JSON)
	public Response aktiveVerlaengern(SperrenVerlaengernCallback callback) throws IllegalStateException, SecurityException, SystemException {
		try {
			if (callback == null || callback.getSpielerId() == null || callback.getFaktor() == null) {
				return Response.status(Status.BAD_REQUEST).build();
			}
			transaction.begin();
			AktiveSperreDAO aktiveSperreDAO = new AktiveSperreDAO(entityManager);
			List<AktiveSperreEntity> aktiveLocks = aktiveSperreDAO.findAktiveLocks(callback.getSpielerId());
			SperreVerarbeiten verarbeiten = new SperreVerarbeiten();
			aktiveLocks.forEach(lock -> verarbeiten.SperreVerlaengern(lock, callback.getFaktor(), aktiveSperreDAO));
			transaction.commit();
			return Response.accepted().build();
		} catch (Exception exception) {
			LOGGER.error(exception.getMessage(), exception);
			transaction.rollback();
			return Response.serverError().build();
		}
	}
}
