package net.curisit.securis.services.helpers;

import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.persistence.EntityManager;
import jakarta.persistence.TypedQuery;

import org.apache.commons.io.FileUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import net.curisit.integrity.exception.CurisRuntimeException;
import net.curisit.securis.beans.LicenseBean;
import net.curisit.securis.db.License;
import net.curisit.securis.db.LicenseHistory;
import net.curisit.securis.db.LicenseStatus;
import net.curisit.securis.db.Pack;
import net.curisit.securis.db.PackMetadata;
import net.curisit.securis.db.User;
import net.curisit.securis.security.BasicSecurityContext;
import net.curisit.securis.services.exception.SeCurisServiceException;
import net.curisit.securis.services.exception.SeCurisServiceException.ErrorCodes;

@ApplicationScoped
public class LicenseHelper {

	@SuppressWarnings("unused")
	private static final Logger LOG = LogManager.getLogger(LicenseHelper.class);
	private static final long MS_PER_DAY = 24L * 3600L * 1000L;

	@Inject
	private UserHelper userHelper;

	/**
	 * Cancel the license
	 * 
	 * @param lic
	 * @param em
	 */
	public void cancelLicense(License lic, String reason, BasicSecurityContext bsc, EntityManager em) throws SeCurisServiceException {
		lic.setStatus(LicenseStatus.CANCELLED);
		lic.setCancelledById(bsc.getUserPrincipal().getName());
		lic.setModificationTimestamp(new Date());
		em.persist(lic);

		em.persist(createLicenseHistoryAction(lic, userHelper.getUser(bsc, em), LicenseHistory.Actions.CANCEL, "Cancellation reason: " + reason));
	}

	/**
	 * Validates that the passed license exists and is still valid
	 * 
	 * @param licBean
	 * @param em
	 * @return The License instance in DB
	 * @throws SeCurisServiceException
	 */
	public License getActiveLicenseFromDB(LicenseBean licBean, EntityManager em) throws SeCurisServiceException {
		License lic = License.findLicenseByCode(licBean.getLicenseCode(), em);
		if (lic == null) {
			throw new SeCurisServiceException(ErrorCodes.LICENSE_DATA_IS_NOT_VALID, "Current license code doesn't exist");
		}
		if (lic.getStatus() != LicenseStatus.ACTIVE && lic.getStatus() != LicenseStatus.PRE_ACTIVE) {
			throw new SeCurisServiceException(ErrorCodes.LICENSE_DATA_IS_NOT_VALID, "Current license in not active");
		}
		return lic;
	}

	public LicenseHistory createLicenseHistoryAction(License lic, User user, String action, String comments) {
		LicenseHistory lh = new LicenseHistory();
		lh.setLicense(lic);
		lh.setUser(user);
		lh.setCreationTimestamp(new Date());
		lh.setAction(action);
		lh.setComments(comments);
		return lh;
	}

	public LicenseHistory createLicenseHistoryAction(License lic, User user, String action) {
		return createLicenseHistoryAction(lic, user, action, null);
	}

	/**
	 * Create a license file in a temporary directory
	 * 
	 * @param lic
	 * @param licFileName
	 * @return
	 * @throws IOException
	 */
	public File createTemporaryLicenseFile(License lic, String licFileName) throws IOException {
		File f = Files.createTempDirectory("securis-server").toFile();
		f = new File(f, licFileName);
		FileUtils.writeStringToFile(f, lic.getLicenseData(), StandardCharsets.UTF_8);
		return f;
	}

	public Map<String, Object> extractPackMetadata(Set<PackMetadata> packMetadata) {
		Map<String, Object> metadata = new HashMap<>();
		for (PackMetadata md : packMetadata) {
			metadata.put(md.getKey(), md.getValue());
		}

		return metadata;
	}

	/**
	 * If the action is a renew the expiration date is got form pack end valid
	 * date, if the action is a pre-activation the expiration date is calculated
	 * using the pack default valid period
	 * 
	 * @param pack
	 * @param isPreActivation
	 * @return
	 */
	public Date getExpirationDateFromPack(Pack pack, boolean isPreActivation) {
		Long validPeriod;
		if (pack.getEndValidDate().before(new Date())) {
			throw new CurisRuntimeException("Pack end valid period is reached, no new licenses can be activated.");
		}
		if (isPreActivation) {
			validPeriod = pack.getPreactivationValidPeriod() * MS_PER_DAY;
		} else {
			if (pack.getRenewValidPeriod() <= 0) {
				return pack.getEndValidDate();
			}
			long renewPeriod = pack.getRenewValidPeriod() * MS_PER_DAY;
			long expirationPeriod = pack.getEndValidDate().getTime() - new Date().getTime();
			validPeriod = renewPeriod < expirationPeriod ? renewPeriod : expirationPeriod;
		}
		Date expirationDate = new Date(new Date().getTime() + validPeriod);
		return expirationDate;
	}

	/**
	 * Get the next free code suffis for a given Pack
	 * 
	 * @param packId
	 * @param em
	 * @return
	 */
	public int getNextCodeSuffix(int packId, EntityManager em) {
		TypedQuery<Integer> query = em.createNamedQuery("last-code-suffix-used-in-pack", Integer.class);
		query.setParameter("packId", packId);
		Integer lastCodeSuffix = query.getSingleResult();
		return lastCodeSuffix == null ? 1 : lastCodeSuffix + 1;
	}

}