#define PK_IMPL_ITER
#define PK_IMPL_MEM
#define PK_IMPL_ARR

#include <cstring>
#include <utility>

#include "../pkarr.h"

// TODO might be able to define a "test" class that inherits from a given
//  `pk_arr_t<T>` to make some of this testing more streamlined.
// Spinup in ctor, check bkt in dtor, log fn calls, etc.

void
test_spinup(struct pk_membucket **bkt)
{
	*bkt = pk_mem_bucket_create("test", 1024 * 1024, PK_MEMBUCKET_FLAG_NONE);
}

void
test_teardown(struct pk_membucket **bkt)
{
	pk_mem_bucket_destroy(*bkt);
	*bkt = NULL;
}

int main(int argc, char *argv[])
{
	(void)argc;
	(void)argv;
	struct pk_membucket *bkt = {};
	uint8_t val1 = 69;
	uint8_t val2 = 117;

	/* template
	{
		test_spinup(&bkt);

		test_teardown(&arr, &bkt);
	}
	*/

	fprintf(stdout, "[%s] Begin\n\n", __FILE__);

	fprintf(stdout, "[%s] Starting append test\n", __FILE__);
	test_spinup(&bkt);
	{
		pk_arr_t<uint8_t> arr(bkt);

		uint8_t c = 255;
		pk_arr_append_t(&arr, c);

		if (arr.bkt == NULL) exit(1);
		if (arr.data == NULL) exit(1);
		if (arr.reserved == 0) exit(1);
		if (arr.stride != sizeof(uint8_t)) exit(1);
		if (arr.alignment != alignof(uint8_t)) exit(1);
		if (arr.next != 1) exit(1);
		if (arr[0] != c) exit(1);

		fprintf(stdout, "[%s] parameterized bkt ctor + operator[]\n", __FILE__);

		pk_arr_reset(&arr);
	}
	if (bkt->alloc_count != 0) exit(1);
	fprintf(stdout, "[%s] dtor called.\n", __FILE__);
	fprintf(stdout, "[%s] Ending append test\n\n", __FILE__);
	test_teardown(&bkt);

	// copy ctor
	fprintf(stdout, "[%s] Starting copy ctor test\n", __FILE__);
	test_spinup(&bkt);
	{
		pk_arr_t<uint8_t> arr1(bkt);
		pk_arr_append_t(&arr1, val1);

		// copy
		pk_arr_t<uint8_t> arr2{arr1};

		if (arr1[0] != val1) exit(1);
		if (arr2[0] != val1) exit(1);

		pk_arr_reset(&arr1);
		pk_arr_reset(&arr2);
	}
	if (bkt->alloc_count != 0) exit(1);
	fprintf(stdout, "[%s] dtor called.\n", __FILE__);
	fprintf(stdout, "[%s] Ending copy ctor test\n\n", __FILE__);
	test_teardown(&bkt);

	// move ctor
	fprintf(stdout, "[%s] Starting move ctor test\n", __FILE__);
	test_spinup(&bkt);
	{
		pk_arr_t<uint8_t> arr1(bkt);
		pk_arr_append_t(&arr1, val1);

		// move
		pk_arr_t<uint8_t> arr2{std::move(arr1)};

		// if (arr1[0] == val1) exit(1);
		if (arr2[0] != val1) exit(1);

		pk_arr_reset(&arr1);
		pk_arr_reset(&arr2);
	}
	if (bkt->alloc_count != 0) exit(1);
	fprintf(stdout, "[%s] dtor called.\n", __FILE__);
	fprintf(stdout, "[%s] Ending move ctor test\n\n", __FILE__);
	test_teardown(&bkt);

	// copy assignment
	fprintf(stdout, "[%s] Starting copy assignment test\n", __FILE__);
	test_spinup(&bkt);
	{
		pk_arr_t<uint8_t> arr1(bkt);
		pk_arr_append_t(&arr1, val1);
		pk_arr_t<uint8_t> arr2(bkt);
		pk_arr_append_t(&arr2, val2);

		// copy
		arr1 = arr2;

		if (arr1[0] != val2) exit(1);
		if (arr2[0] != val2) exit(1);

		pk_arr_reset(&arr1);
		pk_arr_reset(&arr2);
	}
	if (bkt->alloc_count != 0) exit(1);
	fprintf(stdout, "[%s] dtor called.\n", __FILE__);
	fprintf(stdout, "[%s] Ending copy assignment test\n\n", __FILE__);
	test_teardown(&bkt);

	// move assignment
	fprintf(stdout, "[%s] Starting move assignment test\n", __FILE__);
	test_spinup(&bkt);
	{
		pk_arr_t<uint8_t> arr1(bkt);
		pk_arr_append_t(&arr1, val1);
		pk_arr_t<uint8_t> arr2(bkt);
		pk_arr_append_t(&arr2, val2);

		// move
		arr1 = std::move(arr2);

		if (arr1[0] != val2) exit(1);
		// if (arr2[0] != val1) exit(1);

		pk_arr_reset(&arr1);
		pk_arr_reset(&arr2);
	}
	if (bkt->alloc_count != 0) exit(1);
	fprintf(stdout, "[%s] dtor called.\n", __FILE__);
	fprintf(stdout, "[%s] Ending move assignment test\n\n", __FILE__);
	test_teardown(&bkt);

	test_spinup(&bkt);
	fprintf(stdout, "[%s] Starting iter forward test\n", __FILE__);
	{
		bool res;
		uint8_t u, u2;
		pk_arr_t<uint8_t> arr(bkt);
		for (u = 4; u > 0; --u) {
			u2 = u - 1;
			pk_arr_append_t(&arr, u2);
		}

		struct pk_iter_t<uint8_t> it;
		res = pk_arr_iter_begin(&arr, &it);
		if (res == false) exit(1);
		if (it.id.arr.i != 0) exit(1);
		if (*it != 3) exit(1);
		PK_LOGV_INF("iter.data: %p iter.val: %i\n", it.data, *it);

		res = pk_arr_iter_increment(&arr, &it);
		if (res == false) exit(1);
		if (it.id.arr.i != 1) exit(1);
		if (*it != 2) exit(1);
		PK_LOGV_INF("iter.data: %p iter.val: %i\n", it.data, *it);

		res = pk_arr_iter_increment(&arr, &it);
		if (res == false) exit(1);
		if (it.id.arr.i != 2) exit(1);
		if (*it != 1) exit(1);
		PK_LOGV_INF("iter.data: %p iter.val: %i\n", it.data, *it);

		res = pk_arr_iter_increment(&arr, &it);
		if (res == false) exit(1);
		if (it.id.arr.i != 3) exit(1);
		if (*it != 0) exit(1);
		PK_LOGV_INF("iter.data: %p iter.val: %i\n", it.data, *it);

		res = pk_arr_iter_increment(&arr, &it);
		if (res == true) exit(1);

	}
	fprintf(stdout, "[%s] Ending iter forward test\n\n", __FILE__);
	test_teardown(&bkt);

	test_spinup(&bkt);
	fprintf(stdout, "[%s] Starting iter reverse test\n", __FILE__);
	{
		bool res;
		uint8_t u, u2;
		pk_arr_t<uint8_t> arr(bkt);
		for (u = 4; u > 0; --u) {
			u2 = u - 1;
			pk_arr_append_t(&arr, u2);
		}

		struct pk_iter_t<uint8_t> it;
		res = pk_arr_iter_end(&arr, &it);
		if (res == false) exit(1);
		if (it.id.arr.i != 3) exit(1);
		if (*it != 0) exit(1);
		PK_LOGV_INF("iter.data: %p iter.val: %i\n", it.data, *it);

		res = pk_arr_iter_decrement(&arr, &it);
		if (res == false) exit(1);
		if (it.id.arr.i != 2) exit(1);
		if (*it != 1) exit(1);
		PK_LOGV_INF("iter.data: %p iter.val: %i\n", it.data, *it);

		res = pk_arr_iter_decrement(&arr, &it);
		if (res == false) exit(1);
		if (it.id.arr.i != 1) exit(1);
		if (*it != 2) exit(1);
		PK_LOGV_INF("iter.data: %p iter.val: %i\n", it.data, *it);

		res = pk_arr_iter_decrement(&arr, &it);
		if (res == false) exit(1);
		if (it.id.arr.i != 0) exit(1);
		if (*it != 3) exit(1);
		PK_LOGV_INF("iter.data: %p iter.val: %i\n", it.data, *it);

		res = pk_arr_iter_decrement(&arr, &it);
		if (res == true) exit(1);

	}
	fprintf(stdout, "[%s] Ending iter reverse test\n\n", __FILE__);
	test_teardown(&bkt);

	fprintf(stdout, "[%s] End\n", __FILE__);

	return 0;
}