#include "eventManager.h"

void EventManager::shutdown() { subscribers.clear(); }

void EventManager::subscribe(int eventType,
							 std::unique_ptr<IEventHandlerWrapper> && handler,
							 int eventId) {
	if (eventId) {
		std::unordered_map<
			int, std::unordered_map<
					 int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>::
			iterator subscribers
			= subscribersByEventId.find(eventType);

		if (subscribers != subscribersByEventId.end()) {
			std::unordered_map<
				int, std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
				handlersMap
				= subscribers->second;
			std::unordered_map<
				int,
				std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
				handlers
				= handlersMap.find(eventId);
			if (handlers != handlersMap.end()) {
				handlers->second.emplace_back(std::move(handler));
				return;
			}
		}
		subscribersByEventId[eventType][eventId].emplace_back(
			std::move(handler));

	} else {
		auto & handlers = subscribers[eventType];
		handlers.emplace_back(std::move(handler));
	}
}

void EventManager::unsubscribe(int eventType, const std::string & handlerName,
							   int eventId) {
	if (eventId) {
		std::unordered_map<
			int, std::unordered_map<
					 int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>::
			iterator subscriberList
			= subscribersByEventId.find(eventType);
		if (subscriberList != subscribersByEventId.end()) {
			std::unordered_map<
				int, std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
				handlersMap
				= subscriberList->second;
			std::unordered_map<
				int,
				std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
				handlers
				= handlersMap.find(eventId);
			if (handlers != handlersMap.end()) {
				std::vector<std::unique_ptr<IEventHandlerWrapper>> & callbacks
					= handlers->second;
				for (std::vector<
						 std::unique_ptr<IEventHandlerWrapper>>::iterator it
					 = callbacks.begin();
					 it != callbacks.end(); ++it) {
					if (it->get()->getType() == handlerName) {
						it = callbacks.erase(it);
						return;
					}
				}
			}
		}
	} else {
		std::unordered_map<
			int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
			handlersIt
			= subscribers.find(eventType);
		if (handlersIt != subscribers.end()) {
			std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
				= handlersIt->second;
			for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it
				 = handlers.begin();
				 it != handlers.end(); ++it) {
				if (it->get()->getType() == handlerName) {
					it = handlers.erase(it);
					return;
				}
			}
		}
	}
}

void EventManager::triggerEvent(const Event & event_, int eventId) {
	if (eventId > 0) {
		auto handlersIt
			= subscribersByEventId[event_.getEventType()].find(eventId);
		if (handlersIt != subscribersByEventId[event_.getEventType()].end()) {
			std::vector<std::unique_ptr<IEventHandlerWrapper>> & callbacks
				= handlersIt->second;
			for (auto it = callbacks.begin(); it != callbacks.end();) {
				(*it)->exec(event_);
				if ((*it)->isDestroyOnSuccess()) {
					it = callbacks.erase(it);
				} else {
					++it;
				}
			}
		}
	} else {
		auto & handlers = subscribers[event_.getEventType()];
		for (std::unique_ptr<IEventHandlerWrapper> & handler : handlers) {
			handler->exec(event_);
		}
	}
}

void EventManager::queueEvent(std::unique_ptr<Event> && event_, int eventId) {
	eventsQueue.emplace_back(std::move(event_), eventId);
}

void EventManager::dispatchEvents() {
	for (std::vector<std::pair<std::unique_ptr<Event>, int>>::iterator eventIt
		 = eventsQueue.begin();
		 eventIt != eventsQueue.end();) {
		if (!eventIt->first.get()->getHandled()) {
			triggerEvent(*eventIt->first.get(), eventIt->second);
			eventIt = eventsQueue.erase(eventIt);
		} else {
			++eventIt;
		}
	}
}