vecs.h

Go to the documentation of this file.

 
#ifndef __VECS_H__
#define __VECS_H__
 
#include <cassert>
#include <chrono>
#include <cstdio>
#include <functional>
#include <memory>
#include <typeindex>
#include <unordered_map>
#include <variant>
 
#include "bundle.h"
#include "dense_map.h"
#include "type_id.h"
 
namespace vecs {
 
template<typename T>
class Optional;
 
template<typename T>
struct With {};
 
template<typename T>
struct Without {};
 
template<typename... Filters>
class Filter {};
 
namespace _traits {
 
    template<typename T>
    struct function_traits;
 
    // Specialization for function types
    template<typename R, typename... Args>
    struct function_traits<R(Args...)> {
        using result_type = R;
        using args_tuple = std::tuple<Args...>;
    };
 
    // Specialization for function pointers
    template<typename R, typename... Args>
    struct function_traits<R (*)(Args...)>: function_traits<R(Args...)> {};
 
    // Specialization for function references
    template<typename R, typename... Args>
    struct function_traits<R (&)(Args...)>: function_traits<R(Args...)> {};
 
    // Specialization for member function pointers
    template<typename C, typename R, typename... Args>
    struct function_traits<R (C::*)(Args...)>: function_traits<R(Args...)> {};
 
    // Specialization for const member function pointers
    template<typename C, typename R, typename... Args>
    struct function_traits<R (C::*)(Args...) const>:
        function_traits<R(Args...)> {};
 
    // Specialization for functors and lambdas
    template<typename T>
    struct function_traits: function_traits<decltype(&T::operator())> {};
 
    template<typename T, typename... Ts>
    struct contains;
 
    template<typename T>
    struct contains<T>: std::false_type {};
 
    template<typename T, typename U, typename... Ts>
    struct contains<T, U, Ts...>: contains<T, Ts...> {};
 
    template<typename T, typename... Ts>
    struct contains<T, T, Ts...>: std::true_type {};
 
    template<typename T>
    struct is_optional: std::false_type {};
 
    template<typename T>
    struct is_optional<Optional<T>>: std::true_type {};
 
}  // namespace _traits
 
namespace _traits::query {
 
    template<typename T>
    struct QueryTypeTraits {
        using StorageType = T*;
        using IterationType = T&;
        using IterationPointerType = T*;
 
        static IterationType dereference(StorageType arg) {
            return *arg;
        }
    };
 
    template<>
    struct QueryTypeTraits<Entity> {
        using StorageType = Entity;
        using IterationType = Entity;
        using IterationPointerType = Entity*;
 
        static IterationType dereference(StorageType arg) {
            return arg;
        }
    };
 
    template<typename T>
    struct QueryTypeTraits<Optional<T>> {
        using StorageType = Optional<T>;
        using IterationType = Optional<T>;
        using IterationPointerType = Optional<T>*;
 
        static IterationType dereference(StorageType arg) {
            return arg;
        }
    };
 
    template<typename T>
    struct filter_traits {
        static constexpr bool is_with = false;
        static constexpr bool is_without = false;
        using component_type = void;
    };
 
    template<typename T>
    struct filter_traits<With<T>> {
        static constexpr bool is_with = true;
        static constexpr bool is_without = false;
        using component_type = T;
    };
 
    template<typename T>
    struct filter_traits<Without<T>> {
        static constexpr bool is_with = false;
        static constexpr bool is_without = true;
        using component_type = T;
    };
 
}  // namespace _traits::query
 
struct Parent {
    Entity entity;
 
    operator Entity() {
        return entity;
    }
};
 
enum class ScheduleLabel {
    Startup,
    PreUpdate,
    Update,
    Validate,
    PostUpdate,
    PreStore,
    Store
};
 
// Forward declare
class World;
template<typename... Components>
struct Bundle;
template<typename... Components>
class Observer;
class Commands;
 
template<typename Tuple>
auto get_system_params(World& world);
 
struct TypeErasedResource {
    virtual ~TypeErasedResource() = default;
};
 
template<typename T>
struct Resource: TypeErasedResource {
    explicit Resource(T* ptr) : m_ptr(ptr) {}
 
    T& operator*() const {
        return *m_ptr;
    }
 
    T* operator->() const {
        return m_ptr;
    }
 
    T* get() const {
        return m_ptr;
    }
 
    T* get_mut() {
        return m_ptr;
    }
 
  private:
    T* m_ptr {nullptr};
};
 
class TypeErasedObserver {
  public:
    virtual ~TypeErasedObserver() = default;
    virtual const std::vector<Entity>& added() const = 0;
    virtual const std::vector<Entity>& inserted() const = 0;
    virtual const std::vector<Entity>& removed() const = 0;
 
  private:
    friend class World;
    virtual const ComponentMask& mask() const = 0;
    virtual void insert(Entity entity) = 0;
    virtual void remove(Entity entity) = 0;
    virtual void add(Entity entity) = 0;
    virtual void clear() = 0;
};
 
template<typename... Components>
class Observer: public TypeErasedObserver {
  public:
    Observer() : m_mask(compute_mask<Components...>()) {}
 
    Observer(const Observer&) = delete;
    Observer& operator=(const Observer&) = delete;
    Observer(Observer&&) = delete;
    Observer& operator=(Observer&&) = delete;
 
    const std::vector<Entity>& added() const override {
        return get_entities(Added);
    }
 
    const std::vector<Entity>& inserted() const override {
        return get_entities(Inserted);
    }
 
    const std::vector<Entity>& removed() const override {
        return get_entities(Removed);
    }
 
  private:
    ComponentMask m_mask;
 
    using kind = unsigned int;
 
    constexpr static kind Added = 0;
    constexpr static kind Inserted = 1;
    constexpr static kind Removed = 2;
 
    inline const std::vector<Entity>& get_entities(kind kind) const {
        static const std::vector<Entity> empty;
        auto it = m_entities.find(kind);
        return (it != m_entities.end()) ? it->second : empty;
    }
 
    const ComponentMask& mask() const override {
        return m_mask;
    }
 
    void add(Entity entity) override {
        m_entities[Added].push_back(entity);
    }
 
    void insert(Entity entity) override {
        m_entities[Inserted].push_back(entity);
    }
 
    void remove(Entity entity) override {
        m_entities[Removed].push_back(entity);
    }
 
    void clear() override {
        m_entities.clear();
    }
 
    storage::dense_map<kind, std::vector<Entity>> m_entities;
};
 
class EntityBuilder;
template<typename... Components>
class Query;
 
struct Time {
    float delta {0.f};
};
 
class World {
  public:
    World() :
        m_last_time(std::chrono::high_resolution_clock::now()),
        m_commands(std::make_unique<Commands>(*this)) {
        add_resource(&m_time);
    }
 
    template<typename T>
    World& add_resource(T* resource) {
        m_resources[typeid(T)] = std::make_unique<Resource<T>>(resource);
        return *this;
    }
 
    template<typename T>
    Resource<T>& get_resource() const {
        auto it = m_resources.find(typeid(T));
 
        assert(it != m_resources.end() && "Requested resource not found");
 
        return *static_cast<Resource<T>*>(it->second.get());
    }
 
    template<typename Func>
    void add_system(ScheduleLabel label, Func&& func) {
        get_systems(label).emplace_back(
            std::make_unique<System<std::decay_t<Func>>>(
                std::forward<Func>(func),
                *this
            )
        );
    }
 
    template<typename Func>
    void add_system(Func&& func) {
        add_system(ScheduleLabel::Update, std::forward<Func>(func));
    }
 
    inline void progress() {
        auto current_time = std::chrono::high_resolution_clock::now();
        std::chrono::duration<float> delta = current_time - m_last_time;
        m_time.delta = delta.count();
        m_last_time = current_time;
        execute_progress();
    }
 
    inline void progress(float delta_time) {
        m_time.delta = delta_time;
        execute_progress();
    }
 
    EntityBuilder spawn();
 
    template<typename... Components>
    inline Query<Components...> query() {
        return Query<Components...>(this);
    }
 
    template<typename... Components>
    Observer<Components...>& observe() {
        auto observer = std::make_unique<Observer<Components...>>();
        auto new_observer = observer.get();
        m_observers.push_back(std::move(observer));
        return *new_observer;
    }
 
    inline Commands& commands();
 
    void despawn(Entity entity) {
        auto entity_it = m_entity_archetype_map.find(entity);
        if (entity_it == m_entity_archetype_map.end()) {
            // can't despawn non-existant entity
            return;
        }
 
        Archetype* archetype = entity_it->second;
        archetype->remove_entity(entity);
        m_entity_archetype_map.erase(entity_it);
        notify_remove(archetype->m_mask, entity);
        m_free_list.push_back(entity);
        ++m_query_version;
    }
 
    void log_archetypes() {
        printf("--- Logging Archetypes ---\n");
        for (const auto& archetype : m_archetypes) {
            printf(
                "Archetype with mask: %s\n",
                archetype->m_mask.to_string().c_str()
            );
 
            if (archetype->m_entity_to_index.empty()) {
                printf("No entities in this archetype (empty)\n");
            } else {
                printf("Entities in this archetype: ");
                for (const auto& entity : archetype->m_entity_to_index) {
                    printf("Entity(%zu) ", entity.first);
                }
                printf("(total = %zu)\n", archetype->m_entity_to_index.size());
            }
        }
        printf("--- End of Archetypes Log ---\n");
    }
 
  private:
    template<typename... Components>
    friend class Query;
    friend class EntityBuilder;
    friend class EntityCommands;
 
    // System implementation details
    struct TypeErasedSystem {
        virtual ~TypeErasedSystem() = default;
        virtual void execute(World& world) = 0;
    };
 
    template<typename Func>
    struct System: TypeErasedSystem {
        Func func;
 
        System(Func&& f, World& world) :
            params(get_system_params<
                   typename _traits::function_traits<Func>::args_tuple>(world)),
            func(std::forward<Func>(f)) {}
 
        void execute(World& world) override {
            std::apply(func, params);
        }
 
      private:
        using Params =
            decltype(get_system_params<
                     typename _traits::function_traits<Func>::args_tuple>(
                std::declval<World&>()
            ));
        Params params;
    };
 
    // Archetype storage implementation details
    class Archetype {
      private:
        template<typename... Components>
        friend class Query;
        friend class World;
        friend class EntityBuilder;
 
        template<typename T>
        T* get_component(Entity entity) {
            auto it = m_entity_to_index.find(entity);
            if (it == m_entity_to_index.end()) {
                return nullptr;
            }
            return get_row<T>(it->second);
        }
 
        template<typename T>
        T* get_row(size_t row) {
            static const ComponentId id = TypeIDGenerator::get_type_id<T>();
            auto it = m_type_to_column.find(id);
            if (it == m_type_to_column.end()) {
                // Component type does not exist in the archetype
                return nullptr;
            }
 
            auto* column =
                static_cast<ComponentColumn<T>*>(m_columns[it->second].get());
            if (row >= column->data.size()) {
                // Row index is out of range
                return nullptr;
            }
 
            return &column->data[row];
        }
 
        template<typename Component>
        static auto
        get_component_or_entity(Archetype* archetype, const Entity& entity) {
            if constexpr (std::is_same_v<Component, Entity>) {
                return entity;
            } else if constexpr (_traits::is_optional<Component>()) {
                using UnderlyingType = typename Component::value_type;
                return Optional<UnderlyingType>(
                    archetype->template get_component<UnderlyingType>(entity)
                );
            } else {
                return archetype->template get_component<Component>(entity);
            }
        }
 
        template<typename... Components>
        static auto
        make_component_tuple(Archetype* archetype, const Entity& entity) {
            return std::make_tuple(
                get_component_or_entity<Components>(archetype, entity)...
            );
        }
 
        Archetype(const ComponentMask& mask) : m_mask(mask) {}
 
        template<typename... Components>
        static std::unique_ptr<Archetype> from_columns() {
            ComponentMask mask = compute_mask<Components...>();
            auto archetype = std::make_unique<Archetype>(Archetype(mask));
            (archetype->add_column<Components>(), ...);
            return std::move(archetype);
        }
 
        template<typename... NewComponents>
        static std::unique_ptr<Archetype>
        from_archetype(const Archetype& old_archetype) {
            ComponentMask new_components_mask =
                compute_mask<NewComponents...>();
            ComponentMask combined_mask =
                old_archetype.m_mask | new_components_mask;
 
            auto new_archetype =
                std::make_unique<Archetype>(Archetype(combined_mask));
 
            for (const auto& [component_id, column_index] :
                 old_archetype.m_type_to_column) {
                auto& component = old_archetype.m_columns[column_index];
                new_archetype->m_columns.emplace_back(component->clone_empty());
                new_archetype->m_type_to_column[component_id] =
                    new_archetype->m_columns.size() - 1;
            }
 
            (new_archetype->add_column<NewComponents>(), ...);
 
            return new_archetype;
        }
 
        template<typename T>
        void add_column() {
            ComponentId id = TypeIDGenerator::get_type_id<T>();
            m_columns.push_back(std::make_unique<ComponentColumn<T>>());
            m_type_to_column[id] = m_columns.size() - 1;
        }
 
        template<typename T>
        void add_row(size_t row, T&& component) {
            static const ComponentId id = TypeIDGenerator::get_type_id<T>();
 
            auto it = m_type_to_column.find(id);
            if (it == m_type_to_column.end()) {
                printf("Error: column does not exist in archetype\n");
                std::abort();
            }
 
            auto* column = static_cast<ComponentColumn<T>*>(
                m_columns[m_type_to_column[id]].get()
            );
 
            if (column->data.size() <= row) {
                column->data.resize(row + 1);
            }
 
            column->data[row] = std::forward<T>(component);
        }
 
        template<typename... Components>
        void update_components(Entity entity, Components&&... components) {
            (update_row<Components>(entity, components), ...);
        }
 
        template<typename T>
        void update_row(Entity entity, T&& component) {
            static const ComponentId id = TypeIDGenerator::get_type_id<T>();
 
            auto it = m_type_to_column.find(id);
            if (it == m_type_to_column.end()) {
                printf("error: coulmn does not exist in archetype\n");
                std::abort();
            }
 
            auto* column = static_cast<ComponentColumn<T>*>(
                m_columns[m_type_to_column[id]].get()
            );
 
            auto row_it = m_entity_to_index.find(entity);
 
            if (row_it == m_entity_to_index.end()) {
                printf("error: row does not exist in archetype\n");
                std::abort();
            }
 
            column->data[row_it->second] = std::forward<T>(component);
        }
 
        template<typename... Components>
        bool has_components() const {
            auto mask = compute_mask<Components...>();
            return has_components(mask);
        }
 
        bool has_components(ComponentMask mask) const {
            // return (m_mask & mask) == mask;
            return m_mask.contains(mask);
        }
 
        template<typename... Components>
        void add_entity(Entity entity, Components&&... components) {
            size_t row = m_next_available_row;
            m_entity_to_index[entity] = row;
            (add_row<Components>(row, std::forward<Components>(components)),
             ...);
            ++m_next_available_row;
        }
 
        void remove_entity(Entity entity) {
            auto it = m_entity_to_index.find(entity);
            if (it == m_entity_to_index.end()) {
                return;
            }
            size_t row = it->second;
            size_t last_row = m_next_available_row - 1;
            if (row != last_row) {
                for (auto& column : m_columns) {
                    column->swap(row, last_row);
                }
                for (auto& pair : m_entity_to_index) {
                    if (pair.second == last_row) {
                        pair.second = row;
                        break;
                    }
                }
            }
 
            --m_next_available_row;
 
            for (auto& column : m_columns) {
                column->pop_back();
            }
 
            m_entity_to_index.erase(it);
        }
 
        struct TypeErasedComponentColumn {
            virtual ~TypeErasedComponentColumn() = default;
            virtual std::unique_ptr<TypeErasedComponentColumn>
            clone_empty() const = 0;
            virtual void copy_component_to(
                TypeErasedComponentColumn* target_column,
                size_t from_index,
                size_t to_index
            ) = 0;
            virtual void swap(size_t index1, size_t index2) = 0;
            virtual void pop_back() = 0;
        };
 
        template<typename T>
        struct ComponentColumn: TypeErasedComponentColumn {
            using StorageType = typename std::decay<T>::type;
 
            std::vector<StorageType> data;
 
            std::unique_ptr<TypeErasedComponentColumn>
            clone_empty() const override {
                return std::make_unique<ComponentColumn<T>>();
            }
 
            void copy_component_to(
                TypeErasedComponentColumn* target_column,
                size_t from_index,
                size_t to_index
            ) override {
                auto* target = static_cast<ComponentColumn<T>*>(target_column);
                if (target->data.size() <= to_index) {
                    target->data.resize(to_index + 1);
                }
                target->data[to_index] = this->data[from_index];
            }
 
            void swap(size_t index1, size_t index2) override {
                std::swap(data[index1], data[index2]);
            }
 
            void pop_back() override {
                data.pop_back();
            }
        };
 
        template<typename... NewComponents>
        void move_entity(
            Archetype* target_archetype,
            Entity entity,
            NewComponents&&... new_components
        ) {
            auto it = m_entity_to_index.find(entity);
            if (it == m_entity_to_index.end()) {
                printf("Error: Entity not found in archetype during move.\n");
                std::abort();
            }
            size_t source_row = it->second;
            size_t target_row = target_archetype->m_next_available_row;
            target_archetype->m_entity_to_index[entity] = target_row;
 
            for (const auto& [component_id, column_index] : m_type_to_column) {
                auto& src_column = m_columns[column_index];
                auto target_it =
                    target_archetype->m_type_to_column.find(component_id);
                if (target_it != target_archetype->m_type_to_column.end()) {
                    size_t target_column_index = target_it->second;
                    auto& target_column =
                        target_archetype->m_columns[target_column_index];
 
                    // Move the component data
                    src_column->copy_component_to(
                        target_column.get(),
                        source_row,
                        target_row
                    );
                }
            }
 
            // Add new components
            (target_archetype->add_row<NewComponents>(
                 target_row,
                 std::forward<NewComponents>(new_components)
             ),
             ...);
 
            // Increment the target archetype's row count
            ++target_archetype->m_next_available_row;
        }
 
        ComponentMask m_mask;
 
        size_t m_next_available_row {0};
        storage::dense_map<ComponentId, size_t> m_type_to_column;
        storage::dense_map<Entity, size_t> m_entity_to_index;
        std::vector<std::unique_ptr<TypeErasedComponentColumn>> m_columns;
    };
 
    void notify_add(const ComponentMask& mask, Entity entity) {
        for (const auto& observer : m_observers) {
            if (mask.contains(observer->mask())) {
                observer->add(entity);
            }
        }
    }
 
    void notify_insert(const ComponentMask& mask, Entity entity) {
        for (const auto& observer : m_observers) {
            if (mask.contains(observer->mask())) {
                observer->insert(entity);
            }
        }
    }
 
    void notify_remove(const ComponentMask& mask, Entity entity) {
        for (const auto& observer : m_observers) {
            if (mask.contains(observer->mask())) {
                observer->remove(entity);
            }
        }
    }
 
    template<typename... Components>
    void add_components(Entity entity, Components&&... components) {
        auto new_components_mask = compute_mask<Components...>();
        ComponentMask combined_mask = new_components_mask;
 
        Archetype* current_archetype = nullptr;
        auto entity_it = m_entity_archetype_map.find(entity);
        if (entity_it != m_entity_archetype_map.end()) {
            current_archetype = entity_it->second;
            combined_mask = current_archetype->m_mask | new_components_mask;
 
            // Check if the current archetype can accommodate the new components
            if (current_archetype->m_mask.contains(new_components_mask)) {
                current_archetype->update_components(entity, components...);
                notify_insert(combined_mask, entity);
                return;
            }
        }
 
        // Find or create an archetype with the combined mask
        Archetype* target_archetype = nullptr;
        auto archetype_it = m_archetype_map.find(combined_mask);
        if (archetype_it != m_archetype_map.end()) {
            // Use existing archetype
            target_archetype = archetype_it->second;
        } else {
            // Create a new archetype with combined components
            if (current_archetype == nullptr) {
                auto new_archetype = Archetype::from_columns<Components...>();
                target_archetype = new_archetype.get();
                m_archetypes.push_back(std::move(new_archetype));
                m_archetype_map[combined_mask] = target_archetype;
            } else {
                auto new_archetype =
                    Archetype::from_archetype<Components...>(*current_archetype
                    );
                target_archetype = new_archetype.get();
                m_archetypes.push_back(std::move(new_archetype));
                m_archetype_map[combined_mask] = target_archetype;
            }
        }
 
        if (current_archetype != nullptr) {
            current_archetype->move_entity(
                target_archetype,
                entity,
                std::forward<Components>(components)...
            );
            notify_add(combined_mask, entity);
            notify_insert(combined_mask, entity);
            // Remove the entity from the current archetype
            current_archetype->remove_entity(entity);
        } else {
            target_archetype->add_entity(
                entity,
                std::forward<Components>(components)...
            );
            notify_add(combined_mask, entity);
            notify_insert(combined_mask, entity);
        }
        m_entity_archetype_map[entity] = target_archetype;
        ++m_query_version;
    }
 
    template<typename Component>
    void remove_component(Entity entity) {
        auto entity_it = m_entity_archetype_map.find(entity);
        if (entity_it == m_entity_archetype_map.end()) {
            return;
        }
 
        Archetype* current_archetype = entity_it->second;
 
        ComponentMask new_mask = current_archetype->m_mask;
        ComponentId component_id = TypeIDGenerator::get_type_id<Component>();
        new_mask.reset(component_id);
 
        // Check if an archetype with this mask already exists
        Archetype* target_archetype = nullptr;
        auto archetype_it = m_archetype_map.find(new_mask);
        if (archetype_it != m_archetype_map.end()) {
            target_archetype = archetype_it->second;
        } else {
            // Create a new archetype based on the current one minus the target component
            target_archetype =
                Archetype::from_archetype<>(*current_archetype).release();
            target_archetype->m_mask = new_mask;
 
            m_archetypes.push_back(std::unique_ptr<Archetype>(target_archetype)
            );
            m_archetype_map[new_mask] = target_archetype;
        }
 
        current_archetype->move_entity(target_archetype, entity);
        current_archetype->remove_entity(entity);
 
        m_entity_archetype_map[entity] = target_archetype;
        notify_remove(current_archetype->m_mask, entity);
 
        ++m_query_version;
    }
 
    inline void execute_schedule(ScheduleLabel label) {
        for (const auto& system : get_systems(label)) {
            system->execute(*this);
        }
        // auto it = m_systems.find(label);
        // if (it != m_systems.end()) {
        //     for (auto& system_ptr : it->second) {
        //         system_ptr->execute(*this);
        //     }
        // }
    }
 
    inline void execute_commands();
 
    inline void execute_progress() {
        execute_schedule(ScheduleLabel::Startup);
        execute_schedule(ScheduleLabel::PreUpdate);
        execute_schedule(ScheduleLabel::Update);
        execute_schedule(ScheduleLabel::Validate);
        execute_schedule(ScheduleLabel::PostUpdate);
        execute_schedule(ScheduleLabel::PreStore);
        execute_schedule(ScheduleLabel::Store);
 
        for (const auto& observer : m_observers) {
            observer->clear();
        }
 
        execute_commands();
 
        get_systems(ScheduleLabel::Startup).clear();
 
        // auto startup_it = m_systems.find(ScheduleLabel::Startup);
        // if (startup_it != m_systems.end()) {
        //     startup_it->second.clear();
        // }
    }
 
    Time m_time;
    std::chrono::high_resolution_clock::time_point m_last_time;
 
    inline std::vector<std::unique_ptr<TypeErasedSystem>>&
    get_systems(ScheduleLabel label) {
        return m_systems[static_cast<std::underlying_type_t<ScheduleLabel>>(
            label
        )];
    }
 
    storage::dense_map<
        std::underlying_type_t<ScheduleLabel>,
        std::vector<std::unique_ptr<TypeErasedSystem>>>
        m_systems;
 
    // std::unordered_map<
    //     ScheduleLabel,
    //     std::vector<std::unique_ptr<TypeErasedSystem>>>
    //     m_systems;
 
    std::unordered_map<std::type_index, std::unique_ptr<TypeErasedResource>>
        m_resources;
 
    Entity m_current_entity_id {0};
    unsigned int m_query_version {0};
    std::vector<std::unique_ptr<Archetype>> m_archetypes;
    std::unordered_map<ComponentMask, Archetype*> m_archetype_map;
    storage::dense_map<Entity, Archetype*> m_entity_archetype_map;
    std::vector<std::unique_ptr<TypeErasedObserver>> m_observers;
    std::unique_ptr<Commands> m_commands;
    std::vector<Entity> m_free_list;
};
 
template<typename... Filters>
struct QueryFilter {
    static ComponentMask evaluate(ComponentMask mask) {
        QueryFilter<Filters...> filter;
        (Filters::evaluate(mask), ...);
        return mask;
    }
};
 
// template<typename... Components>
// struct With {
//     static void evaluate(ComponentMask& mask) {
//         mask |= compute_mask<Components...>();
//     }
// };
 
// template<typename... Components>
// struct Without {
//     static void evaluate(ComponentMask& mask) {
//         mask &= ~compute_mask<Components...>();
//     }
// };
 
template<typename T>
class Optional {
  public:
    using value_type = T;
 
    Optional() : m_ptr(nullptr) {}
 
    explicit Optional(T* ptr) : m_ptr(ptr) {}
 
    operator bool() const {
        return has_value();
    }
 
    T& operator*() const {
        return get();
    }
 
    T& get() const {
        assert(has_value() && "Optional is none");
        return *m_ptr;
    }
 
    T* operator->() {
        return m_ptr;
    }
 
    T* operator->() const {
        return m_ptr;
    }
 
    bool has_value() const {
        return m_ptr != nullptr;
    }
 
  private:
    T* m_ptr;
};
 
// Forward declaration of primary template
template<typename... Args>
class Test;
 
// Specialization for Filter version
template<typename... Filters, typename... Components>
class Test<Filter<Filters...>, Components...> {
  private:
    template<typename T>
    using filter_traits = _traits::query::filter_traits<T>;
 
    static ComponentMask compute_mask() {
        ComponentMask mask;
        (add_component_to_mask<Components>(mask), ...);
        (apply_filter<Filters>(mask), ...);
        return mask;
    }
 
    template<typename Component>
    static void add_component_to_mask(ComponentMask& mask) {
        if constexpr (!_traits::is_optional<Component>::value
                      && !std::is_same_v<Component, Entity>) {
            ComponentId id = TypeIDGenerator::get_type_id<Component>();
            if (id >= mask.size()) {
                mask.resize(id + 1);
            }
            mask.set(id);
        }
    }
 
    template<typename Filter>
    static void apply_filter(ComponentMask& mask) {
        using Traits = filter_traits<Filter>;
        if constexpr (Traits::is_with) {
            add_component_to_mask<typename Traits::component_type>(mask);
        } else if constexpr (Traits::is_without) {
            ComponentId id =
                TypeIDGenerator::get_type_id<typename Traits::component_type>();
            if (id >= mask.size()) {
                mask.resize(id + 1);
            }
            mask.reset(id);
        }
    }
 
  public:
    void describe() {
        printf("Components: ");
        ((printf("%s ", typeid(Components).name())), ...);
        printf("\n");
        printf("Filters: ");
        ((printf("%s ", typeid(Filters).name())), ...);
        printf("\n");
 
        auto mask = compute_mask();
        printf("Mask: ");
        for (size_t i = 0; i < mask.size(); ++i) {
            printf("%d", mask.test(i) ? 1 : 0);
        }
        printf("\n");
    }
};
 
// New specialization for components-only version
template<typename... Components>
class Test {
  private:
    static ComponentMask compute_mask() {
        ComponentMask mask;
        (add_component_to_mask<Components>(mask), ...);
        return mask;
    }
 
    template<typename Component>
    static void add_component_to_mask(ComponentMask& mask) {
        if constexpr (!_traits::is_optional<Component>::value
                      && !std::is_same_v<Component, Entity>) {
            ComponentId id = TypeIDGenerator::get_type_id<Component>();
            if (id >= mask.size()) {
                mask.resize(id + 1);
            }
            mask.set(id);
        }
    }
 
  public:
    void describe() {
        printf("Components: ");
        ((printf("%s ", typeid(Components).name())), ...);
        printf("\n");
 
        auto mask = compute_mask();
        printf("Mask: ");
        for (size_t i = 0; i < mask.size(); ++i) {
            printf("%d", mask.test(i) ? 1 : 0);
        }
        printf("\n");
    }
};
 
// Deduction guides
template<typename... Filters, typename... Components>
Test(Filter<Filters...>, Components...)
    -> Test<Filter<Filters...>, Components...>;
 
template<typename... Components>
Test(Components...) -> Test<Components...>;
 
template<typename... Components>
class Query {
  public:
    template<typename T>
    using QueryTypeTraits = _traits::query::QueryTypeTraits<T>;
 
    template<typename T>
    using ComponentStorageType = typename QueryTypeTraits<T>::StorageType;
 
    using QueryComponents =
        std::vector<std::tuple<ComponentStorageType<Components>...>>;
 
    Query(World* world) : m_world(world) {
        prepare_query();
    }
 
    static ComponentMask compute_mask() {
        ComponentMask mask;
        (add_component_to_mask<Components>(mask), ...);
        return mask;
    }
 
    class Iterator {
      public:
        using iterator_category = std::forward_iterator_tag;
        using value_type =
            std::tuple<typename QueryTypeTraits<Components>::IterationType...>;
        using difference_type = std::ptrdiff_t;
        using pointer = std::tuple<
            typename QueryTypeTraits<Components>::IterationPointerType...>;
        using reference = value_type;
 
        Iterator(
            typename QueryComponents::iterator current,
            typename QueryComponents::iterator end
        ) :
            m_current(current),
            m_end(end) {}
 
        Iterator& operator++() {
            ++m_current;
            return *this;
        }
 
        reference operator*() const {
            return dereference_tuple(std::index_sequence_for<Components...> {});
        }
 
        bool operator!=(const Iterator& other) const {
            return m_current != other.m_current;
        }
 
      private:
        typename QueryComponents::iterator m_current;
        typename QueryComponents::iterator m_end;
 
        template<size_t... Is>
        reference dereference_tuple(std::index_sequence<Is...>) const {
            return std::tuple<
                typename QueryTypeTraits<Components>::IterationType...>(
                dereference_element<Components>(std::get<Is>(*m_current))...
            );
        }
 
        template<typename T>
        typename QueryTypeTraits<T>::IterationType
        dereference_element(typename QueryTypeTraits<T>::StorageType elem
        ) const {
            return QueryTypeTraits<T>::dereference(elem);
        }
    };
 
    Iterator begin() {
        ensure_up_to_date();
        return Iterator(m_components.begin(), m_components.end());
    }
 
    Iterator end() {
        return Iterator(m_components.end(), m_components.end());
    }
 
    struct Single {
        Single() = default;
 
        Single(const std::tuple<Components*...>& components) :
            m_state(dereference_tuple(components)) {}
 
        inline std::tuple<Components&...> operator*() {
            assert(is_valid() && "Attempted to dereference an invalid Single.");
            return std::get<std::tuple<Components&...>>(m_state);
        }
 
        inline operator bool() const {
            return is_valid();
        }
 
      private:
        friend class Query;
        std::variant<std::monostate, std::tuple<Components&...>> m_state;
 
        template<typename... Ts>
        static inline std::tuple<Ts&...>
        dereference_tuple(const std::tuple<Ts*...>& pointers) {
            return std::apply(
                [](auto*... ptrs) { return std::tie(*ptrs...); },
                pointers
            );
        }
 
        inline bool is_valid() const {
            return std::holds_alternative<std::tuple<Components&...>>(m_state);
        }
    };
 
    struct Record {
        using RecordComponents =
            std::tuple<ComponentStorageType<Components>...>;
 
        Record() = default;
 
        operator bool() const {
            return is_valid();
        }
 
        inline bool is_valid() const {
            return std::holds_alternative<RecordComponents>(m_state);
        }
 
        inline auto operator*() const {
            assert(is_valid() && "Attempted to dereference an invalid Record.");
            return dereference_tuple(std::index_sequence_for<Components...> {});
        }
 
        inline auto operator*() {
            assert(is_valid() && "Attempted to dereference an invalid Record.");
            return dereference_tuple(std::index_sequence_for<Components...> {});
        }
 
      private:
        friend struct Query;
        std::variant<std::monostate, RecordComponents> m_state;
 
        explicit Record(const RecordComponents& components) :
            m_state(components) {}
 
        template<size_t... Is>
        auto dereference_tuple(std::index_sequence<Is...>) {
            auto& components = std::get<RecordComponents>(m_state);
            return std::tuple<decltype(QueryTypeTraits<Components>::dereference(
                std::get<Is>(components)
            ))...>(
                QueryTypeTraits<Components>::dereference(std::get<Is>(components
                ))...
            );
        }
 
        template<size_t... Is>
        auto dereference_tuple(std::index_sequence<Is...>) const {
            const auto& components = std::get<RecordComponents>(m_state);
            return std::tuple<
                const decltype(QueryTypeTraits<Components>::dereference(
                    std::get<Is>(components)
                ))...>(
                QueryTypeTraits<Components>::dereference(std::get<Is>(components
                ))...
            );
        }
 
        template<typename T>
        static auto
        dereference_element(typename QueryTypeTraits<T>::StorageType elem) {
            return QueryTypeTraits<T>::dereference(elem);
        }
    };
 
    inline Record get(Entity entity) {
        auto archetype_it = m_world->m_entity_archetype_map.find(entity);
        if (archetype_it == m_world->m_entity_archetype_map.end()) {
            return {};
        }
 
        World::Archetype* archetype = archetype_it->second;
 
        ComponentMask record_mask = Query<Components...>::compute_mask();
        if (!archetype->has_components(record_mask)) {
            return {};
        }
 
        return Record(World::Archetype::make_component_tuple<Components...>(
            archetype,
            entity
        ));
    }
 
    inline Record get_single() {
        ensure_up_to_date();
 
        if (m_components.size() != 1) {
            return {};
        }
 
        return Record(m_components.at(0));
    }
 
  private:
    World* m_world {nullptr};
    QueryComponents m_components;
    unsigned int m_query_version {0};
 
    void ensure_up_to_date();
 
    void prepare_query();
 
    template<typename Component>
    static void add_component_to_mask(ComponentMask& mask) {
        if constexpr (!_traits::is_optional<Component>::value
                      && !std::is_same_v<Component, Entity>) {
            ComponentId id = TypeIDGenerator::get_type_id<Component>();
            if (id >= mask.size()) {
                mask.resize(id + 1);
            }
            mask.set(id);
        }
    }
 
    template<typename T>
    static decltype(auto) dereference_if_needed(T&& arg) {
        return QueryTypeTraits<std::remove_reference_t<T>>::dereference(
            std::forward<T>(arg)
        );
    }
};
 
class EntityBuilder {
  public:
    EntityBuilder() = delete;
 
    template<typename... Components>
    bool has() const {
        auto it = m_world->m_entity_archetype_map.find(m_id);
        if (it == m_world->m_entity_archetype_map.end()) {
            return false;
        }
        auto archetype = it->second;
        return archetype->has_components<Components...>();
    }
 
    operator Entity() {
        return m_id;
    }
 
    void despawn() {
        m_world->despawn(m_id);
    }
 
    template<typename... Components>
    EntityBuilder& insert(Components&&... components) {
        auto components_tuple =
            std::make_tuple(std::forward<Components>(components)...);
        auto flat_tuple = flatten_tuple(std::move(components_tuple));
 
        // m_world->add_components(m_id, std::forward<Components>(components)...);
        std::apply(
            [this](auto&&... flat_comps) {
                m_world->add_components(
                    m_id,
                    std::forward<decltype(flat_comps)>(flat_comps)...
                );
            },
            flat_tuple
        );
        return *this;
    }
 
    template<typename Component>
    EntityBuilder& remove() {
        m_world->remove_component<Component>(m_id);
        return *this;
    }
 
    template<typename Func>
    EntityBuilder& with_children(Func&& func) {
        EntityBuilder new_builder = m_world->spawn();
        EntityBuilder ret_builder = func(new_builder);
        ret_builder.insert(Parent {m_id});
 
        return *this;
    }
 
    EntityBuilder& add_child(Entity entity) {
        EntityBuilder(m_world, entity).insert(Parent {m_id});
        return *this;
    }
 
    template<typename... Components>
    EntityBuilder& insert_child(Components&&... components) {
        auto child =
            m_world->spawn().insert(std::forward<Components>(components)...);
        add_child(child);
        return *this;
    }
 
  private:
    friend class World;
    friend class EntityCommands;
 
    EntityBuilder(World* world, Entity entity) : m_id(entity), m_world(world) {}
 
    // Used for flattening bundle component
    template<typename Tuple>
    static auto flatten_tuple(Tuple&& t) {
        return flatten_tuple_impl(
            std::forward<Tuple>(t),
            std::make_index_sequence<
                std::tuple_size<std::decay_t<Tuple>>::value> {}
        );
    }
 
    template<typename Tuple, std::size_t... Is>
    static auto flatten_tuple_impl(Tuple&& t, std::index_sequence<Is...>) {
        return std::tuple_cat(
            flatten_element(std::get<Is>(std::forward<Tuple>(t)))...
        );
    }
 
    template<typename T>
    static auto flatten_element(T&& t) {
        if constexpr (_traits::is_bundle_v<T>) {
            return flatten_tuple(std::forward<T>(t).components);
        } else {
            return std::make_tuple(std::forward<T>(t));
        }
    }
 
    World* m_world {nullptr};
    Entity m_id;
};
 
class EntityCommands {
  public:
    template<typename... Components>
    EntityCommands& insert(Components&&... components);
 
    template<typename Component>
    EntityCommands& remove() {
        Entity entity = m_entity;
        // util::commands_add(m_commands, [entity](World& world) {
        //     EntityBuilder(&world, entity).remove<Component>();
        // });
        return *this;
    }
 
    operator Entity() {
        return m_entity;
    }
 
    EntityCommands& add_child(Entity entity);
 
    template<typename... Components>
    EntityCommands& insert_child(Components&&... components);
 
    template<typename Func>
    EntityCommands& with_children(Func&& func);
 
    void despawn();
 
  private:
    friend class Commands;
 
    EntityCommands(Commands& commands, Entity entity) :
        m_commands(commands),
        m_entity(entity) {}
 
    Commands& m_commands;
    Entity m_entity;
};
 
class Command {
  public:
    template<typename F>
    explicit Command(F&& f) :
        m_cmd(std::make_unique<Model<std::decay_t<F>>>(std::forward<F>(f))) {}
 
    Command(const Command&) = delete;
    Command& operator=(const Command&) = delete;
    Command(Command&&) noexcept = default;
    Command& operator=(Command&&) noexcept = default;
 
    void execute(World& world) {
        m_cmd->execute(world);
    }
 
  private:
    struct Concept {
        virtual ~Concept() = default;
        virtual void execute(World& world) = 0;
    };
 
    template<typename F>
    struct Model: Concept {
        F f;
 
        explicit Model(F&& f_) : f(std::move(f_)) {}
 
        void execute(World& world) override {
            f(world);
        }
    };
 
    std::unique_ptr<Concept> m_cmd;
};
 
class Commands {
  public:
    Commands(World& world) : m_world(world) {}
 
    Commands(const Commands&) = delete;
    Commands& operator=(const Commands&) = delete;
    Commands(Commands&&) noexcept = default;
    Commands& operator=(Commands&&) noexcept = delete;
 
    template<typename Func>
    void add(Func&& func) {
        m_commands.emplace_back(std::forward<Func>(func));
    }
 
    EntityCommands spawn() {
        Entity entity = m_world.spawn();
        return EntityCommands(*this, entity);
    }
 
    EntityCommands entity(Entity entity) {
        return EntityCommands(*this, entity);
    }
 
  private:
    friend class World;
 
    void apply() {
        std::vector<Command> commands_to_execute;
        std::swap(commands_to_execute, m_commands);
 
        for (auto& command : commands_to_execute) {
            command.execute(m_world);
        }
    }
 
  private:
    World& m_world;
    std::vector<Command> m_commands;
};
 
template<typename... Components>
EntityCommands& EntityCommands::insert(Components&&... components) {
    m_commands.add([entity = m_entity,
                    tuple_components =
                        std::make_tuple(std::forward<Components>(components)...
                        )](World& world) mutable {
        std::apply(
            [&world, entity](auto&&... comps) {
                EntityBuilder(&world, entity).insert(std::move(comps)...);
            },
            tuple_components
        );
    });
    return *this;
}
 
// template<typename... Components>
// EntityCommands& EntityCommands::insert(Components&&... components) {
//     Entity entity = m_entity;
 
//     std::tuple<std::decay_t<Components>...> components_copy(
//         std::forward<Components>(components)...
//     );
 
//     m_commands.add([entity = m_entity,
//                     components_copy =
//                         std::move(components_copy)](World& world) mutable {
//         std::apply(
//             [&world, entity](auto&&... comps) {
//                 EntityBuilder(&world, entity).insert(std::move(comps)...);
//             },
//             components_copy
//         );
//     });
 
//     return *this;
// }
 
template<typename Func>
EntityCommands& EntityCommands::with_children(Func&& func) {
    m_commands.add([entity = m_entity,
                    func = std::forward<Func>(func)](World& world) mutable {
        EntityBuilder(&world, entity).with_children(std::forward<Func>(func));
    });
 
    return *this;
}
 
template<typename... Components>
EntityCommands& EntityCommands::insert_child(Components&&... components) {
    std::tuple<std::decay_t<Components>...> components_copy(
        std::forward<Components>(components)...
    );
 
    m_commands.add([entity = m_entity,
                    components_copy =
                        std::move(components_copy)](World& world) {
        std::apply(
            [&world, entity](auto&&... comps) {
                EntityBuilder(&world, entity).insert_child(std::move(comps)...);
            },
            components_copy
        );
    });
    return *this;
}
 
inline Commands& World::commands() {
    return *m_commands.get();
}
 
inline void World::execute_commands() {
    m_commands->apply();
}
 
template<typename... Components>
void Query<Components...>::prepare_query() {
    ComponentMask query_mask = Query<Components...>::compute_mask();
 
    m_components.clear();
    for (const auto& archetype : m_world->m_archetypes) {
        if (archetype->m_mask.contains(query_mask)) {
            for (const auto& [entity, index] : archetype->m_entity_to_index) {
                m_components.emplace_back(
                    World::Archetype::make_component_tuple<Components...>(
                        archetype.get(),
                        entity
                    )
                );
            }
        }
    }
    m_query_version = m_world->m_query_version;
}
 
template<typename... Components>
void Query<Components...>::ensure_up_to_date() {
    if (m_query_version != m_world->m_query_version) {
        prepare_query();
    }
}
 
template<typename T>
struct into_system_param {
    static_assert(
        sizeof(T) == -1,
        "into_system_param not specialized for this type"
    );
};
 
template<typename T>
struct into_system_param<T&>: into_system_param<T> {};
 
template<typename T>
struct into_system_param<const T&>: into_system_param<T> {};
 
// Built-in system parameters
 
template<typename T>
struct Local {
    T& operator*() {
        return m_data;
    }
 
  private:
    T m_data;  
};
 
template<typename T>
struct into_system_param<Local<T>> {
    static Local<T> get(World&) {
        return Local<T> {};
    }
};
 
template<>
struct into_system_param<const Time&> {
    static const Time& get(World& world) {
        auto time = world.get_resource<Time>();
        return *time;
    }
};
 
template<typename T>
struct into_system_param<Resource<T>> {
    static Resource<T> get(World& world) {
        return world.get_resource<T>();
    }
};
 
template<typename... Components>
struct into_system_param<Query<Components...>> {
    static Query<Components...> get(World& world) {
        return Query<Components...>(&world);
    }
};
 
template<typename... Components>
struct into_system_param<const Observer<Components...>&> {
    static const Observer<Components...>& get(World& world) {
        return world.observe<Components...>();
    }
};
 
template<>
struct into_system_param<Commands&> {
    static Commands& get(World& world) {
        return world.commands();
    }
};
 
template<typename Tuple>
struct get_system_params_helper;
 
template<typename... Args>
struct get_system_params_helper<std::tuple<Args...>> {
    static auto get(World& world) {
        return std::make_tuple(
            wrap_param<Args>(into_system_param<Args>::get(world))...
        );
    }
 
  private:
    template<typename T, typename ParamT>
    static auto wrap_param(ParamT&& param) {
        if constexpr (std::is_reference_v<ParamT>) {
            return std::ref(param);
        } else {
            return std::forward<ParamT>(param);
        }
    }
};
 
template<typename Tuple>
auto get_system_params(World& world) {
    return get_system_params_helper<Tuple>::get(world);
}
 
}  // namespace vecs
 
#endif