ecs/include/ecs/core/system/scheduler/atomic_counter.h

#pragma once

#include <ecs/config.h>

beg_namespace_ecs_core_system_scheduler
{

    namespace __impl
    {
        template<typename T_system_tag, typename T_dependencies>
        struct dependencie_item_t
        {
            using system_tag_type   = T_system_tag;
            using dependencies_type = T_dependencies;

            system_tag_type     tag;
            dependencies_type   dependencies;
        };

        template<typename T_system_signature_list, typename T_system_tag_list>
        constexpr decltype(auto) build_dependencie_list(T_system_signature_list ssl, T_system_tag_list stl)
        {
            auto filtered = hana::filter(ssl, [stl](auto& ssig){
                return hana::contains(stl, mp::unwrap(ssig).tag());
            });
            return hana::transform(filtered, [](auto& ssig){
                auto tag  = mp::unwrap(ssig).tag();
                auto deps = hana::filter(mp::unwrap(ssig).dependencies(), [](auto& tag){
                                return hana::contains(T_system_tag_list { }, tag);
                            });
                using tag_type  = mp::decay_t<decltype(tag)>;
                using dep_type  = mp::decay_t<decltype(deps)>;
                using item_type = dependencie_item_t<tag_type, dep_type>;
                return item_type { };
            });
        }

        template<typename T_dependency_list>
        constexpr decltype(auto) get_independent_items(T_dependency_list deps) noexcept
        {
            return hana::filter(deps, [](auto& item){
                return hana::size(item.dependencies) == hana::size_c<0>;
            });
        }
    }

    template<typename T_settings>
    struct atomic_counter
    {
    public:
        using settings_type = T_settings;

    public:
        template<typename T_system_tag_list, typename T_func>
        inline void execute(T_system_tag_list stl, T_func&& func)
        {
            static_assert(tag::system::is_list(stl));
            auto dependencie_list  = __impl::build_dependencie_list((settings_type { }).system_signatures().items, stl);
            auto independent_items = __impl::get_independent_items(dependencie_list);

            std::cout << "dependencie_list" << std::endl;
            hana::for_each(dependencie_list, [](auto& item){
                using system_type = mp::unwrap_t<mp::decay_t<decltype(item.tag)>>;
                std::cout << "  " << type_helper<system_type>::name() << std::endl;
                hana::for_each(item.dependencies, [](auto& tag){
                    std::cout << "    " << type_helper<mp::unwrap_t<mp::decay_t<decltype(tag)>>>::name() << std::endl;
                });
            });

            std::cout << "independent_items" << std::endl;
            hana::for_each(independent_items, [](auto& item){
                using system_type = mp::unwrap_t<mp::decay_t<decltype(item.tag)>>;
                std::cout << "  " << type_helper<system_type>::name() << std::endl;
                hana::for_each(item.dependencies, [](auto& tag){
                    std::cout << "    " << type_helper<mp::unwrap_t<mp::decay_t<decltype(tag)>>>::name() << std::endl;
                });
            });
        }
    };

}
end_namespace_ecs_core_system_scheduler