#pragma once

#include <functional>
#include <string>

#include "Event.h"

namespace crepe {
/**
 * \brief A type alias for an event handler function.
 * 
 * The EventHandler is a std::function that takes an EventType reference and returns a boolean value 
 * indicating whether the event is handled.
 * 
 * \tparam EventType The type of event this handler will handle.
 * 
 * Returning \c false from an event handler results in the event being propogated to other listeners for the same event type, while returning \c true stops propogation altogether.
 */
template <typename EventType>
using EventHandler = std::function<bool(const EventType & e)>;

/**
 * \class IEventHandlerWrapper
 * \brief An abstract base class for event handler wrappers.
 * 
 * This class provides the interface for handling events. Derived classes must implement the
 * `call()` method to process events
 */
class IEventHandlerWrapper {
public:
	/**
     * \brief Virtual destructor for IEventHandlerWrapper.
     */
	virtual ~IEventHandlerWrapper() = default;

	/**
     * \brief Executes the handler with the given event.
     * 
     * This method calls the `call()` method of the derived class, passing the event to the handler.
     * 
     * \param e The event to be processed.
     * \return A boolean value indicating whether the event is handled.
     */
	bool exec(const Event & e);

private:
	/**
     * \brief The method responsible for handling the event.
     * 
     * This method is implemented by derived classes to process the event.
     * 
     * \param e The event to be processed.
     * \return A boolean value indicating whether the event is handled.
     */
	virtual bool call(const Event & e) = 0;
};

/**
 * \class EventHandlerWrapper
 * \brief A wrapper for event handler functions.
 * 
 * This class wraps an event handler function of a specific event type. It implements the 
 * `call()` and `get_type()` methods to allow the handler to be executed and its type to be 
 * queried.
 * 
 * \tparam EventType The type of event this handler will handle.
 */
template <typename EventType>
class EventHandlerWrapper : public IEventHandlerWrapper {
public:
	/**
     * \brief Constructs an EventHandlerWrapper with a given handler.
     * 
     * The constructor takes an event handler function and stores it in the wrapper.
     * 
     * \param handler The event handler function.
     */
	explicit EventHandlerWrapper(const EventHandler<EventType> & handler);

private:
	/**
     * \brief Calls the stored event handler with the event.
     * 
     * This method casts the event to the appropriate type and calls the handler.
     * 
     * \param e The event to be handled.
     * \return A boolean value indicating whether the event is handled.
     */
	bool call(const Event & e) override;
	//! The event handler function.
	EventHandler<EventType> handler;
};

} // namespace crepe

#include "EventHandler.hpp"