#include <catch.hpp>
#include "common.h"

#include <pfor/clusters.h>
#include <pfor/expression/operand.h>
#include <pfor/expression/operators.h>

#define N 10

TEST_CASE("Cluster") {
	int a_[N], b_[N], c_[N], d_[N], e_[N], f_[N], g_[N];

	auto a = pfor::Operand<int*, class IDa>(a_);
	auto b = pfor::Operand<int*, class IDb>(b_);
	auto c = pfor::Operand<int*, class IDc>(c_);
	auto d = pfor::Operand<int*, class IDd>(d_);
	auto e = pfor::Operand<int*, class IDe>(e_);
	auto f = pfor::Operand<int*, class IDf>(f_);
	auto g = pfor::Operand<int*, class IDg>(g_);

	using UE0 = decltype(a+b);
	using UE1 = decltype(d = b+c);
	using UE2 = decltype(e = g);
	using UE3 = decltype(b = a);
	using UE4 = decltype(f = f+f);
	using UE5 = decltype(g = f);
	using UE6 = decltype(c = d);
	using UE7 = decltype(g = b);

	using E0 = std::decay_t<decltype(V(UE0))>;
	using E1 = std::decay_t<decltype(V(UE1))>;
	using E2 = std::decay_t<decltype(V(UE1), V(UE2))>;
	using E3 = std::decay_t<decltype(V(UE1), V(UE2), V(UE3))>;
	using E4 = std::decay_t<decltype(V(UE4), V(UE5), V(UE6))>;
	using E5 = std::decay_t<decltype(V(UE1), V(UE2), V(UE4), V(UE6))>;
	using E6 = std::decay_t<decltype(V(UE2), V(UE3), V(UE4), V(UE7), V(UE6))>;

	using S0 = pfor::Pack<UE0>;
	using S1 = pfor::Pack<UE1>;
	using S2 = pfor::Pack<UE1, UE2>;
	using S3 = pfor::Pack<UE1, UE2, UE3>;
	using S4 = pfor::Pack<UE4, UE5, UE6>;
	using S5 = pfor::Pack<UE1, UE2, UE4, UE6>;

	SECTION("SplitComma") {
		TEST(REQUIRE, is_same_v<pfor::expr::SplitComma<E0>, S0>);
		TEST(REQUIRE, is_same_v<pfor::expr::SplitComma<E1>, S1>);
		TEST(REQUIRE, is_same_v<pfor::expr::SplitComma<E2>, S2>);
		TEST(REQUIRE, is_same_v<pfor::expr::SplitComma<E3>, S3>);
		TEST(REQUIRE, is_same_v<pfor::expr::SplitComma<E4>, S4>);
		TEST(REQUIRE, is_same_v<pfor::expr::SplitComma<E5>, S5>);
	}

	SECTION("ReadList") {
		using R0 = pfor::Pack<class IDa, class IDb>;
		using R1 = pfor::Pack<class IDb, class IDc>;
		using R2 = pfor::Pack<class IDb, class IDc, class IDg>;
		using R3 = pfor::Pack<class IDb, class IDc, class IDg, class IDa>;
		using R4 = pfor::Pack<class IDf, class IDf, class IDf, class IDd>;
		using R5 = pfor::Pack<class IDb, class IDc, class IDg, class IDf, class IDf, class IDd>;

		TEST(REQUIRE, is_same_v<pfor::expr::ReadList<pfor::expr::ExpressionTagger<E0>>, R0>);
		TEST(REQUIRE, is_same_v<pfor::expr::ReadList<pfor::expr::ExpressionTagger<E1>>, R1>);
		TEST(REQUIRE, is_same_v<pfor::expr::ReadList<pfor::expr::ExpressionTagger<E2>>, R2>);
		TEST(REQUIRE, is_same_v<pfor::expr::ReadList<pfor::expr::ExpressionTagger<E3>>, R3>);
		TEST(REQUIRE, is_same_v<pfor::expr::ReadList<pfor::expr::ExpressionTagger<E4>>, R4>);
		TEST(REQUIRE, is_same_v<pfor::expr::ReadList<pfor::expr::ExpressionTagger<E5>>, R5>);
	}

	SECTION("WriteList") {
		using W0 = pfor::Pack<>;
		using W1 = pfor::Pack<class IDd>;
		using W2 = pfor::Pack<class IDd, class IDe>;
		using W3 = pfor::Pack<class IDd, class IDe, class IDb>;
		using W4 = pfor::Pack<class IDf, class IDg, class IDc>;
		using W5 = pfor::Pack<class IDd, class IDe, class IDf, class IDc>;

		TEST(REQUIRE, is_same_v<pfor::expr::WriteList<pfor::expr::ExpressionTagger<E0>>, W0>);
		TEST(REQUIRE, is_same_v<pfor::expr::WriteList<pfor::expr::ExpressionTagger<E1>>, W1>);
		TEST(REQUIRE, is_same_v<pfor::expr::WriteList<pfor::expr::ExpressionTagger<E2>>, W2>);
		TEST(REQUIRE, is_same_v<pfor::expr::WriteList<pfor::expr::ExpressionTagger<E3>>, W3>);
		TEST(REQUIRE, is_same_v<pfor::expr::WriteList<pfor::expr::ExpressionTagger<E4>>, W4>);
		TEST(REQUIRE, is_same_v<pfor::expr::WriteList<pfor::expr::ExpressionTagger<E5>>, W5>);
	}

	SECTION("ComparatorUIntToType") {
		TEST(REQUIRE,       pfor::ComparatorUIntToType<pfor::UIntToType<0>, pfor::UIntToType<1>>::value);
		TEST(REQUIRE_FALSE, pfor::ComparatorUIntToType<pfor::UIntToType<0>, pfor::UIntToType<0>>::value);
		TEST(REQUIRE_FALSE, pfor::ComparatorUIntToType<pfor::UIntToType<1>, pfor::UIntToType<0>>::value);
	}

	SECTION("ComparatorUIntPack") {
		TEST(REQUIRE_FALSE, pfor::ComparatorUIntPack<UIntsToPack<>, UIntsToPack<>>::value);
		TEST(REQUIRE_FALSE, pfor::ComparatorUIntPack<UIntsToPack<0>, UIntsToPack<>>::value);
		TEST(REQUIRE_FALSE, pfor::ComparatorUIntPack<UIntsToPack<0, 1>, UIntsToPack<>>::value);
		TEST(REQUIRE_FALSE, pfor::ComparatorUIntPack<UIntsToPack<1>, UIntsToPack<0>>::value);
		TEST(REQUIRE_FALSE, pfor::ComparatorUIntPack<UIntsToPack<1>, UIntsToPack<0, 1, 2>>::value);
		TEST(REQUIRE_FALSE, pfor::ComparatorUIntPack<UIntsToPack<2>, UIntsToPack<0, 1, 2>>::value);

		TEST(REQUIRE,       pfor::ComparatorUIntPack<UIntsToPack<>, UIntsToPack<1>>::value);
		TEST(REQUIRE,       pfor::ComparatorUIntPack<UIntsToPack<0>, UIntsToPack<1>>::value);
		TEST(REQUIRE,       pfor::ComparatorUIntPack<UIntsToPack<0, 1, 2>, UIntsToPack<1>>::value);
		TEST(REQUIRE,       pfor::ComparatorUIntPack<UIntsToPack<0, 1, 2>, UIntsToPack<1, 3>>::value);

		TEST(REQUIRE,       pfor::ComparatorUIntPack<UIntsToPack<1, 2>, UIntsToPack<1, 3>>::value);
	}

	SECTION("ComparatorExpressionInfo") {
		using C0 = pfor::Pack<pfor::UIntToType<0>, UIntsToPack<>, UIntsToPack<>>;
		using C1 = pfor::Pack<pfor::UIntToType<1>, UIntsToPack<>, UIntsToPack<>>;
		using C2 = pfor::Pack<pfor::UIntToType<2>, UIntsToPack<>, UIntsToPack<>>;

		TEST(REQUIRE_FALSE, pfor::ComparatorExpressionInfo<C0, C0>::value);
		TEST(REQUIRE_FALSE, pfor::ComparatorExpressionInfo<C1, C0>::value);
		TEST(REQUIRE_FALSE, pfor::ComparatorExpressionInfo<C1, C1>::value);
		TEST(REQUIRE_FALSE, pfor::ComparatorExpressionInfo<C2, C0>::value);
		TEST(REQUIRE_FALSE, pfor::ComparatorExpressionInfo<C2, C1>::value);
		TEST(REQUIRE_FALSE, pfor::ComparatorExpressionInfo<C2, C2>::value);

		TEST(REQUIRE,       pfor::ComparatorExpressionInfo<C0, C1>::value);
		TEST(REQUIRE,       pfor::ComparatorExpressionInfo<C0, C2>::value);
		TEST(REQUIRE,       pfor::ComparatorExpressionInfo<C1, C2>::value);
	}

	SECTION("ComparatorWritePack") {
		using WP0 = pfor::Pack<pfor::UIntToType<0>, UIntsToPack<>, UIntsToPack<>>;
		using WP1 = pfor::Pack<pfor::UIntToType<0>, UIntsToPack<0>, UIntsToPack<>>;
		using WP2 = pfor::Pack<pfor::UIntToType<0>, UIntsToPack<1>, UIntsToPack<>>;
		using WP3 = pfor::Pack<pfor::UIntToType<0>, UIntsToPack<0, 1, 2>, UIntsToPack<>>;
		using WP4 = pfor::Pack<pfor::UIntToType<0>, UIntsToPack<0, 2>, UIntsToPack<>>;

		TEST(REQUIRE_FALSE, pfor::ComparatorWritePack<WP0, WP0>::value);
		TEST(REQUIRE_FALSE, pfor::ComparatorWritePack<WP1, WP0>::value);
		TEST(REQUIRE_FALSE, pfor::ComparatorWritePack<WP2, WP0>::value);
		TEST(REQUIRE_FALSE, pfor::ComparatorWritePack<WP3, WP1>::value);
		TEST(REQUIRE_FALSE, pfor::ComparatorWritePack<WP4, WP1>::value);
		TEST(REQUIRE_FALSE, pfor::ComparatorWritePack<WP4, WP3>::value);

		TEST(REQUIRE,       pfor::ComparatorWritePack<WP0, WP1>::value);
		TEST(REQUIRE,       pfor::ComparatorWritePack<WP0, WP2>::value);
		TEST(REQUIRE,       pfor::ComparatorWritePack<WP1, WP2>::value);
		TEST(REQUIRE,       pfor::ComparatorWritePack<WP3, WP2>::value);
		TEST(REQUIRE,       pfor::ComparatorWritePack<WP4, WP2>::value);
		TEST(REQUIRE,       pfor::ComparatorWritePack<WP3, WP4>::value);
	}

	SECTION("ExpressionInfo") {
		using EI0 = pfor::Pack<pfor::Pack<pfor::UIntToType<0>, pfor::Pack<>, pfor::Pack<class IDa, class IDb>>>;
		using EI1 = pfor::Pack<pfor::Pack<pfor::UIntToType<0>, pfor::Pack<class IDd>, pfor::Pack<class IDb, class IDc>>>;
		using EI2 = pfor::Pack<
			pfor::Pack<pfor::UIntToType<0>, pfor::Pack<class IDd>, pfor::Pack<class IDb, class IDc>>,
			pfor::Pack<pfor::UIntToType<1>, pfor::Pack<class IDe>, pfor::Pack<class IDg>>
		>;
		using EI3 = pfor::Pack<
			pfor::Pack<pfor::UIntToType<0>, pfor::Pack<class IDd>, pfor::Pack<class IDb, class IDc>>,
			pfor::Pack<pfor::UIntToType<1>, pfor::Pack<class IDe>, pfor::Pack<class IDg>>,
			pfor::Pack<pfor::UIntToType<2>, pfor::Pack<class IDb>, pfor::Pack<class IDa>>
		>;

		TEST(REQUIRE, is_same_v<pfor::expr::ExpressionInfo<S0>, EI0>);
		TEST(REQUIRE, is_same_v<pfor::expr::ExpressionInfo<S1>, EI1>);
		TEST(REQUIRE, is_same_v<pfor::expr::ExpressionInfo<S2>, EI2>);
		TEST(REQUIRE, is_same_v<pfor::expr::ExpressionInfo<S3>, EI3>);
	}

	SECTION("Clusters") {
		using C0 = pfor::Pack<>;
		using C1 = pfor::expr::ExpressionInfo<S1>;
		using C2 = pfor::expr::ExpressionInfo<S2>;
		using C3 = pfor::expr::ExpressionInfo<S3>;
		using C4 = pfor::expr::ExpressionInfo<S4>;
		using C5 = pfor::expr::ExpressionInfo<S5>;

		using CC0 = pfor::Pack<>;
		using CC1 = pfor::Pack<C1>;
		using CC2 = pfor::Pack<C2>;
		using CC3 = pfor::Pack<C3>;
		using CC4 = pfor::Pack<C4>;
		using CC5 = pfor::Pack<C5>;

		using I0 = pfor::Pack<pfor::UIntToType<0>, pfor::Pack<>, pfor::Pack<>>;
		using I1 = pfor::Pack<pfor::UIntToType<1>, pfor::Pack<class IDg, class IDh>, pfor::Pack<class IDh, class IDi>>;
		using I2 = pfor::Pack<pfor::UIntToType<2>, pfor::Pack<class IDd, class IDh>, pfor::Pack<class IDb, class IDh, class IDi>>;
		using I3 = pfor::Pack<pfor::UIntToType<3>, pfor::Pack<class IDi>, pfor::Pack<class IDa, class IDf, class IDg, class IDh, class IDi>>;

		using CC0I1 = pfor::Pack<pfor::Pack<I1>>;
		using CC0I2 = pfor::Pack<pfor::Pack<I2>>;
		using CC1I1 = pfor::Pack<C1, pfor::Pack<I1>>;
		using CC1I2 = pfor::Pack<pfor::PackSortInsert<pfor::ComparatorExpressionInfo, C1, I2>>;
		using CC2I1 = pfor::Pack<pfor::PackSortInsert<pfor::ComparatorExpressionInfo, C2, I1>>;
		using CC2I2 = pfor::Pack<pfor::PackSortInsert<pfor::ComparatorExpressionInfo, C2, I2>>;

		using F0 = UIntsToPack<>;
		using F1 = UIntsToPack<0>;
		using F2 = UIntsToPack<0, 1>;
		using F3 = UIntsToPack<0, 1, 2>;
		using F4 = UIntsToPack<0, 1, 2>;
		using F5 = UIntsToPack<0, 1, 2, 3>;

		using CF0 = pfor::Pack<>;
		using CF1 = pfor::Pack<F1>;
		using CF2 = pfor::Pack<F2>;
		using CF3 = pfor::Pack<F3>;
		using CF4 = pfor::Pack<F4>;
		using CF5 = pfor::Pack<F5>;

		using CF1I1 = pfor::Pack<UIntsToPack<0>, UIntsToPack<1>>;

		// using CE0 = pfor::Pack<>;
		// using CE1 = UIntsToPack<0>;
		// using CE2 = UIntsToPack<0, 1>;
		// using CE3 = UIntsToPack<0, 1, 2>;
		// using CE4 = UIntsToPack<0, 1, 2>;
		// using CE5 = UIntsToPack<0, 1, 2, 3>;

		// using CCE0 = pfor::Pack<>;
		// using CCE1 = pfor::Pack<CE1>;
		// using CCE2 = pfor::Pack<CE2>;
		// using CCE3 = pfor::Pack<CE3>;
		// using CCE4 = pfor::Pack<CE4>;
		// using CCE5 = pfor::Pack<CE5>;

		SECTION("ClusterDepends") {
			TEST(REQUIRE_FALSE, pfor::ClusterDepends<C0, I0>::value);
			TEST(REQUIRE_FALSE, pfor::ClusterDepends<C0, I1>::value);
			TEST(REQUIRE_FALSE, pfor::ClusterDepends<C0, I2>::value);
			TEST(REQUIRE_FALSE, pfor::ClusterDepends<C0, I3>::value);

			TEST(REQUIRE_FALSE, pfor::ClusterDepends<C1, I0>::value);
			TEST(REQUIRE_FALSE, pfor::ClusterDepends<C1, I1>::value);
			TEST(REQUIRE,       pfor::ClusterDepends<C1, I2>::value);
			TEST(REQUIRE_FALSE, pfor::ClusterDepends<C1, I3>::value);

			TEST(REQUIRE_FALSE, pfor::ClusterDepends<C2, I0>::value);
			TEST(REQUIRE,       pfor::ClusterDepends<C2, I1>::value);
			TEST(REQUIRE,       pfor::ClusterDepends<C2, I2>::value);
			TEST(REQUIRE_FALSE, pfor::ClusterDepends<C2, I3>::value);

			TEST(REQUIRE_FALSE, pfor::ClusterDepends<C3, I0>::value);
			TEST(REQUIRE,       pfor::ClusterDepends<C3, I1>::value);
			TEST(REQUIRE,       pfor::ClusterDepends<C3, I2>::value);
			TEST(REQUIRE_FALSE, pfor::ClusterDepends<C3, I3>::value);

			TEST(REQUIRE_FALSE, pfor::ClusterDepends<C4, I0>::value);
			TEST(REQUIRE,       pfor::ClusterDepends<C4, I1>::value);
			TEST(REQUIRE,       pfor::ClusterDepends<C4, I2>::value);
			TEST(REQUIRE,       pfor::ClusterDepends<C4, I3>::value);

			TEST(REQUIRE_FALSE, pfor::ClusterDepends<C5, I0>::value);
			TEST(REQUIRE,       pfor::ClusterDepends<C5, I1>::value);
			TEST(REQUIRE,       pfor::ClusterDepends<C5, I2>::value);
			TEST(REQUIRE,       pfor::ClusterDepends<C5, I3>::value);
		}

		SECTION("ClustersInsert") {
			TEST(REQUIRE, is_same_v<pfor::ClustersInsert<CC0, I1>, CC0I1>);
			TEST(REQUIRE, is_same_v<pfor::ClustersInsert<CC0, I2>, CC0I2>);
			TEST(REQUIRE, is_same_v<pfor::ClustersInsert<CC1, I1>, CC1I1>);
			TEST(REQUIRE, is_same_v<pfor::ClustersInsert<CC1, I2>, CC1I2>);
			TEST(REQUIRE, is_same_v<pfor::ClustersInsert<CC2, I1>, CC2I1>);
			TEST(REQUIRE, is_same_v<pfor::ClustersInsert<CC2, I2>, CC2I2>);
		}

		SECTION("ClusterExpressionIds") {
			TEST(REQUIRE, is_same_v<pfor::ClusterExpressionIds<C0>, F0>);
			TEST(REQUIRE, is_same_v<pfor::ClusterExpressionIds<C1>, F1>);
			TEST(REQUIRE, is_same_v<pfor::ClusterExpressionIds<C2>, F2>);
			TEST(REQUIRE, is_same_v<pfor::ClusterExpressionIds<C3>, F3>);
			TEST(REQUIRE, is_same_v<pfor::ClusterExpressionIds<C4>, F4>);
			TEST(REQUIRE, is_same_v<pfor::ClusterExpressionIds<C5>, F5>);
		}

		SECTION("ClustersExpressionIds") {
			TEST(REQUIRE, is_same_v<pfor::ClustersExpressionIds<CC0>, CF0>);
			TEST(REQUIRE, is_same_v<pfor::ClustersExpressionIds<CC1>, CF1>);
			TEST(REQUIRE, is_same_v<pfor::ClustersExpressionIds<CC2>, CF2>);
			TEST(REQUIRE, is_same_v<pfor::ClustersExpressionIds<CC3>, CF3>);
			TEST(REQUIRE, is_same_v<pfor::ClustersExpressionIds<CC4>, CF4>);
			TEST(REQUIRE, is_same_v<pfor::ClustersExpressionIds<CC5>, CF5>);

			TEST(REQUIRE, is_same_v<pfor::ClustersExpressionIds<CC1I1>, CF1I1>);
		}

		// SECTION("ClusterExpression") {
			// TEST(REQUIRE, is_same_v<pfor::ClusterExpression<S0, F0>, CE0>);
			// TEST(REQUIRE, is_same_v<pfor::ClusterExpression<S1, F1>, CE1>);
			// TEST(REQUIRE, is_same_v<pfor::ClusterExpression<S2, F2>, CE2>);
			// TEST(REQUIRE, is_same_v<pfor::ClusterExpression<S3, F3>, CE3>);
			// TEST(REQUIRE, is_same_v<pfor::ClusterExpression<S4, F4>, CE4>);
			// TEST(REQUIRE, is_same_v<pfor::ClusterExpression<S5, F5>, CE5>);
		// }
//
		// SECTION("ClustersExpression") {
			// using CCE1I1 = pfor::Pack<UIntsToPack<0>, UIntsToPack<1>>;
//
			// TEST(REQUIRE, is_same_v<pfor::ClustersExpression<S0, CF0>, CCE0>);
			// TEST(REQUIRE, is_same_v<pfor::ClustersExpression<S1, CF1>, CCE1>);
			// TEST(REQUIRE, is_same_v<pfor::ClustersExpression<S2, CF2>, CCE2>);
			// TEST(REQUIRE, is_same_v<pfor::ClustersExpression<S3, CF3>, CCE3>);
			// TEST(REQUIRE, is_same_v<pfor::ClustersExpression<S4, CF4>, CCE4>);
			// TEST(REQUIRE, is_same_v<pfor::ClustersExpression<S5, CF5>, CCE5>);
//
			// TEST(REQUIRE, is_same_v<pfor::ClustersExpression<S5, CF1I1>, CCE1I1>);
		// }

		SECTION("ClustersGen") {
			using CG0 = pfor::Pack<UIntsToPack<0>>;
			using CG1 = pfor::Pack<UIntsToPack<0>>;
			using CG2 = pfor::Pack<UIntsToPack<0>, UIntsToPack<1>>;
			using CG3 = pfor::Pack<UIntsToPack<0, 2>, UIntsToPack<1>>;
			using CG4 = pfor::Pack<UIntsToPack<0, 1>, UIntsToPack<2>>;
			using CG5 = pfor::Pack<UIntsToPack<0, 3>, UIntsToPack<1>, UIntsToPack<2>>;
			using CG6 = pfor::Pack<UIntsToPack<0, 1, 3>, UIntsToPack<2>, UIntsToPack<4>>;

			TEST(REQUIRE, is_same_v<typename pfor::ClustersGen<E0>::type, CG0>);
			TEST(REQUIRE, is_same_v<typename pfor::ClustersGen<E1>::type, CG1>);
			TEST(REQUIRE, is_same_v<typename pfor::ClustersGen<E2>::type, CG2>);
			TEST(REQUIRE, is_same_v<typename pfor::ClustersGen<E3>::type, CG3>);
			TEST(REQUIRE, is_same_v<typename pfor::ClustersGen<E4>::type, CG4>);
			TEST(REQUIRE, is_same_v<typename pfor::ClustersGen<E5>::type, CG5>);

			TEST(REQUIRE, is_same_v<typename pfor::ClustersGen<E6>::type, CG6>);
		}
	}
}