#pragma once
#include "entity.h"
#include <vector>
#include <unordered_map>
#include <queue>

namespace ecs {

class EntityManager {
public:
    EntityManager() : m_NextEntityID(0) {}
    ~EntityManager() = default;

    // Créer une nouvelle entité
    std::shared_ptr<Entity> CreateEntity() {
        EntityID id;
        
        // Réutiliser les IDs des entités supprimées si possible
        if (!m_FreeIDs.empty()) {
            id = m_FreeIDs.front();
            m_FreeIDs.pop();
        } else {
            id = m_NextEntityID++;
        }
        
        auto entity = std::make_shared<Entity>(id);
        m_Entities[id] = entity;
        
        return entity;
    }

    // Supprimer une entité
    void DestroyEntity(EntityID id) {
        auto it = m_Entities.find(id);
        if (it != m_Entities.end()) {
            m_Entities.erase(it);
            m_FreeIDs.push(id); // Recycler l'ID
        }
    }

    // Obtenir une entité par son ID
    std::shared_ptr<Entity> GetEntity(EntityID id) {
        auto it = m_Entities.find(id);
        if (it != m_Entities.end()) {
            return it->second;
        }
        return nullptr;
    }

    // Mettre à jour toutes les entités
    void UpdateEntities(float deltaTime) {
        for (auto& [id, entity] : m_Entities) {
            entity->UpdateComponents(deltaTime);
        }
    }

    // Obtenir toutes les entités
    std::vector<std::shared_ptr<Entity>> GetAllEntities() {
        std::vector<std::shared_ptr<Entity>> result;
        result.reserve(m_Entities.size());
        
        for (const auto& [id, entity] : m_Entities) {
            result.push_back(entity);
        }
        
        return result;
    }

    // Obtenir toutes les entités qui ont un composant spécifique
    template<typename T>
    std::vector<std::shared_ptr<Entity>> GetEntitiesWithComponent() {
        static_assert(std::is_base_of<Component, T>::value, "T must derive from Component");
        
        std::vector<std::shared_ptr<Entity>> result;
        
        for (auto& [id, entity] : m_Entities) {
            if (entity->HasComponent<T>()) {
                result.push_back(entity);
            }
        }
        
        return result;
    }

    // Obtenir le nombre d'entités
    size_t GetEntityCount() const {
        return m_Entities.size();
    }

    // Vider toutes les entités
    void Clear() {
        m_Entities.clear();
        
        // Vider la file des IDs libres
        std::queue<EntityID> empty;
        std::swap(m_FreeIDs, empty);
        
        m_NextEntityID = 0;
    }

private:
    EntityID m_NextEntityID;
    std::unordered_map<EntityID, std::shared_ptr<Entity>> m_Entities;
    std::queue<EntityID> m_FreeIDs; // IDs à réutiliser
};

}  // namespace ecs