#pragma once

#include "js_host.h"

template<int ...>         struct seq {};
template<int N, int ...M> struct gen : gen<N - 1, N - 1, M...>  {};
template<int ...N>        struct gen<0, N...> {typedef seq<N...> type;};

template <typename T>  struct identity {typedef T type;};

// indirect apply lambdas

template<typename R, typename ... A , int ...N>
R apply(typename identity<std::function<R(A...)>>::type f, js_State *J, std::tuple<A...>*, seq<N...>)
{
    return f(stack::get<A>(J, N)...);
}
template<typename ... A , int ...N>
void apply(typename identity<std::function<void(A...)>>::type f, js_State *J, std::tuple<A...>*, seq<N...>)
{
    f(stack::get<A>(J, N)...);
}

// indirect apply static

template<typename R, typename ... A , int ...N>
R apply(R(*f)(A...), js_State *J, std::tuple<A...>*, seq<N...>)
{
    return f(stack::get<A>(J, N)...);
}
template<typename ... A , int ...N>
void apply(void(*f)(A...), js_State *J, std::tuple<A...>*, seq<N...>)
{
    f(stack::get<A>(J, N)...);
}

// indirect apply members

template<typename R, typename T, typename ... A , int ...N>
R apply(T * instance, R(T::*f)(A...), js_State *J, std::tuple<A...>*, seq<N...>)
{
    return (instance->*f)(stack::get<A>(J, N)...);
}

template<typename T, typename ... A , int ...N>
void apply(T * instance, void (T::*f)(A...), js_State *J, std::tuple<A...>*, seq<N...>)
{
    (instance->*f)(stack::get<A>(J, N)...);
}

// indirect apply constructor

template<typename T, typename ... A , int ...N>
T * constructor(T *, js_State *J, std::tuple<A...>*, seq<N...>)
{
    return new T(stack::get<A>(J, N)...);
}