#include <const_vector.hpp>

#include <test.hpp>
#include "test_params.h"

constexpr test_suite tests = define_tests("Assignment")
		("const_vector::operator=(const const_vector& other)", []() constexpr {

			REPEAT_FOR_TYPES_N(([]<typename T, std::size_t N, typename Ctx>() {

				cc::const_vector original(Ctx::template value<"arr">);

				decltype(original) v1;
				cc::const_vector<T, get_test_param<"capacity">()> v2;
				cc::const_vector<T, c_arr_len(Ctx::template value<"arr">) - 1> too_small;

				v1 = original;
				v2 = original;
				ASSERT_TYPE_NUM_THROWS((too_small = original), std::invalid_argument, T, N);

				ASSERT_TYPE_NUM(std::ranges::equal(v1, Ctx::template value<"arr">), T, N);
				ASSERT_TYPE_NUM(std::ranges::equal(v2, Ctx::template value<"arr">), T, N);
				ASSERT_TYPE_NUM(std::ranges::equal(original, Ctx::template value<"arr">), T, N);

				return TEST_PASS();
			}), 2, int, char, const char *, TestObj);

			return TEST_PASS();
		}, EvalFlag::RUNTIME_CONSTEVAL)
		("const_vector::operator=(const_vector&& other)", []() constexpr {

			REPEAT_FOR_TYPES_N(([]<typename T, std::size_t N, typename Ctx>() {

				cc::const_vector original1(Ctx::template value<"arr">);
				cc::const_vector original2(Ctx::template value<"arr">);
				cc::const_vector original3(Ctx::template value<"arr">);

				decltype(original1) v1;
				cc::const_vector<T, test_params<"capacity", Ctx>> v2;
				cc::const_vector<T, c_arr_len(Ctx::template value<"arr">) - 1> too_small;

				v1 = force_move(original1);
				v2 = force_move(original2);
				ASSERT_TYPE_NUM_THROWS((too_small = force_move(original3)), std::invalid_argument, T, N);

				ASSERT_TYPE_NUM(std::ranges::equal(v1, Ctx::template value<"arr">), T, N);
				ASSERT_TYPE_NUM(std::ranges::equal(v2, Ctx::template value<"arr">), T, N);

				return TEST_PASS();
			}), 2, int, char, const char *, TestObj);

			return TEST_PASS();
		}, EvalFlag::RUNTIME_CONSTEVAL)
		("const_vector::operator=(const value_type (&array)[])", []() constexpr {

			REPEAT_FOR_TYPES_N(([]<typename T, std::size_t N, typename Ctx>() {

				std::remove_cvref_t<decltype(Ctx::template value<"arr">)> arr = {};
				std::copy(std::begin(Ctx::template value<"arr">), std::end(Ctx::template value<"arr">), std::begin(arr));

				cc::const_vector<T, c_arr_len(arr)> v1;
				cc::const_vector<T, test_params<"capacity", Ctx>> v2;
				cc::const_vector<T, c_arr_len(Ctx::template value<"arr">) - 1> too_small;

				v1 = arr;
				v2 = arr;
				ASSERT_TYPE_NUM_THROWS((too_small = arr), std::invalid_argument, T, N);

				ASSERT_TYPE_NUM(std::ranges::equal(v1, Ctx::template value<"arr">), T, N);
				ASSERT_TYPE_NUM(std::ranges::equal(v2, Ctx::template value<"arr">), T, N);
				ASSERT_TYPE_NUM(std::ranges::equal(arr, Ctx::template value<"arr">), T, N);

				return TEST_PASS();
			}), 2, int, char, const char *, TestObj);

			return TEST_PASS();
		}, EvalFlag::RUNTIME_CONSTEVAL)
		("const_vector::operator=(std::initializer_list<value_type> values)", []() constexpr {

			REPEAT_FOR_TYPES_N(([]<typename T, std::size_t N, typename Ctx>() {

				cc::const_vector<T, test_params<"ilist", Ctx>.size()> v1;
				cc::const_vector<T, test_params<"capacity", Ctx>> v2;
				cc::const_vector<T, test_params<"ilist", Ctx>.size() - 1> too_small;

				v1 = test_params<"ilist", Ctx>;
				v2 = test_params<"ilist", Ctx>;
				ASSERT_TYPE_NUM_THROWS((too_small = test_params<"ilist", Ctx>), std::invalid_argument, T, N);

				ASSERT_TYPE_NUM(std::ranges::equal(v1, test_params<"ilist", Ctx>), T, N);
				ASSERT_TYPE_NUM(std::ranges::equal(v2, test_params<"ilist", Ctx>), T, N);

				return TEST_PASS();
			}), 2, int, char, const char *, TestObj);

			return TEST_PASS();
		}, EvalFlag::RUNTIME_CONSTEVAL)

		("const_vector::assign(size_type count, const value_type& value)", []() constexpr {

			REPEAT_FOR_TYPES_N(([]<typename T, std::size_t N, typename Ctx>() constexpr {

				std::remove_cvref_t<decltype(test_params<"value", Ctx>)> value = test_params<"value", Ctx>;

				cc::const_vector v1(test_params<"arr", Ctx>);
				cc::const_vector v2(test_params<"arr", Ctx>);

				auto count1 = v1.size();
				auto count2 = v2.size() / 2;

				v1.assign(count1, value);
				v2.assign(count2, value);

				ASSERT_TYPE_NUM(v1.size() == count1, T, N);
				ASSERT_TYPE_NUM(v2.size() == count2, T, N);
				ASSERT_TYPE_NUM(std::ranges::all_of(v1, [value](auto&& e) { return e == value; }), T, N);
				ASSERT_TYPE_NUM(std::ranges::all_of(v1, [value](auto&& e) { return e == value; }), T, N);

				ASSERT_TYPE_NUM((value == test_params<"value", Ctx>), T, N);

				return TEST_PASS();
			}), 2, int, char, const char*, TestObj);

			return TEST_PASS();
		}, EvalFlag::RUNTIME_CONSTEVAL)
		/*("const_vector::assign(InputIt first, InputIt last)", []() constexpr {

			REPEAT_FOR_TYPES_N(([]<typename T, std::size_t n, typename params>() constexpr {
				constexpr std::size_t N = n+1;
				cc::const_vector<T, test_defs::get<T>::template arr_len<N>()> v1;
				cc::const_vector<T, test_defs::get<T>::template il_len<N>()> v2;
				cc::const_vector<T, test_defs::get<T>::template il_len<N>()> v3;
				cc::const_vector<T, test_defs::get<T>::template arr_len<N>() - 1> v4;

				std::vector<T> container = test_defs::get<T>::template i_list<N>;

				v1.assign(std::begin(test_defs::get<T>::template arr<N>), std::end(test_defs::get<T>::template arr<N>));
				v2.assign(container.begin(), container.end());
				v3.assign(container.begin(), std::next(container.begin(), test_defs::get<T>::template il_len<N>() / 2));

				ASSERT_TYPE_NUM_THROWS(
						(v4.assign(std::begin(test_defs::get<T>::template arr<N>),
						           std::end(test_defs::get<T>::template arr<N>))), std::invalid_argument, T, N);

				ASSERT_TYPE_NUM_VEC_ARR_EQ(v1, test_defs::get<T>::template arr<N>, T, N);
				ASSERT_TYPE_NUM(v1.size() == test_defs::get<T>::template arr_len<N>(), T, N);
				ASSERT_TYPE_NUM_VEC_ARR_EQ(v2, container, T, N);
				ASSERT_TYPE_NUM(v2.size() == container.size(), T, N);
				ASSERT_TYPE_NUM_VEC_ARR_EQ(v3, container, T, N);
				ASSERT_TYPE_NUM(v3.size() == container.size() / 2, T, N);

				return TEST_PASS();
			}), 3, int, char, const char *, TestStruct);

			return TEST_PASS();
		}, EvalFlag::RUNTIME_CONSTEVAL)
		("const_vector::assign(std::initializer_list<value_type> values)", []() constexpr {

			REPEAT_FOR_TYPES_N(([]<typename T, std::size_t N, typename Ctx>() constexpr {

				cc::const_vector<T, (test_params<"ilist", Ctx>).size()> v1;
				cc::const_vector<T, (test_params<"ilist", Ctx>).size() - 1> v2;

				v1.assign(test_params<"ilist", Ctx>);

				ASSERT_TYPE_NUM_VEC_ARR_EQ(v1, (test_params<"ilist", Ctx>), T, N);
				ASSERT_TYPE_NUM((v1.size() == test_params<"ilist", Ctx>.size()), T, N);

				ASSERT_TYPE_NUM_THROWS(v2.assign(test_params<"ilist", Ctx>), std::invalid_argument, T, N);

				return TEST_PASS();
			}), 2, int, char, const char *, TestObj);

			return TEST_PASS();
		}, EvalFlag::RUNTIME_CONSTEVAL)*/;

int main() {
	return tests.run();
}