#ifndef SPROUT_INDEX_TUPLE_HPP
#define SPROUT_INDEX_TUPLE_HPP

#include <cstddef>
#include <type_traits>
#include <sprout/config.hpp>

namespace sprout {
	//
	// index_t
	//
	typedef std::ptrdiff_t index_t;

	//
	// index_tuple
	//
	template<sprout::index_t... Indexes>
	struct index_tuple {
	public:
		typedef index_tuple type;
	};

	//
	// make_indexes
	//
	template<typename IndexTupleType>
	inline SPROUT_CONSTEXPR typename IndexTupleType::type make_indexes() {
		return typename IndexTupleType::type();
	}

	namespace detail {
		template<typename IndexTupleType>
		struct make_index_tuple_helper {
		public:
			typedef typename IndexTupleType::type type;
		public:
			static SPROUT_CONSTEXPR type make() {
				return type();
			}
		};
	}	// namespace detail

	//
	// index_range
	//
	namespace detail {
		template<typename IndexTuple, sprout::index_t Next>
		struct index_range_next;
		template<sprout::index_t... Indexes, sprout::index_t Next>
		struct index_range_next<sprout::index_tuple<Indexes...>, Next> {
		public:
			typedef sprout::index_tuple<Indexes..., (Indexes + Next)...> type;
		};

		template<typename IndexTuple, sprout::index_t Next, sprout::index_t Tail>
		struct index_range_next2;
		template<sprout::index_t... Indexes, sprout::index_t Next, sprout::index_t Tail>
		struct index_range_next2<sprout::index_tuple<Indexes...>, Next, Tail> {
		public:
			typedef sprout::index_tuple<Indexes..., (Indexes + Next)..., Tail> type;
		};

		template<sprout::index_t First, sprout::index_t Step, std::size_t N, typename Enable = void>
		struct index_range_impl;
		template<sprout::index_t First, sprout::index_t Step, std::size_t N>
		struct index_range_impl<
			First,
			Step,
			N,
			typename std::enable_if<(N == 0)>::type
		> {
		public:
			typedef sprout::index_tuple<> type;
		};
		template<sprout::index_t First, sprout::index_t Step, std::size_t N>
		struct index_range_impl<
			First,
			Step,
			N,
			typename std::enable_if<(N == 1)>::type
		> {
		public:
			typedef sprout::index_tuple<First> type;
		};
		template<sprout::index_t First, sprout::index_t Step, std::size_t N>
		struct index_range_impl<
			First,
			Step,
			N,
			typename std::enable_if<(N > 1 && N % 2 == 0)>::type
		>
			: public sprout::detail::index_range_next<
				typename sprout::detail::index_range_impl<First, Step, N / 2>::type,
				First + N / 2 * Step
			>
		{};
		template<sprout::index_t First, sprout::index_t Step, std::size_t N>
		struct index_range_impl<
			First,
			Step,
			N,
			typename std::enable_if<(N > 1 && N % 2 == 1)>::type
		>
			: public sprout::detail::index_range_next2<
				typename sprout::detail::index_range_impl<First, Step, N / 2>::type,
				First + N / 2 * Step,
				First + (N - 1) * Step
			>
		{};
	}	// namespace detail
	template<sprout::index_t First, sprout::index_t Last, sprout::index_t Step = 1>
	struct index_range
		: public sprout::detail::make_index_tuple_helper<
			sprout::detail::index_range_impl<
				First,
				Step,
				((Last - First) + (Step - 1)) / Step
			>
		>
	{};

	//
	// index_n
	//
	namespace detail {
		template<typename IndexTuple>
		struct index_n_next;
		template<sprout::index_t... Indexes>
		struct index_n_next<sprout::index_tuple<Indexes...>> {
		public:
			typedef sprout::index_tuple<Indexes..., Indexes...> type;
		};

		template<typename IndexTuple, sprout::index_t Tail>
		struct index_n_next2;
		template<sprout::index_t... Indexes, sprout::index_t Tail>
		struct index_n_next2<sprout::index_tuple<Indexes...>, Tail> {
		public:
			typedef sprout::index_tuple<Indexes..., Indexes..., Tail> type;
		};

		template<sprout::index_t I, std::size_t N, typename Enable = void>
		struct index_n_impl;
		template<sprout::index_t I, std::size_t N>
		struct index_n_impl<
			I,
			N,
			typename std::enable_if<(N == 0)>::type
		> {
		public:
			typedef sprout::index_tuple<> type;
		};
		template<sprout::index_t I, std::size_t N>
		struct index_n_impl<
			I,
			N,
			typename std::enable_if<(N == 1)>::type
		> {
		public:
			typedef sprout::index_tuple<I> type;
		};
		template<sprout::index_t I, std::size_t N>
		struct index_n_impl<
			I,
			N,
			typename std::enable_if<(N > 1 && N % 2 == 0)>::type
		>
			: public sprout::detail::index_n_next<
				typename sprout::detail::index_n_impl<I, N / 2>::type
			>
		{};
		template<sprout::index_t I, std::size_t N>
		struct index_n_impl<
			I,
			N,
			typename std::enable_if<(N > 1 && N % 2 == 1)>::type
		>
			: public sprout::detail::index_n_next2<
				typename sprout::detail::index_n_impl<I, N / 2>::type,
				I
			>
		{};
	}	// namespace detail
	template<sprout::index_t I, std::size_t N>
	struct index_n
		: public sprout::detail::make_index_tuple_helper<
			sprout::detail::index_n_impl<I, N>
		>
	{};

	//
	// pack_indexes
	//
	template<typename... Args>
	struct pack_indexes
		: public sprout::detail::make_index_tuple_helper<
			sprout::index_range<0, sizeof...(Args)>
		>
	{};
}	// namespace sprout

#endif	// #ifndef SPROUT_INDEX_TUPLE_HPP