#pragma once

#include <tuple>
#include <type_traits>
#include <utility>

#include <amdis/common/Index.hpp>
#include <amdis/common/StaticSize.hpp>
#include <amdis/common/TypeTraits.hpp>

namespace AMDiS
{
  namespace Tools
  {
    namespace Impl_
    {
      template <class Functor, class Tuple, std::size_t... I>
      constexpr decltype(auto) apply_impl(Functor&& f, Tuple&& t, std::index_sequence<I...>)
      {
        using std::get;
        return f(get<I>(FWD(t))...);
      }

      template <class Functor, std::size_t I0, std::size_t... I>
      constexpr decltype(auto) apply_indices_impl(Functor&& f, index_t<I0>, std::index_sequence<I...>)
      {
        return f(index_t<I0+I>{}...);
      }
    }  // namespace Impl_

    template <class F, class Tuple>
    constexpr decltype(auto) apply(F&& f, Tuple&& t)
    {
      return Impl_::apply_impl(FWD(f), FWD(t),
          std::make_index_sequence<static_size_v<Tuple>>{});
    }

    template <class Functor, class... Args>
    constexpr decltype(auto) apply_variadic(Functor&& f, Args&&... args)
    {
      return apply(FWD(f), std::forward_as_tuple(args...));
    }

    template <std::size_t N, class Functor>
    constexpr decltype(auto) apply_indices(Functor&& f)
    {
      return Impl_::apply_indices_impl(FWD(f), index_t<0>{},
          std::make_index_sequence<N>{});
    }

    template <class Functor, std::size_t N>
    constexpr decltype(auto) apply_indices(Functor&& f, index_t<N>)
    {
      return Impl_::apply_indices_impl(FWD(f), index_t<0>{},
          std::make_index_sequence<N>{});
    }

    template <class Functor, std::size_t I0, std::size_t I1>
    constexpr decltype(auto) apply_indices(Functor&& f, index_t<I0>, index_t<I1>)
    {
      return Impl_::apply_indices_impl(FWD(f), index_t<I0>{},
          std::make_index_sequence<I1-I0>{});
    }
  }
} // end namespace AMDiS