#define PK_IMPL_MEM

#include "../pkmem.h"

#define PK_IMPL_TST
#include "../pktst.h"

#define PK_IMPL_FUNCINSTR
#include "../pkfuncinstr.h"

#include <stdio.h>
#include <string.h>

struct mem_test {
	struct pk_membucket *bkt1;
	struct pk_membucket *bkt2;
} mt;

void spinup() {
	mt.bkt1 = pk_mem_bucket_create("bkt1", 1024, false);
	mt.bkt2 = pk_mem_bucket_create("bkt2", 1024, false);
}

void spinup_w_instr() {
	pk_funcinstr_init();
	spinup();
}

void teardown() {
	pk_mem_bucket_destroy(mt.bkt1);
	pk_mem_bucket_destroy(mt.bkt2);
	pk_funcinstr_teardown();
}

int main(int argc, char *argv[])
{
	(void)argc;
	(void)argv;

	// pk_new_base
	{
		spinup_w_instr();
		pk_mem_bucket_set_client_mem_bucket(mt.bkt1);
		char *some_dang_string = (char*)pk_new_base(64, alignof(char*));
		memset(some_dang_string, '\0', 64);
		fprintf(stdout, "some_dang_string: \"%s\": %p\n", some_dang_string, (void *)some_dang_string);
		pk_delete_base(some_dang_string, 64);
		teardown();
	}

	/* template
	{
		spinup();
		teardown();
	}
	*/

	// zero-length alloc
	{
		spinup_w_instr();
		char *zero_length_string;
		char *three_length_string;

		zero_length_string = pk_new_bkt(0, 0, mt.bkt1);
		three_length_string = pk_new_bkt(3, 0, mt.bkt1);
		three_length_string[0] = '1';
		three_length_string[1] = '2';
		three_length_string[2] = '\0';

#ifdef PK_MEMORY_FORCE_MALLOC
		PK_TEST_ASSERT_NEQ_EXIT(NULL, zero_length_string);
		PK_TEST_ASSERT_EQ_EXIT(2, strlen(three_length_string));
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->alloc_count);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->head);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
		pk_delete(zero_length_string, 0, mt.bkt1);
#else
		PK_TEST_ASSERT_EQ_EXIT(NULL, zero_length_string);
		PK_TEST_ASSERT_EQ_EXIT(2, strlen(three_length_string));
		PK_TEST_ASSERT_EQ_EXIT(1, mt.bkt1->alloc_count);
		PK_TEST_ASSERT_EQ_EXIT(3, mt.bkt1->head);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
#endif

		pk_delete(three_length_string, 3, mt.bkt1);
		PK_LOGV_INF("%s: %s\n", __FILE__, "handles zero-length alloc");
		teardown();
	}

	// expand buckets
	{
		spinup_w_instr();

		struct pk_memblock *blk;

		void *ptrs[16];

		for (size_t i = 0; i < 16; ++i) {
			ptrs[i] = pk_new_bkt(7, 8, mt.bkt1);
		}

		blk = mt.bkt1->blocks;

#ifdef PK_MEMORY_FORCE_MALLOC
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->alloc_count);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->head);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
		PK_TEST_ASSERT_EQ_EXIT(16, mt.bkt1->block_capacity);
		PK_TEST_ASSERT_EQ_EXIT(blk, mt.bkt1->blocks);
#else
		PK_TEST_ASSERT_EQ_EXIT(16, mt.bkt1->alloc_count);
		PK_TEST_ASSERT_EQ_EXIT((8*16)-1, mt.bkt1->head);
		PK_TEST_ASSERT_EQ_EXIT(15, mt.bkt1->block_head_r);
		PK_TEST_ASSERT_EQ_EXIT(16, mt.bkt1->block_capacity);
		PK_TEST_ASSERT_EQ_EXIT(blk, mt.bkt1->blocks);
#endif

		void *ptr2 = pk_new_bkt(7, 8, mt.bkt1);

#ifdef PK_MEMORY_FORCE_MALLOC
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->alloc_count);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->head);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
		PK_TEST_ASSERT_EQ_EXIT(16, mt.bkt1->block_capacity);
		PK_TEST_ASSERT_EQ_EXIT(blk, mt.bkt1->blocks);
#else
		PK_TEST_ASSERT_EQ_EXIT(17, mt.bkt1->alloc_count);
		PK_TEST_ASSERT_EQ_EXIT((8*17)-1, mt.bkt1->head);
		PK_TEST_ASSERT_EQ_EXIT(16, mt.bkt1->block_head_r);
		PK_TEST_ASSERT_EQ_EXIT(17, mt.bkt1->block_capacity);
		PK_TEST_ASSERT_NEQ_EXIT(blk, mt.bkt1->blocks);
#endif

		blk = mt.bkt1->blocks;

		void *ptr3 = pk_new_bkt(7, 8, mt.bkt1);

#ifdef PK_MEMORY_FORCE_MALLOC
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->alloc_count);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->head);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
		PK_TEST_ASSERT_EQ_EXIT(16, mt.bkt1->block_capacity);
		PK_TEST_ASSERT_EQ_EXIT(blk, mt.bkt1->blocks);
#else
		PK_TEST_ASSERT_EQ_EXIT(18, mt.bkt1->alloc_count);
		PK_TEST_ASSERT_EQ_EXIT((8*18)-1, mt.bkt1->head);
		PK_TEST_ASSERT_EQ_EXIT(17, mt.bkt1->block_head_r);
		PK_TEST_ASSERT_EQ_EXIT(18, mt.bkt1->block_capacity);
		PK_TEST_ASSERT_NEQ_EXIT(blk, mt.bkt1->blocks);
#endif

		pk_delete(ptr3, 7, mt.bkt1);
		pk_delete(ptr2, 7, mt.bkt1);
		for (int i = 15; i >= 0; --i) {
			pk_delete(ptrs[i], 7, mt.bkt1);
		}

		PK_LOGV_INF("%s: %s\n", __FILE__, "handles block growth");
		teardown();
	}

	// expand buckets
	{
		// spinup_w_instr();
		spinup();

		/*
		 * [00-47] (48) ptr1
		 * [48-XX] ( 1) HEAD
		 */
		void *ptr1 = pk_new_bkt(48, 1, mt.bkt1);
		(void)ptr1;

#ifdef PK_MEMORY_FORCE_MALLOC
		// PK_TEST_ASSERT_EQ_EXIT(ptr1, (void*)&mt.bkt1->data[0]);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->alloc_count);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->head);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->debug_head_l);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->debug_head_r);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_l);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
#else
		PK_TEST_ASSERT_EQ_EXIT(ptr1, (void*)&mt.bkt1->data[0]);
		PK_TEST_ASSERT_EQ_EXIT(1, mt.bkt1->alloc_count);
		PK_TEST_ASSERT_EQ_EXIT(48, mt.bkt1->head);
		PK_TEST_ASSERT_EQ_EXIT(1, mt.bkt1->debug_head_l);
		PK_TEST_ASSERT_EQ_EXIT(1, mt.bkt1->debug_head_r);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_l);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
#endif

		/*
		 * [00-47] (48) ptr1
		 * [   48] ( 1) ptr2
		 * [49-XX] ( 1) HEAD
		 */
		void *ptr2 = pk_new_bkt(1, 1, mt.bkt1);

#ifdef PK_MEMORY_FORCE_MALLOC
		// PK_TEST_ASSERT_EQ_EXIT(ptr2, (void*)(&mt.bkt1->data[0]+48));
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->alloc_count);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->head);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->debug_head_l);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->debug_head_r);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_l);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
#else
		PK_TEST_ASSERT_EQ_EXIT(ptr2, (void*)(&mt.bkt1->data[0]+48));
		PK_TEST_ASSERT_EQ_EXIT(2, mt.bkt1->alloc_count);
		PK_TEST_ASSERT_EQ_EXIT(49, mt.bkt1->head);
		PK_TEST_ASSERT_EQ_EXIT(2, mt.bkt1->debug_head_l);
		PK_TEST_ASSERT_EQ_EXIT(2, mt.bkt1->debug_head_r);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_l);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
#endif

		/*
		 * [00-47] (48) ptr1
		 * [48-XX] ( 1) HEAD
		 */
		pk_delete_bkt(ptr2, 1, mt.bkt1);

#ifdef PK_MEMORY_FORCE_MALLOC
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->alloc_count);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->head);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->debug_head_l);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->debug_head_r);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_l);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
#else
		PK_TEST_ASSERT_EQ_EXIT(1, mt.bkt1->alloc_count);
		PK_TEST_ASSERT_EQ_EXIT(48, mt.bkt1->head);
		PK_TEST_ASSERT_EQ_EXIT(1, mt.bkt1->debug_head_l);
		PK_TEST_ASSERT_EQ_EXIT(2, mt.bkt1->debug_head_r);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_l);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
#endif

		/*
		 * [00-47] (48) ptr1
		 * [   48] ( 1) ptr2
		 * [49-XX] ( 1) HEAD
		 */
		ptr2 = pk_new_bkt(1, 1, mt.bkt1);

#ifdef PK_MEMORY_FORCE_MALLOC
		// PK_TEST_ASSERT_EQ_EXIT(ptr2, (void*)(&mt.bkt1->data[0]+48));
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->alloc_count);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->head);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->debug_head_l);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->debug_head_r);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_l);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
#else
		PK_TEST_ASSERT_EQ_EXIT(ptr2, (void*)(&mt.bkt1->data[0]+48));
		PK_TEST_ASSERT_EQ_EXIT(2, mt.bkt1->alloc_count);
		PK_TEST_ASSERT_EQ_EXIT(49, mt.bkt1->head);
		PK_TEST_ASSERT_EQ_EXIT(2, mt.bkt1->debug_head_l);
		PK_TEST_ASSERT_EQ_EXIT(2, mt.bkt1->debug_head_r);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_l);
		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
#endif

		pk_delete(ptr1, 48, mt.bkt1);
		pk_delete(ptr2,  1, mt.bkt1);
		PK_LOGV_INF("%s: %s\n", __FILE__, "handles free last + new");
		teardown();
	}

	return 0;
}