package dev.kske.eventbus.core;

import java.lang.reflect.*;

import dev.kske.eventbus.core.Event.USE_PARAMETER;

/**
 * Internal representation of an event handling method.
 *
 * @author Kai S. K. Engelbart
 * @since 0.0.1
 * @see EventBus
 */
final class EventHandler implements Comparable<EventHandler> {

	/**
	 * The priority assigned to every event handler without an explicitly defined priority.
	 *
	 * @since 1.0.0
	 * @see Priority
	 */
	public static final int DEFAULT_PRIORITY = 100;

	private final EventListener				listener;
	private final Method					method;
	private final Event						annotation;
	private final Class<? extends IEvent>	eventType;
	private final boolean					polymorphic;
	private final int						priority;

	/**
	 * Constructs an event handler.
	 *
	 * @param listener   the listener containing the handler
	 * @param method     the handler method
	 * @param annotation the event annotation
	 * @throws EventBusException if the method or the annotation do not comply with the
	 *                           specification
	 * @since 0.0.1
	 */
	@SuppressWarnings("unchecked")
	EventHandler(EventListener listener, Method method, Event annotation) throws EventBusException {
		this.listener	= listener;
		this.method		= method;
		this.annotation	= annotation;

		// Check for correct method signature and return type
		if (method.getParameterCount() == 0 && annotation.eventType().equals(USE_PARAMETER.class))
			throw new EventBusException(method + " does not define an event type!");

		if (method.getParameterCount() == 1 && !annotation.eventType().equals(USE_PARAMETER.class))
			throw new EventBusException(method + " defines an ambiguous event type!");

		if (method.getParameterCount() > 1)
			throw new EventBusException(method + " defines more than one parameter!");

		if (!method.getReturnType().equals(void.class))
			throw new EventBusException(method + " does not have a return type of void!");

		// Determine the event type
		Class<? extends IEvent> eventType = annotation.eventType();
		if (eventType.equals(USE_PARAMETER.class)) {
			var param = method.getParameterTypes()[0];
			if (!IEvent.class.isAssignableFrom(param))
				throw new EventBusException(param + " is not of type IEvent!");
			eventType = (Class<? extends IEvent>) param;
		}
		this.eventType	= eventType;
		polymorphic		= method.isAnnotationPresent(Polymorphic.class);
		priority		= method.isAnnotationPresent(Priority.class)
			? method.getAnnotation(Priority.class).value()
			: DEFAULT_PRIORITY;

		// Allow access if the method is non-public
		method.setAccessible(true);
	}

	/**
	 * Compares this to another event handler based on priority. In case of equal priority a
	 * non-zero value based on hash codes is returned.
	 * <p>
	 * This is used to retrieve event handlers in order of descending priority from a tree set.
	 *
	 * @since 0.0.1
	 */
	@Override
	public int compareTo(EventHandler other) {
		int priority = other.priority - this.priority;
		if (priority == 0)
			priority = listener.hashCode() - other.listener.hashCode();
		return priority == 0 ? hashCode() - other.hashCode() : priority;
	}

	@Override
	public String toString() {
		return String.format("EventHandler[method=%s, eventType=%s, polymorphic=%b, priority=%d]",
			method, annotation.eventType(), polymorphic, priority);
	}

	/**
	 * Executes the event handler.
	 *
	 * @param event the event used as the method parameter
	 * @throws EventBusException if the handler throws an exception
	 * @since 0.0.1
	 */
	void execute(IEvent event) throws EventBusException {
		try {
			if (annotation.eventType() == USE_PARAMETER.class)
				method.invoke(listener, event);
			else
				method.invoke(listener);
		} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
			throw new EventBusException("Failed to invoke event handler!", e);
		}
	}

	/**
	 * @return the listener containing this handler
	 * @since 0.0.1
	 */
	EventListener getListener() { return listener; }

	/**
	 * @return the event type this handler listens to
	 * @since 0.0.3
	 */
	Class<? extends IEvent> getEventType() { return eventType; }

	/**
	 * @return the priority of this handler
	 * @since 0.0.1
	 * @see Priority
	 */
	int getPriority() { return priority; }

	/**
	 * @return whether this handler is polymorphic
	 * @since 1.0.0
	 * @see Polymorphic
	 */
	boolean isPolymorphic() { return polymorphic; }
}