package org.gcube.application.cms.notifications;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import org.bson.Document;
import org.gcube.application.cms.implementations.utils.UserUtils;
import org.gcube.application.cms.notifications.config.SubscribeNotificationEvent;
import org.gcube.application.cms.notifications.manage.ManageDoActionNotification;
import org.gcube.application.cms.notifications.substitutor.NMessagesPlaceholdersSubstitutorUtil;
import org.gcube.application.cms.plugins.EventListenerPluginInterface;
import org.gcube.application.cms.plugins.events.EventListener;
import org.gcube.application.cms.plugins.events.EventManager;
import org.gcube.application.cms.plugins.events.EventManager.Event;
import org.gcube.application.cms.plugins.events.ItemObserved;
import org.gcube.application.cms.plugins.faults.InitializationException;
import org.gcube.application.cms.plugins.faults.InvalidProfileException;
import org.gcube.application.cms.plugins.faults.MaterializationException;
import org.gcube.application.cms.plugins.faults.ShutDownException;
import org.gcube.application.cms.plugins.implementations.AbstractPlugin;
import org.gcube.application.cms.plugins.reports.InitializationReport;
import org.gcube.application.cms.plugins.reports.Report;
import org.gcube.application.cms.plugins.reports.Report.Status;
import org.gcube.application.cms.serialization.Serialization;
import org.gcube.application.geoportal.common.model.document.Project;
import org.gcube.application.geoportal.common.model.plugins.PluginDescriptor;
import org.gcube.application.geoportal.common.model.useCaseDescriptor.UseCaseDescriptor;

import com.vdurmont.semver4j.Semver;

import lombok.Synchronized;
import lombok.extern.slf4j.Slf4j;

/**
 * The Class NotificationsPlugin.
 *
 * @author Francesco Mangiacrapa at ISTI-CNR francesco.mangiacrapa@isti.cnr.it
 * 
 *         Jan 30, 2024
 */
@Slf4j
public class NotificationsPlugin extends AbstractPlugin implements EventListenerPluginInterface {

	public static final String SUBSCRIBE_NOTIFICATIONS_CONFIG = "subscribeNotifications";
	public static final String PLUGIN_ID = "Notifications-Plugin";
	public static final String PLUGIN_TYPE = "EventListener";

	private static final String CONFIG_ENABLED = "enabled";
	private static final String CONFIG_LINK_TO_NOTIFICATIONS_MESSAGES = "link_to_notifications_messages";

	public static final PluginDescriptor DESCRIPTOR = new PluginDescriptor(PLUGIN_ID, PLUGIN_TYPE);

	static {
		DESCRIPTOR.setVersion(new Semver("1.0.0"));
		DESCRIPTOR.setDescription("Manage the notification from Geoportal engine");
	}

	// This is a map "<Context,<UCD_ID,NotificationEventsSubscribedConfig>"
	protected Map<String, Map<String, NotificationEventsSubscribedConfig>> notificationEventsBindingMap = null;

	/**
	 * Inits the.
	 *
	 * @return the initialization report
	 * @throws InitializationException the initialization exception
	 */
	@Override
	public InitializationReport init() throws InitializationException {
		log.debug("Called init");
		InitializationReport report = null;
		try {
			// Creating all listeners
			EventListener<ItemObserved<Project>> listenerCreated = new EventListener<ItemObserved<Project>>() {

				@Override
				public void updated(ItemObserved<Project> observerd) {
					log.info("listenerCreated fired on item: {} ", observerd);

					boolean subscribed = checkIfSubscribedEvent(observerd);

					if (subscribed) {
						doAction(observerd);
					}

				}
			};

			EventListener<ItemObserved<Project>> listenerUpdated = new EventListener<ItemObserved<Project>>() {

				@Override
				public void updated(ItemObserved<Project> observerd) {
					log.info("listenerUpdated fired on item: {} ", observerd);
					boolean subscribed = checkIfSubscribedEvent(observerd);

					if (subscribed) {
						doAction(observerd);
					}

				}
			};

			EventListener<ItemObserved<Project>> listenerDeleted = new EventListener<ItemObserved<Project>>() {

				@Override
				public void updated(ItemObserved<Project> observerd) {
					log.info("listenerDeleted fired on item: {} ", observerd);
					boolean subscribed = checkIfSubscribedEvent(observerd);

					if (subscribed) {
						doAction(observerd);
					}
				}
			};

			EventListener<ItemObserved<Project>> listenerLCStepPerformed = new EventListener<ItemObserved<Project>>() {

				@Override
				public void updated(ItemObserved<Project> observerd) {
					log.info("listenerLCStepPerformed fired on item: {} ", observerd);
					boolean subscribed = checkIfSubscribedEvent(observerd);

					if (subscribed) {
						doAction(observerd);
					}
				}
			};

			// Subscribing all events
			EventManager eventMngInst = EventManager.getInstance();
			eventMngInst.subscribe(Event.PROJECT_CREATED, listenerCreated);
			eventMngInst.subscribe(Event.PROJECT_UPDATED, listenerUpdated);
			eventMngInst.subscribe(Event.PROJECT_DELETED, listenerDeleted);
			eventMngInst.subscribe(Event.LIFECYCLE_STEP_PERFORMED, listenerLCStepPerformed);

			report = new InitializationReport(Status.OK, PLUGIN_ID + " init performed");
		} catch (Exception e) {
			InitializationException exc = new InitializationException("Unable to initialize " + DESCRIPTOR.getId(), e);
			log.error("init error: {} ", exc);
			throw exc;
		}

		return report;

	}

	/**
	 * Gets the descriptor.
	 *
	 * @return the descriptor
	 */
	@Override
	public PluginDescriptor getDescriptor() {
		return DESCRIPTOR;
	}

	/**
	 * Inits the in context.
	 *
	 * @return the initialization report
	 * @throws InitializationException the initialization exception
	 */
	@Override
	@Synchronized
	public InitializationReport initInContext() throws InitializationException {
		log.debug("Called initInContext");
		InitializationReport report = new InitializationReport();
		try {
			String context = UserUtils.getCurrent().getContext();
			if (getNotificationBindingMapPerContext() == null) {
				log.info("Initializing in " + context);
				notificationEventsBindingMap.put(context, new HashMap<String, NotificationEventsSubscribedConfig>());
			}
			report.setStatus(Report.Status.OK);
			report.putMessage("Initialized " + DESCRIPTOR.getId() + " in the " + context);
		} catch (Exception e) {
			InitializationException exc = new InitializationException("Unable to initialize " + DESCRIPTOR.getId(), e);
			log.error("initInContext error: {} ", exc);
			throw exc;
		}
		return report;
	}

	/**
	 * Check if subscribed event.
	 *
	 * @param observerd the observerd
	 * @return true, if successful
	 */
	public boolean checkIfSubscribedEvent(ItemObserved<Project> observerd) {
		log.info("Checking if {} is an subscribed event", observerd.getEvent());
		try {
			NotificationEventsSubscribedConfig eventsSub = readNotificationsSubscribedFromConfigurationInTheUCD(
					observerd.getUseCaseDescriptor());

			if (eventsSub != null) {

				List<SubscribeNotificationEvent> listEvents = eventsSub.getListNotificationEventSubscribed();
				log.info("List events is {}", listEvents);
				
				if(listEvents==null) {
					log.info("no event subscribed, returning false");
					return false;
				}
				
				if (listEvents.stream().anyMatch(sne -> sne.getEvent().equals(observerd.getEvent()))) {
					log.info("the event {} is subscribed from config ", observerd.getEvent());
					return true;
				}
				log.info("the event {} is not subscribed from config ", observerd.getEvent());
				return false;
			}
			log.info("the event {} is not subscribed from config ", observerd.getEvent());
			return false;

		} catch (Exception e) {
			log.error("Exception, Error on checking subscribed events", e);
			return false;
		}

	}

	/**
	 * Gets the notification binding map per context.
	 *
	 * @return the notification binding map per context
	 */
	protected Map<String, NotificationEventsSubscribedConfig> getNotificationBindingMapPerContext() {
		String context = UserUtils.getCurrent().getContext();
		log.debug("Getting {} from cache map for context {}", NotificationsPlugin.PLUGIN_ID, context);
		if (notificationEventsBindingMap == null) {
			notificationEventsBindingMap = new LinkedHashMap<String, Map<String, NotificationEventsSubscribedConfig>>();
		}

		// read notification events binding subscribed in the context
		Map<String, NotificationEventsSubscribedConfig> map = notificationEventsBindingMap.get(context);
		return map == null ? new LinkedHashMap<String, NotificationEventsSubscribedConfig>() : map;
	}

	/**
	 * Sets the notification binding map per context.
	 *
	 * @param context      the context
	 * @param ucd          the ucd
	 * @param notification the notification
	 */
	private void setNotificationBindingMapPerContext(String context, UseCaseDescriptor ucd,
			NotificationEventsSubscribedConfig notification) {
		Map<String, NotificationEventsSubscribedConfig> mapNotificationConfig = notificationEventsBindingMap
				.get(context);
		if (mapNotificationConfig == null) {
			mapNotificationConfig = new LinkedHashMap<String, NotificationEventsSubscribedConfig>();
		}

		mapNotificationConfig.put(ucd.getId(), notification);
		notificationEventsBindingMap.put(context, mapNotificationConfig);
	}

	/**
	 * Read notifications subscribed from configuration in the UCD.
	 *
	 * @param useCaseDescriptor the use case descriptor
	 * @return the notification events subscribed config
	 * @throws Exception the exception
	 */
	public NotificationEventsSubscribedConfig readNotificationsSubscribedFromConfigurationInTheUCD(
			UseCaseDescriptor useCaseDescriptor) throws Exception {

		log.debug("Reading subscribed events from UCD");

		NotificationEventsSubscribedConfig notificationMapPerContext = null;

		if (useCaseDescriptor == null)
			throw new Exception("Error reading UCD null found");

		try {

			String context = UserUtils.getCurrent().getContext();

			Map<String, NotificationEventsSubscribedConfig> mapPerContext = getNotificationBindingMapPerContext();

			notificationMapPerContext = mapPerContext.get(useCaseDescriptor.getId());

			if (notificationMapPerContext == null) {
				notificationMapPerContext = new NotificationEventsSubscribedConfig();
				setNotificationBindingMapPerContext(context, useCaseDescriptor, notificationMapPerContext);
			}

			List<SubscribeNotificationEvent> listNotificationEventsSubscribedPerUCD = notificationMapPerContext
					.getListNotificationEventSubscribed();

			if (listNotificationEventsSubscribedPerUCD == null) {
				listNotificationEventsSubscribedPerUCD = new ArrayList<SubscribeNotificationEvent>();
				Document profileConfiguration = getConfigurationFromProfile(useCaseDescriptor).getConfiguration();
				log.debug("UseCaseDescriptor Configuration is {} ", profileConfiguration);
				// JSONPathWrapper schemaNavigator = new
				// JSONPathWrapper(useCaseDescriptor.getSchema().toJson());

				if (profileConfiguration != null) {
					for (Object fsConfigObj : profileConfiguration.get(SUBSCRIBE_NOTIFICATIONS_CONFIG, List.class)) {
						log.debug("Managing {}", fsConfigObj);
						SubscribeNotificationEvent fsConfig = Serialization.convert(fsConfigObj,
								SubscribeNotificationEvent.class);
						log.debug("Converted config {}", fsConfig);
						try {
							Event theEventSubsribed = Serialization.convert(fsConfig.getEvent(), Event.class);
							if (theEventSubsribed == null)
								throw new MaterializationException(
										"Invalid Field Definition path in configuration [NO MATCH]  : "
												+ theEventSubsribed);
						} catch (Exception e) {
							log.error("MaterializationException: ", e);
							throw new MaterializationException(
									"Invalid Event Definition path in configuration [NO MATCH Event] : "
											+ Event.values());
						}

						listNotificationEventsSubscribedPerUCD.add(fsConfig);
					}

					notificationMapPerContext.setUcd(useCaseDescriptor);
					notificationMapPerContext
							.setListNotificationEventSubscribed(listNotificationEventsSubscribedPerUCD);
					String linkToMessages = profileConfiguration.get(CONFIG_LINK_TO_NOTIFICATIONS_MESSAGES,
							String.class);
					Boolean enabledNotifications = profileConfiguration.get(CONFIG_ENABLED, Boolean.class);
					notificationMapPerContext.setLinkToNotificationsMessages(linkToMessages);
					notificationMapPerContext.setEnabled(enabledNotifications);
				}
				setNotificationBindingMapPerContext(context, useCaseDescriptor, notificationMapPerContext);

				log.info("Events subscribed read from config {} ", notificationMapPerContext);

			}
		} catch (InvalidProfileException e) {
			log.warn("Unable to read configuration for {} in the UCD {}", NotificationsPlugin.PLUGIN_ID,
					useCaseDescriptor.getId());
		} catch (Exception e) {
			log.error("Unable to read configuration for " + NotificationsPlugin.PLUGIN_ID, e);
		} catch (Throwable t) {
			log.error("Exception, Unable to read configuration ", t);
		}

		return notificationMapPerContext;
	}

	/**
	 * Shutdown.
	 *
	 * @throws ShutDownException the shut down exception
	 */
	@Override
	public void shutdown() throws ShutDownException {
		// TODO Auto-generated method stub

	}

	/**
	 * Do action.
	 *
	 * @param itemObserved the item observed
	 */
	@Override
	public void doAction(ItemObserved<Project> itemObserved) {
		log.debug("doAction called...");

		boolean isSubscribedEvent = checkIfSubscribedEvent(itemObserved);

		log.info("Is the event {} subscribed in notification plugin configured in the UCD: {} ",
				itemObserved.getEvent(), isSubscribedEvent);

		if (isSubscribedEvent) {

			// Map (UCD_ID, Notification)
			Map<String, NotificationEventsSubscribedConfig> notificationMapPerContext = getNotificationBindingMapPerContext();

			NotificationEventsSubscribedConfig subscribedConfig = notificationMapPerContext
					.get(itemObserved.getUCD_Id());

			boolean subscribeNotificationsEnabled = subscribedConfig.isEnabled();

			log.info("subscribeNotifications enabled: {}", subscribeNotificationsEnabled);

			if (subscribeNotificationsEnabled) {

				String linkToFileWithMessages = subscribedConfig.getLinkToNotificationsMessages();
				List<SubscribeNotificationEvent> list = subscribedConfig.getListNotificationEventSubscribed();

				// Filtering list of SubscribeNotificationEvent for itemObserved Event
				List<SubscribeNotificationEvent> filterList = list.stream()
						.filter(sne -> sne.getEvent().equals(itemObserved.getEvent())).collect(Collectors.toList());

				log.debug(linkToFileWithMessages);
				NMessagesPlaceholdersSubstitutorUtil nMPlaceholdersSUtil = null;
				try {
					nMPlaceholdersSUtil = new NMessagesPlaceholdersSubstitutorUtil(linkToFileWithMessages);
				} catch (IOException e) {
					log.error("Error instancing the {}. Please check the URL {}. Returning!!",
							NMessagesPlaceholdersSubstitutorUtil.class.getSimpleName(), linkToFileWithMessages);
					return;
				}

				ManageDoActionNotification mdoact = new ManageDoActionNotification(itemObserved, nMPlaceholdersSUtil,
						filterList);
				mdoact.manage();

			}
		}

	}
}