/*
 * Copyright @ 2013 CurisTEC, S.A.S. All Rights Reserved.
 */
package net.curisit.securis.services;

import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

import jakarta.annotation.security.RolesAllowed;
import jakarta.inject.Inject;
import jakarta.persistence.EntityManager;
import jakarta.persistence.TypedQuery;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.ws.rs.Consumes;
import jakarta.ws.rs.DELETE;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.HeaderParam;
import jakarta.ws.rs.POST;
import jakarta.ws.rs.PUT;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.PathParam;
import jakarta.ws.rs.Produces;
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 org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import net.curisit.integrity.commons.Utils;
import net.curisit.securis.DefaultExceptionHandler;
import net.curisit.securis.SeCurisException;
import net.curisit.securis.db.Application;
import net.curisit.securis.db.LicenseType;
import net.curisit.securis.db.LicenseTypeMetadata;
import net.curisit.securis.db.User.Rol;
import net.curisit.securis.ioc.EnsureTransaction;
import net.curisit.securis.security.BasicSecurityContext;
import net.curisit.securis.security.Securable;
import net.curisit.securis.services.exception.SeCurisServiceException;
import net.curisit.securis.services.exception.SeCurisServiceException.ErrorCodes;
import net.curisit.securis.services.helpers.MetadataHelper;
import net.curisit.securis.utils.TokenHelper;

/**
 * LicenseTypeResource
 * <p>
 * CRUD for license types. Non-admin queries are scoped to the applications
 * accessible by the caller. Metadata changes are reconciled and, when keys
 * change, can be propagated to dependent entities via {@link MetadataHelper}.
 *
 * @author JRA
 * Last reviewed by JRA on Oct 5, 2025.
 */
@Path("/licensetype")
public class LicenseTypeResource {

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

	@Inject TokenHelper tokenHelper;
	@Inject MetadataHelper metadataHelper;

	@Context EntityManager em;

	public LicenseTypeResource() { }

	/**
	 * index
	 * <p>
	 * List license types. Non-admin users get only types for their allowed apps.
	 *
	 * @param bsc security context.
	 * @return 200 OK with list (possibly empty).
	 */
	@GET
	@Path("/")
	@Produces({ MediaType.APPLICATION_JSON })
	@Securable
	public Response index(@Context BasicSecurityContext bsc) {
		LOG.info("Getting license types list ");
		em.clear();
		TypedQuery<LicenseType> q;
		if (bsc.isUserInRole(BasicSecurityContext.ROL_ADMIN)) {
			q = em.createNamedQuery("list-license_types", LicenseType.class);
		} else {
			if (bsc.getApplicationsIds() == null || bsc.getApplicationsIds().isEmpty()) {
				return Response.ok().build();
			}
			q = em.createNamedQuery("list-license_types-by_apps-id", LicenseType.class);
			q.setParameter("list_ids", bsc.getApplicationsIds());
		}
		List<LicenseType> list = q.getResultList();
		return Response.ok(list).build();
	}

	/**
	 * get
	 * <p>
	 * Fetch a license type by id.
	 *
	 * @param ltid  LicenseType id (string form).
	 * @param token (unused) header token.
	 * @return 200 OK with the entity.
	 * @throws SeCurisServiceException 404 if not found.
	 */
	@GET
	@Path("/{ltid}")
	@Produces({ MediaType.APPLICATION_JSON })
	@Securable
	public Response get(@PathParam("ltid") String ltid, @HeaderParam(TokenHelper.TOKEN_HEADER_PÀRAM) String token) throws SeCurisServiceException {
		LOG.info("Getting license type data for id: {}: ", ltid);
		if (ltid == null || "".equals(ltid)) {
			LOG.error("LicenseType ID is mandatory");
			return Response.status(Status.NOT_FOUND).build();
		}

		em.clear();
		LicenseType lt = em.find(LicenseType.class, Integer.parseInt(ltid));
		if (lt == null) {
			LOG.error("LicenseType with id {} not found in DB", ltid);
			throw new SeCurisServiceException(ErrorCodes.NOT_FOUND, "LicenseType was not found in DB");
		}
		return Response.ok(lt).build();
	}

	/**
	 * create
	 * <p>
	 * Create a new license type. Requires ADMIN. Sets application reference,
	 * persists metadata entries and stamps creation time.
	 *
	 * @param lt    Payload.
	 * @param token (unused) token header.
	 * @return 200 OK with created entity, or 404 if app missing.
	 */
	@POST
	@Path("/")
	@Consumes(MediaType.APPLICATION_JSON)
	@Produces({ MediaType.APPLICATION_JSON })
	@EnsureTransaction
	@Securable(roles = Rol.ADMIN)
	@RolesAllowed(BasicSecurityContext.ROL_ADMIN)
	public Response create(LicenseType lt, @HeaderParam(TokenHelper.TOKEN_HEADER_PÀRAM) String token) {
		LOG.info("Creating new license type");

		try {
			setApplication(lt, lt.getApplicationId(), em);
		} catch (SeCurisException e) {
			return Response.status(Status.NOT_FOUND).header(DefaultExceptionHandler.ERROR_MESSAGE_HEADER, e.getMessage()).build();
		}

		if (lt.getApplicationId() == null) {
			LOG.error("Application is missing for current license type data");
			return Response.status(Status.NOT_FOUND).header(DefaultExceptionHandler.ERROR_MESSAGE_HEADER, "Application is missing for current license type data").build();
		}

		lt.setCreationTimestamp(new Date());
		em.persist(lt);
		Set<LicenseTypeMetadata> newMD = lt.getMetadata();

		if (newMD != null) {
			for (LicenseTypeMetadata md : newMD) {
				md.setLicenseType(lt);
				em.persist(md);
			}
		}
		lt.setMetadata(newMD);

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

	/**
	 * modify
	 * <p>
	 * Update an existing license type. Reconciles metadata:
	 * removes keys not present in the new set; merges existing; persists new ones.
	 * If keys changed, {@link MetadataHelper#propagateMetadata} is invoked.
	 *
	 * @param lt    New values.
	 * @param ltid  LicenseType id.
	 * @param token (unused) token.
	 * @return 200 OK with updated entity; 404 if not found or app missing.
	 */
	@PUT
	@POST
	@Path("/{ltid}")
	@EnsureTransaction
	@Consumes(MediaType.APPLICATION_JSON)
	@Produces({ MediaType.APPLICATION_JSON })
	@Securable(roles = Rol.ADMIN)
	@RolesAllowed(BasicSecurityContext.ROL_ADMIN)
	public Response modify(LicenseType lt, @PathParam("ltid") String ltid, @HeaderParam(TokenHelper.TOKEN_HEADER_PÀRAM) String token) {
		LOG.info("Modifying license type with id: {}", ltid);
		LicenseType currentlt = em.find(LicenseType.class, Integer.parseInt(ltid));
		if (currentlt == null) {
			LOG.error("LicenseType with id {} not found in DB", ltid);
			return Response.status(Status.NOT_FOUND).header(DefaultExceptionHandler.ERROR_MESSAGE_HEADER, "License type not found with ID: " + ltid).build();
		}

		try {
			setApplication(currentlt, lt.getApplicationId(), em);
		} catch (SeCurisException e) {
			return Response.status(Status.NOT_FOUND).header(DefaultExceptionHandler.ERROR_MESSAGE_HEADER, e.getMessage()).build();
		}

		currentlt.setCode(lt.getCode());
		currentlt.setName(lt.getName());
		currentlt.setDescription(lt.getDescription());

		Set<LicenseTypeMetadata> newMD = lt.getMetadata();
		Set<LicenseTypeMetadata> oldMD = currentlt.getMetadata();
		boolean metadataChanges = !metadataHelper.match(newMD, oldMD);
		if (metadataChanges) {
			Set<String> newMdKeys = getMdKeys(newMD);
			for (LicenseTypeMetadata currentMd : oldMD) {
				if (!newMdKeys.contains(currentMd.getKey())) {
					em.remove(currentMd);
					LOG.info("Removing MD: {}", currentMd);
				}
			}

			if (newMD != null) {
				Set<String> oldMdKeys = getMdKeys(oldMD);

				for (LicenseTypeMetadata md : newMD) {
					if (oldMdKeys.contains(md.getKey())) {
						em.merge(md);
					} else {
						md.setLicenseType(currentlt);
						em.persist(md);
					}
				}
			}
			currentlt.setMetadata(newMD);
		}
		em.merge(currentlt);
		if (metadataChanges) {
			Set<String> keys = newMD.parallelStream().map(md -> md.getKey()).collect(Collectors.toSet());
			metadataHelper.propagateMetadata(em, currentlt, keys);
		}

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

	/**
	 * delete
	 * <p>
	 * Delete a license type by id. Requires ADMIN.
	 *
	 * @param ltid LicenseType id.
	 * @param req  request (unused).
	 * @return 200 OK on success; 404 if not found.
	 */
	@DELETE
	@Path("/{ltid}")
	@EnsureTransaction
	@Produces({ MediaType.APPLICATION_JSON })
	@Securable(roles = Rol.ADMIN)
	@RolesAllowed(BasicSecurityContext.ROL_ADMIN)
	public Response delete(@PathParam("ltid") String ltid, @Context HttpServletRequest req) {
		LOG.info("Deleting app with id: {}", ltid);
		LicenseType app = em.find(LicenseType.class, Integer.parseInt(ltid));
		if (app == null) {
			LOG.error("LicenseType with id {} can not be deleted, It was not found in DB", ltid);
			return Response.status(Status.NOT_FOUND).build();
		}

		em.remove(app);
		return Response.ok(Utils.createMap("success", true, "id", ltid)).build();
	}

	// ---------------------------------------------------------------------
	// Helpers
	// ---------------------------------------------------------------------

	private Set<String> getMdKeys(Set<LicenseTypeMetadata> mds) {
		Set<String> ids = new HashSet<String>();
		if (mds != null) {
			for (LicenseTypeMetadata md : mds) {
				ids.add(md.getKey());
			}
		}
		return ids;
	}

	/**
	 * setApplication<p>
	 * Resolve and set the application of a license type.
	 *
	 * @param licType       target LicenseType.
	 * @param applicationId id of the application (nullable).
	 * @param em            entity manager.
	 * @throws SeCurisException if id provided but not found.
	 */
	private void setApplication(LicenseType licType, Integer applicationId, EntityManager em) throws SeCurisException {
		Application app = null;
		if (applicationId != null) {
			app = em.find(Application.class, applicationId);
			if (app == null) {
				LOG.error("LicenseType application with id {} not found in DB", applicationId);
				throw new SecurityException("License type's app not found with ID: " + applicationId);
			}
		}
		licType.setApplication(app);
	}
}