#ifndef ALSK_TESTS_COMMON_H
#define ALSK_TESTS_COMMON_H

#include <numeric>
#include <initializer_list>
#include <tuple>
#include <utility>

extern std::size_t _copy;
extern std::size_t _move;

template<typename T>
struct Measure {
	using value_type = T;

	T v;

	Measure() = default;
	explicit Measure(int n): v(n) {}

	Measure(T const& v): v{v} { ++_copy; }
	Measure(T&& v): v{std::move(v)} { ++_move; }
	Measure(Measure const& o): v{o.v} { ++_copy; }
	Measure(Measure&& o): v{std::move(o.v)} { ++_move; }

	Measure& operator=(T const& v) {
		this->v = v;
		++_copy;
		return *this;
	}

	Measure& operator=(T&& v) {
		this->v = std::move(v);
		++_move;
		return *this;
	}

	Measure& operator=(Measure const& o) {
		if(this == &o) return *this;
		this->v = o.v;
		++_copy;
		return *this;
	}

	Measure& operator=(Measure&& o) {
		if(this == &o) return *this;
		this->v = std::move(o.v);
		++_move;
		return *this;
	}

	decltype(auto) begin() const { return v.begin(); }
	decltype(auto) end() const { return v.end(); }
	decltype(auto) size() const { return v.size(); }

	decltype(auto) operator[](std::size_t i) const { return v[i]; }
	decltype(auto) operator[](std::size_t i) { return v[i]; }
};


struct Add {
	template<typename T>
	T operator()(T const& lhs, T const& rhs) { return lhs+rhs; }
};

struct Mult {
	template<typename T>
	T operator()(T const& lhs, T const& rhs) { return lhs*rhs; }
};

struct Div {
	template<typename T>
	T operator()(T const& lhs, T const& rhs) { return lhs/rhs; }
};

struct Sqrt {
	template<typename T>
	T operator()(T const& lhs) { return sqrt(lhs); }
};

template<typename T>
struct MultC {
	T m;

	template<typename U>
	auto operator()(U const& lhs) { return lhs*m; }
};

struct Tupler {
	template<typename... Ts>
	auto operator()(Ts const&... values) { return std::make_tuple(values...); }
};

/* for copy/move count test */
template<typename Vector>
struct MultiplyBy {
	Vector coeffs;

	MultiplyBy() = default;
	MultiplyBy(Vector const& coeffs): coeffs{coeffs} {}
	MultiplyBy(Vector&& coeffs): coeffs{std::move(coeffs)} {}

	int operator()(int v) const {
		return std::accumulate(std::begin(coeffs), std::end(coeffs), v,
			[](int a, int b) { return a*b; });
	}
};

template<typename Vector>
struct Process {
	Vector operator()(int n, int a) const {
		Vector v(n);
		for(int i = 0; i < n; ++i)
			v[i] = a+i;
		return v;
	}
};

template<typename Vector>
struct ProdVect {
	void operator()(int& r, Vector const& a, Vector const& b) const {
		r = 0;
		for(std::size_t i = 0; i < a.size(); ++i)
			r += a[i] * b[i];
	}
};

template<typename Vector>
struct Sum {
	Vector operator()(Vector const& a, Vector const& b) const {
		Vector r(a.size());
		for(std::size_t i = 0; i < a.size(); ++i)
			r[i] = a[i] * b[i];
		return r;
	}
};

#endif