Entity.h

#pragma once

#include <memory>
#include <typeindex>
#include <sstream>
#include <unordered_map>
#include <vector>

#include <lazarus/common.h>

namespace __lz  // Meant for internal use only
{
template <typename T>
std::type_index getTypeIndex()
{
    return std::type_index(typeid(T));
}

class BaseComponentHandle
{
public:
    virtual ~BaseComponentHandle() = default;
};

template <typename Component>
class ComponentHandle : public BaseComponentHandle
{
public:
    ComponentHandle(std::shared_ptr<Component> comp)
        : component(std::move(comp))
    {
    }

    Component *get() { return component.get(); }

private:
    std::shared_ptr<Component> component;
};
}

namespace lz
{
using Identifier = size_t;

class Entity
{
public:
    Entity();

    Identifier getId() const { return entityId; }

    template <typename Component>
    bool has() const;

    template <typename T, typename V, typename... Types>
    bool has() const;

    template <typename Component, typename... Args>
    void addComponent(Args&&... args);

    template <typename Component>
    void removeComponent();

    template <typename Component>
    Component* get();

    bool isDeleted() const { return deleted; }

    void markForDeletion() { deleted = true; }

    bool operator==(const Entity& other);

    bool operator!=(const Entity& other);
    
    bool operator<(const Entity& other);

private:
    const Identifier entityId;
    static Identifier entityCount;  // Keep track of the number of entities to assign new IDs
    std::unordered_map<std::type_index, std::shared_ptr<__lz::BaseComponentHandle>> components;
    bool deleted = false;
};

template <typename Component>
bool Entity::has() const
{
    return components.find(__lz::getTypeIndex<Component>()) != components.end();
}

template <typename T, typename V, typename... Types>
bool Entity::has() const
{
    return has<T>() && has<V, Types...>();
}

template <typename Component, typename... Args>
void Entity::addComponent(Args&&... args)
{
    // Check if the entity already holds a component T
    if (has<Component>())
    {
        std::stringstream msg;
        msg << "Entity " << getId() << " already holds a component of type "
            << typeid(Component).name();
        throw __lz::LazarusException(msg.str());
    }

    // Construct component and add it to the map
    std::shared_ptr<__lz::BaseComponentHandle> handle(
        new __lz::ComponentHandle<Component>(std::make_shared<Component>(args...))
    );
    components[__lz::getTypeIndex<Component>()] = std::move(handle);
}

template <typename Component>
void Entity::removeComponent()
{
    if (!has<Component>())
    {
        std::stringstream msg;
        msg << "Entity " << getId() << " does not have a component of type "
            << typeid(Component).name();
        throw __lz::LazarusException(msg.str());
    }

    components.erase(__lz::getTypeIndex<Component>());
}

template <typename Component>
Component* Entity::get()
{
    auto found = components.find(__lz::getTypeIndex<Component>());
    if (found == components.end())
        return nullptr;  // TODO: Log this case
    auto compHandle = dynamic_cast<__lz::ComponentHandle<Component>*>(found->second.get());
    return compHandle->get();
}
}  // namespace lz