ecs/include/ecs/settings/settings.h

#pragma once

#include <ecs/config.h>
#include <ecs/core/mp/list.h>
#include <ecs/core/mp/option_map.h>

#include "./system_storage.h"
#include "./entity_storage.h"
#include "./refresh_parallelism.h"
#include "./scheduler.h"

beg_namespace_ecs_settings
{

    namespace keys
    {
        constexpr decltype(auto) component_signatures = hana::size_c<0>;
        constexpr decltype(auto) system_signatures    = hana::size_c<1>;
        constexpr decltype(auto) system_storage       = hana::size_c<2>;
        constexpr decltype(auto) entity_storage       = hana::size_c<3>;
        constexpr decltype(auto) refresh_parallelism  = hana::size_c<4>;
        constexpr decltype(auto) scheduler            = hana::size_c<5>;
    }

    namespace __impl
    {
        template<typename T_options>
        struct settings_t
        {
        private:
            template<typename T_key, typename T_value>
            constexpr decltype(auto) change(const T_key& key, T_value&& value) const noexcept
            {
                auto new_options = T_options { }.set(key, std::forward<T_value>(value));
                return settings_t<core::mp::decay_t<decltype(new_options)>> { };
            }

            template<typename T_key>
            constexpr decltype(auto) get(const T_key& key) const noexcept
                { return T_options { }.at(key); }

        public: /* getter */
            constexpr decltype(auto) component_signatures() const noexcept
                { return get(keys::component_signatures); }

            constexpr decltype(auto) system_signatures() const noexcept
                { return get(keys::system_signatures); }

            constexpr decltype(auto) system_storage() const noexcept
                { return get(keys::system_storage); }

            constexpr decltype(auto) entity_storage() const noexcept
                { return get(keys::entity_storage); }

            constexpr decltype(auto) refresh_parallelism() const noexcept
                { return get(keys::refresh_parallelism); }

            constexpr decltype(auto) scheduler() const noexcept
                { return get(keys::scheduler); }

        public: /* setter */
            template<typename T>
            constexpr decltype(auto) component_signatures(T t) const noexcept
                { return change(keys::component_signatures, t); }

            template<typename T>
            constexpr decltype(auto) system_signatures(T t) const noexcept
                { return change(keys::system_signatures, t); }

            template<typename T>
            constexpr decltype(auto) system_storage(T t) const noexcept
                { return change(keys::system_storage, t); }

            template<typename T>
            constexpr decltype(auto) entity_storage(T t) const noexcept
                { return change(keys::entity_storage, t); }

            template<typename T>
            constexpr decltype(auto) refresh_parallelism(T t) const noexcept
                { return change(keys::refresh_parallelism, t); }

            template<typename T>
            constexpr decltype(auto) scheduler(T t) const noexcept
                { return change(keys::scheduler, t); }
        };

        struct make_t
        {
            constexpr decltype(auto) operator()() const noexcept
            {
                using namespace ::ecs::core::mp;
                auto options = option_map::make()
                    .add(keys::component_signatures, list::empty)
                    .add(keys::system_signatures,    list::empty)
                    .add(keys::system_storage,       system_storage::tuple)
                    .add(keys::entity_storage,       entity_storage::dynamic<1024>)
                    .add(keys::refresh_parallelism,  refresh_parallelism::enable)
                    .add(keys::scheduler,            scheduler::atomic_counter);
                return settings_t<decay_t<decltype(options)>> { };
            }
        };
    }

    constexpr decltype(auto) make = __impl::make_t { };

}
end_namespace_ecs_settings