#include "EventBus.hpp"

namespace Plains {
namespace Core {

// ============================== EventBus Class ==============================

EventBus::EventBus(Logger& logger) :
    _logger(logger)
{
    _logger.debug.ln ("Starting Event Bus...");
    //_thread = thread(&EventBus::run, this);
    _logger.debug.ln ("Event Bus Started");
}

EventBus::~EventBus() {
    _logger.debug.ln ("Stopping Event Bus...");
    //_thread.join();
    // destroy all events in _events vector
    for (auto event : _events) { delete event; }
    _logger.debug.ln ("Event Bus stopped");
}

Event& EventBus::registerEvent(const string& eventID) {
    _mutex.lock();
    for ( const auto event : _events ) {
        if (event->getID() == eventID) {
            _logger.debug << "Event '" << eventID << "' found" << Logger::commit;
            _mutex.unlock();
            return *event;
        }
    }
    //If event with that id does not exist, create it:
    _logger.debug << "Registering new Event '" << eventID << "'" << Logger::commit;
    Event* event = new Event(eventID);
    _events.push_back(event);
    _mutex.unlock();
    return *event;
}

void EventBus::run() {
    while (true) {
        std::this_thread::sleep_for(std::chrono::seconds(15));
         //_logger.warn.ln("EventBus: Looping...");
    }
}

// =============================== Event Class ================================

Event::Event(const string id) : _id(id) {}

Event::~Event() {}

const string& Event::getID() const {
    return _id;
};

void Event::subscribe(EventSubscriber* es) {
    _mutex.lock();
    _subscribers.push_back(es);
    _mutex.unlock();
}

void Event::fire() {
    for (auto subscriber : _subscribers) {
        subscriber->callback();
    }
}




}}