#include "linkly.hpp"
using namespace linkly;

#include "linkly.hpp"
using namespace linkly;

// Create a FunctionOperator pipeline
auto pipeline = FunctionOperator<SubscriptOperator<>>{};

// Equivalent explicit template version specifying arity, state, and next operator
auto pipeline = FunctionOperator<0, std::tuple<>, SubscriptOperator<0, std::tuple<>, DefaultEndOperator>>{};

#include "linkly.hpp"
using namespace linkly;

// Provide some arguments; the pipeline collects them internally
pipeline(0, 250, 500)[750, 1000];

#include "linkly.hpp"
using namespace linkly;

// Automatically terminates when pipeline reaches End
auto final_state = pipeline(10, 20)[30, 40, 50]; // returns collected arguments (tuple by default)

#include "linkly.hpp"
using namespace linkly;

auto pipeline = SubscriptOperator<3,
                    FunctionOperator<5,
                        SubscriptOperator<> // 0 = no constraints by default
                    >
                >{};

pipeline[0, 10, 20](30, 40, 50, 60, 70)[80]; // Compiles

pipeline[0, 10](20, 30, 40)[50]; // Doesn't compile

#include "linkly.hpp"
using namespace linkly;

template<typename>
struct FunctionOperatorBase;

template<
    template<std::size_t, typename, typename> class DerivedOperator,
    std::size_t Arity,
    typename Next,
    typename State
>
struct FunctionOperatorBase<DerivedOperator<Arity, Next, State>> {
    using Derived_t = DerivedOperator<Arity, Next, State>;

    template<typename... Args>
    auto operator()(Args&&... args)
        -> std::enable_if_t<
            (Arity == 0 || sizeof...(Args) == Arity),
            decltype(std::declval<Derived_t>().onOperated(std::forward<Args>(args)...))
        >
    {
        return static_cast<Derived_t*>(this)
            ->onOperated(std::forward<Args>(args)...);
    }
};

#include "linkly.hpp"
using namespace linkly;

template<
    std::size_t Arity, // Number of arguments required
    typename Next, // Represents the subsequent structure type
    typename CurrentState // Type of the stored state
>
struct EntityIndexerOperator_: //Operator used for an ECS, for example: insert[entity](component)
    OperatorTraits<EntityIndexerOperator_<Arity, Next, CurrentState>>, // Allows for type introspection 
    SubscriptOperatorBase<EntityIndexerOperator_<Arity, Next, CurrentState>>, // Crtp base for generic operator attributes
    StatefulOperator<CurrentState> // Allows support for State by providing constructor, storage, etc...
{
    using StatefulOperator<CurrentState>::StatefulOperator; // Using the base's constructor
    friend SubscriptOperatorBase<EntityIndexerOperator_<Arity, Next, CurrentState>>; // Allows private implementation for onOperated

private:
    template<typename... Args>
    auto onOperated(Args&&... args) { // hooked function called when the base operator is called.
        // Adds the arguments to the current state using std::tuple_cat()
        auto concat_state_args = std::tuple_cat(
            this->state_,
            std::make_tuple(std::make_tuple(std::forward<Args>(args)...))
        );

        // Checks if the next node is normal or terminal
        if constexpr (is_end_operator<Next>::value) {
            if constexpr (has_onOperated_dummy<Next>::value) // Checks if terminal implements onOperated()
                return Next{ concat_state_args }; // If so, returns the terminal node with the current state 
            else
                return concat_state_args; // Otherwise, returns directly the state as it's raw type (tuple in this case) 
        }
        else
            return Next::template template_type<
                sizeof...(args), // Limits the next node to accepting the same number of arguments
                                 // In this case, we want the number of components to be equal to the number of entities

                typename Next::next_type, // Uses the same typename Next as normal, no change here

                decltype(concat_state_args) // Resolves the type of the current state and sends it
                                            // This allows the next node to store the tuple as a member

            >(std::move(concat_state_args)); // std::move the current state and passes it to the next node via its constructor
    }

     LINKLY_GENERATE_OPERATOR_ALIAS(EntityIndexerOperator, EntityIndexerOperator_);
     // In this case, this generates:
     //    EntityIndexerOperator<{Next operator (default=DefaultEndOperator)}, {State (default=std::tuple<>)}> 
     //    EntityIndexerOperator_n<{arity (default=0)}, {Next operator (default=DefaultEndOperator)}, {State (default=std::tuple<>)}>
};