#pragma once
#include "event.h"
#include "eventHandler.h"
#include "keyCodes.h"
#include <memory>
#include <unordered_map>
#include <vector>
// using EventType = std::uint32_t;
// using EventId = std::uint64_t;

class EventManager {
public:
	EventManager(const EventManager &) = delete;
	const EventManager & operator=(const EventManager &) = delete;
	static EventManager & getInstance() {
		static EventManager instance;
		return instance;
	}

	void shutdown();
	void subscribe(int eventType,
				   std::unique_ptr<IEventHandlerWrapper> && handler,
				   int eventId);
	void unsubscribe(int eventType, const std::string & handlerName,
					 int eventId);
	void triggerEvent(const Event & event_, int eventId);
	void queueEvent(std::unique_ptr<Event> && event_, int eventId);
	void dispatchEvents();

private:
<<<<<<< HEAD
    EventManager() = default;
    std::vector<std::pair<std::unique_ptr<Event>, int>> eventsQueue;
    std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>> subscribers;
    std::unordered_map<int, std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>> subscribersByEventId;
=======
	EventManager() = default;
	std::vector<std::pair<std::unique_ptr<Event>, int>> m_eventsQueue;
	std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>
		m_subscribers;
	std::unordered_map<
		int, std::unordered_map<
				 int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>
		m_subscribersByEventId;
>>>>>>> b3b762a34e7ccb4a0dcd041a693ac7180af16002
};

template <typename EventType>
inline void subscribe(const EventHandler<EventType> & callback, int eventId = 0,
					  const bool unsubscribeOnSuccess = false) {
	std::unique_ptr<IEventHandlerWrapper> handler
		= std::make_unique<EventHandlerWrapper<EventType>>(
			callback, unsubscribeOnSuccess);
	EventManager::getInstance().subscribe(EventType::getStaticEventType(),
										  std::move(handler), eventId);
}

template <typename EventType>
inline void unsubscribe(const EventHandler<EventType> & callback,
						int eventId = 0) {
	const std::string handlerName = callback.target_type().name();
	EventManager::getInstance().unsubscribe(EventType::getStaticEventType(),
											handlerName, eventId);
}

inline void triggerEvent(const Event & triggeredEvent, int eventId = 0) {
	EventManager::getInstance().triggerEvent(triggeredEvent, eventId);
}

inline void queueEvent(std::unique_ptr<Event> && queuedEvent, int eventId = 0) {
	EventManager::getInstance().queueEvent(
		std::forward<std::unique_ptr<Event>>(queuedEvent), eventId);
}