#pragma once

#include <tuple>

#include "concepts.h"

namespace concepts {

template <typename F, typename T, typename... ARGS>
concept Operator = Arithmetic<T>
                && requires(F op, T* f_curr, T* f_next, ARGS... args) {
	F::apply(f_curr, f_next, args...);
};

template <typename F, typename T>
concept Functor = Arithmetic<T>
               && requires(F f, T* f_curr, T output[F::size]) {
	F::observe(f_curr, output);
};

}

template <typename F, typename M, typename... ARGS>
struct Operator {
	M& mask;
	std::tuple<ARGS...> args;

	Operator(F, M& m, ARGS&&... args):
		mask(m),
		args(std::forward<ARGS&&>(args)...) { }

	template <typename U>
	requires concepts::Operator<F,U,ARGS...>
	void operator()(U f_curr[], U f_next[]) {
		std::apply([](auto... args) { F::apply(args...); },
		           std::tuple_cat(std::make_tuple(f_curr, f_next), args));
	}
};

template <typename F, typename M, typename... ARGS>
Operator(F, M&, ARGS&&... args) -> Operator<F,M,ARGS...>;