#ifndef HYDRAECS
#define HYDRAECS

#include "../engine/HydraObject.h"
#include "HydraComponentManager.h"
#include "HydraEntityManager.h"
#include "HydraSystemManager.h"
#include <memory>

class HydraECS : HydraObject
{
private:
    std::unique_ptr<HydraEntityManager> m_entity_manager;
    std::unique_ptr<HydraComponentManager> m_component_manager;
    std::unique_ptr<HydraSystemManager> m_system_manager;

public:
    void Init();
    void Shutdown();
    HydraID CreateEntity()
    {
        return m_entity_manager->CreateEntity();
    }
    void DestroyEntity(HydraID entity_id)
    {
        m_entity_manager->DeleteEntity(entity_id);
        m_component_manager->EntityDeleted(entity_id);
        m_system_manager->EntityDeleted(entity_id);
    }

    template <typename T>
    void RegisterComponentType()
    {
        m_component_manager->RegisterComponentType<T>();
    }
    template <typename T>
    HydraID GetComponentType()
    {
        return m_component_manager->GetComponentTypeID<T>();
    }

    template <typename T>
    void AddComponent(HydraID entity_id, T component)
    {
        // Add teh component to the entity
        m_component_manager->AddComponent<T>(entity_id, component);

        // Get the current entity signature and update it to include
        // the new component
        auto signature = m_entity_manager->GetSignature(entity_id);
        signature.set(m_component_manager->GetComponentTypeID<T>(), true);
        m_entity_manager->SetSignature(entity_id, signature);

        // Tell the sytem manager that the entities signature has changed
        m_system_manager->EntitySignatureChanged(entity_id, signature);
    }
    template <typename T>
    void RemoveComponent(HydraID entity_id)
    {
        // Remove the component from the entity
        m_component_manager->RemoveComponent<T>(entity_id);

        // Get the current signature, remove the component from it and update
        auto signature = m_entity_manager->GetSignature(entity_id);
        signature.set(m_component_manager->GetComponentTypeID<T>(), false);
        m_entity_manager->SetSignature(entity_id, signature);

        // Tell the system manager that the entitys signature has changed
        m_system_manager->EntitySignatureChanged(entity_id, signature);
    }
    template <typename T>
    bool HasComponent(HydraID entity_id)
    {
        return m_component_manager->HasComponent<T>(entity_id);
    }

    template <typename T>
    T &GetComponent(HydraID entity_id)
    {
        return m_component_manager->GetComponent<T>(entity_id);
    }

    template <typename T>
    std::shared_ptr<T> RegisterSystem()
    {
        return m_system_manager->RegisterSystem<T>();
    }
    template <typename T>
    void SetSystemSignature(HydraSignature signature)
    {
        m_system_manager->SetSignature<T>(signature);
    }
    template <typename T>
    std::shared_ptr<T> GetSystem()
    {
        return m_system_manager->GetSystem<T>();
    }

    void InitialiseComponents()
    {
        m_system_manager->InitialiseComponents();
    }
};

#endif /* HYDRAECS */