#ifndef HYDRASYSTEMMANAGER
#define HYDRASYSTEMMANAGER

#include "../engine/HydraObject.h"
#include "HydraSystem.h"
#include "HydraEntity.h"
//#include "../ecssystems/HydraECSRenderSystem.h"
#include <memory>
#include <unordered_map>

class HydraSystemManager : public HydraObject
{
private:
    std::unordered_map<std::string, HydraSignature> m_signatures{};
    std::unordered_map<std::string, std::shared_ptr<HydraSystem>> m_systems{};

public:
	void Shutdown()
	{
		for (auto const& pair : m_systems)
		{
			auto const& system = pair.second;
			system->Shutdown();
		}
	}
	template <typename T> std::shared_ptr<T> GetSystem()
	{
		std::string type_name = std::string(typeid(T).name());
		auto it = m_systems.find(type_name);
		assert(it!= m_systems.end() && "System not found.");
		return std::static_pointer_cast<T>( it->second);
	}

    template <typename T>
    std::shared_ptr<T> RegisterSystem()
    {
        std::string type_name = std::string(typeid(T).name());
		
        assert(m_systems.find(type_name) == m_systems.end() && "Registering system more than once.");

        // Create a pointer to the system and return it so it can be used externally
        auto system = std::make_shared<T>();
		system->Initialise();
        m_systems.insert({type_name, system});
        return system;  
    }

    template<typename T> void SetSignature(HydraSignature signature)
    {
        std::string type_name = std::string(typeid(T).name());
		assert(m_systems.find(type_name) != m_systems.end() && "System used before registered.");
		// Set the signature for this system
		m_signatures.insert({type_name, signature});
    }
    void EntitySignatureChanged(HydraID entity_id, HydraSignature signature)
	{
		// Notify each system that an entity's signature changed
		for (auto const& pair : m_systems)
		{
			//auto const& type = pair.first;
			std::string type = pair.first;
			auto const& system = pair.second;
			auto const& system_signature = m_signatures[type];

			// Entity signature matches system signature - insert into set
			
			if ((signature & system_signature) == system_signature)
			{
				system->EntitiesToCreate.insert(entity_id);
				system->Entities.insert(entity_id);
			}
			// Entity signature does not match system signature - erase from set
			else
			{
				system->Entities.erase(entity_id);
				system->EntitiesToCreate.erase(entity_id);
			}
		}
	}
    void EntityDeleted(HydraID entity_id)
    {
        for (auto const& pair : m_systems)
		{
			auto const& system = pair.second;
			system->Entities.erase(entity_id);
			system->EntitiesToCreate.erase(entity_id);
		}
    }
	void InitialiseComponents()
	{
		for (auto const& pair : m_systems)
		{
			auto const& system = pair.second;
			system->InitialiseComponents();
		}
	}


};

#endif /* HYDRASYSTEMMANAGER */