#ifndef PFOR_PFOR_EXPRESSION_SUBEXPRESSION_H
#define PFOR_PFOR_EXPRESSION_SUBEXPRESSION_H

#include <tuple>

#include "../expression/operators.h"

namespace pfor {
namespace expr {

template<typename> struct SubExpressionImpl;

template<template<typename...> class P, typename Expr, typename... Exprs>
struct SubExpressionImpl<P<Expr, Exprs...>> {
	using type = CommaMerger<Expr, typename SubExpressionImpl<P<Exprs...>>::type>;
};

template<template<typename...> class P, typename Expr>
struct SubExpressionImpl<P<Expr>> {
	using type = Expression<op::Comma, Expr>;
};

template<typename P>
using SubExpression = typename SubExpressionImpl<P>::type;


template<typename... Exprs, std::size_t... indices>
decltype(auto) subExpressionImpl(std::tuple<Exprs...>& tuple, std::index_sequence<indices...>) {
	return commaMerger(std::get<indices>(tuple)...);
}

template<typename... Exprs>
decltype(auto) subExpression(std::tuple<Exprs...>& tuple) {
	return subExpressionImpl(tuple, std::make_index_sequence<sizeof...(Exprs)>());
}

template<typename Expr>
decltype(auto) subExpression(std::tuple<Expr>& tuple) {
	return std::get<0>(tuple);
}

template<typename View, typename... Exprs>
decltype(auto) expressionView(Expression<op::Comma, Exprs...>& e) {
	return Expression<op::View<op::Comma>, View, Exprs...>{e};
}

template<typename View, typename Op, typename... Exprs>
decltype(auto) expressionView(Expression<Op, Exprs...>& e) {
	return e;
}

}
}

#endif