ECSEngine.h

#pragma once

#include <functional>
#include <sstream>

#include <lazarus/ECS/Entity.h>
#include <lazarus/ECS/EventListener.h>
#include <lazarus/ECS/Updateable.h>

namespace lz
{
class ECSEngine
{
public:
    Entity* addEntity();

    void addEntity(Entity& entity);

    Entity* getEntity(Identifier entityId);

    template <typename... Types>
    std::vector<Entity*> entitiesWithComponents(bool includeDeleted=false);

    template <typename... Types>
    void applyToEach(
        typename std::common_type<std::function<void(Entity*, Types*...)>>::type&& func,
        bool includeDeleted=false);

    template <typename EventType>
    void subscribe(EventListener<EventType>* eventListener);

    template <typename EventType>
    void unsubscribe(EventListener<EventType>* eventListener);

    template <typename EventType>
    void emit(const EventType& event);

    void registerUpdateable(Updateable* updateable);

    virtual void update();

private:
    void garbageCollect();

private:
    std::unordered_map<Identifier, std::shared_ptr<Entity>> entities;
    std::vector<Updateable*> updateables;
    // Maps event type index -> list of event listeners for that event type
    std::unordered_map<std::type_index,
                       std::vector<__lz::BaseEventListener*>> subscribers;
};

template <typename... Types>
std::vector<Entity*> ECSEngine::entitiesWithComponents(bool includeDeleted)
{
    std::vector<Entity*> result;
    applyToEach<Types...>([&](Entity* ent, Types*... comp)
    {
        result.push_back(ent);
    },
    includeDeleted);
    return result;
}

template <typename... Types>
void ECSEngine::applyToEach(
    typename std::common_type<std::function<void(Entity*, Types*...)>>::type&& func,
    bool includeDeleted)
{
    for (auto it = entities.begin(); it != entities.end(); ++it)
    {
        Entity* entity = it->second.get();

        if (!includeDeleted && entity->isDeleted())
            continue;

        if (entity->has<Types...>())
            func(entity, entity->get<Types>()...);
    }
}

template <typename EventType>
void ECSEngine::subscribe(EventListener<EventType>* eventListener)
{
    std::type_index typeId = __lz::getTypeIndex<EventType>();
    auto found = subscribers.find(typeId);
    if (found == subscribers.end())
    {
        // No subscribers to this type of event yet, create vector
        std::vector<__lz::BaseEventListener*> vec;
        vec.push_back(eventListener);
        subscribers[typeId] = vec;
    }
    else
    {
        // There already exists a list of subscribers to this event type
        found->second.push_back(eventListener);
    }
}

template <typename EventType>
void ECSEngine::unsubscribe(EventListener<EventType>* eventListener)
{
    auto found = subscribers.find(__lz::getTypeIndex<EventType>());
    if (found != subscribers.end())
    {
        auto eventListeners = found->second;
        for (auto it = eventListeners.begin(); it != eventListeners.end(); ++it)
        {
            if (*it == eventListener)
            {
                // System found, remove it from the subscriber list
                eventListeners.erase(it);
                return;
            }
        }
    }
    // System was not found
    std::stringstream msg;
    msg << "ECS engine was not subscribed to the event ";
    msg << typeid(EventType).name();
    throw __lz::LazarusException(msg.str());
}

template <typename EventType>
void ECSEngine::emit(const EventType& event)
{
    // TODO: Log case in which an event is emitted but no listeners for that type exist
    auto found = subscribers.find(__lz::getTypeIndex<EventType>());
    if (found != subscribers.end())
    {
        auto eventListeners = found->second;
        for (auto it = eventListeners.begin(); it != eventListeners.end(); ++it)
        {
            auto* listener = dynamic_cast<EventListener<EventType>*>(*it);
            listener->receive(*this, event);
        }
    }
}
}  // namespace lz