#include "utilities/ChunkArray.h"
#include "unittest/TestSuite.h"
#include <limits.h>
#include <stdint.h>

static void testInit(void) {
	ChunkArray array = ChunkArray_init();
	TestCase_assertPointerNULL(array.data);
	TestCase_assertUIntEqual(array.count, 0);
	TestCase_assertPointerNULL(array.offsets);
	TestCase_assertUIntEqual(array.totalSize, 0);
	TestCase_assertUIntEqual(array.alignment, 8);
	ChunkArray_free(&array);
}

static void testAppend(void) {
	ChunkArray array = ChunkArray_init();
	uint32_t uint32Value = 1234;
	void * entry = ChunkArray_append(&array, &uint32Value, sizeof(uint32Value));
	TestCase_assertPointerNonNULL(array.data);
	TestCase_assertUIntEqual(array.count, 1);
	TestCase_assertPointerNonNULL(array.offsets);
	TestCase_assertUIntEqual(array.offsets[0], 0);
	TestCase_assertUIntEqual(array.totalSize, 8);
	TestCase_assertPointerEqual(entry, array.data);
	TestCase_assertBytesEqual(array.data, &uint32Value, sizeof(uint32Value));
	
	char string[] = "Hello world!";
	entry = ChunkArray_append(&array, string, sizeof(string));
	TestCase_assertUIntEqual(array.count, 2);
	TestCase_assertUIntEqual(array.offsets[1], 8);
	TestCase_assertUIntEqual(array.totalSize, 24);
	TestCase_assertPointerEqual(entry, array.data + 8);
	TestCase_assertBytesEqual(array.data + 8, string, sizeof(string));
	
	uint8_t uint8Value = 9;
	entry = ChunkArray_append(&array, &uint8Value, sizeof(uint8Value));
	TestCase_assertUIntEqual(array.count, 3);
	TestCase_assertUIntEqual(array.offsets[2], 24);
	TestCase_assertUIntEqual(array.totalSize, 32);
	TestCase_assertPointerEqual(entry, array.data + 24);
	TestCase_assertBytesEqual(array.data + 24, &uint8Value, sizeof(uint8Value));
	
	entry = ChunkArray_append(&array, NULL, 8);
	TestCase_assertUIntEqual(array.count, 4);
	TestCase_assertUIntEqual(array.offsets[3], 32);
	TestCase_assertUIntEqual(array.totalSize, 40);
	TestCase_assertPointerEqual(entry, array.data + 32);
	ChunkArray_free(&array);
}

static void testCopy(void) {
	ChunkArray array = ChunkArray_init();
	ChunkArray copy = ChunkArray_copy(&array);
	ChunkArray_free(&array);
	
	TestCase_assertUIntEqual(copy.count, 0);
	TestCase_assertPointerNULL(copy.data);
	TestCase_assertPointerNULL(copy.offsets);
	TestCase_assertUIntEqual(copy.totalSize, 0);
	TestCase_assertUIntEqual(copy.alignment, 8);
	ChunkArray_free(&copy);
	
	array = ChunkArray_init();
	array.alignment = 4;
	uint32_t uint32Value = 1234;
	ChunkArray_append(&array, &uint32Value, sizeof(uint32Value));
	uint8_t uint8Value = 9;
	ChunkArray_append(&array, &uint8Value, sizeof(uint8Value));
	copy = ChunkArray_copy(&array);
	ChunkArray_free(&array);
	
	TestCase_assertPointerNonNULL(copy.data);
	TestCase_assertPointerNonNULL(copy.offsets);
	TestCase_assertUIntEqual(copy.totalSize, 8);
	TestCase_assertUIntEqual(copy.alignment, 4);
	TestCase_assertUIntEqual(copy.count, 2);
	TestCase_assertUIntEqual(copy.offsets[0], 0);
	TestCase_assertUIntEqual(copy.offsets[1], 4);
	TestCase_assertBytesEqual(copy.data, &uint32Value, sizeof(uint32Value));
	TestCase_assertBytesEqual(copy.data + 4, &uint8Value, sizeof(uint8Value));
	ChunkArray_free(&copy);
}

static void testInsert(void) {
	ChunkArray array = ChunkArray_init();
	uint32_t uint32Value = 1234;
	void * entry = ChunkArray_insert(&array, 0, &uint32Value, sizeof(uint32Value));
	TestCase_assertPointerEqual(entry, array.data);
	uint32Value = 5678;
	entry = ChunkArray_insert(&array, 0, &uint32Value, sizeof(uint32Value));
	TestCase_assertPointerNonNULL(array.data);
	TestCase_assertUIntEqual(array.count, 2);
	TestCase_assertPointerNonNULL(array.offsets);
	TestCase_assertUIntEqual(array.offsets[0], 8);
	TestCase_assertUIntEqual(array.offsets[1], 0);
	TestCase_assertUIntEqual(array.totalSize, 16);
	TestCase_assertPointerEqual(entry, array.data + 8);
	TestCase_assertBytesEqual(array.data + 8, &uint32Value, sizeof(uint32Value));
	uint32Value = 1234;
	TestCase_assertBytesEqual(array.data, &uint32Value, sizeof(uint32Value));
	
	char string[] = "Hello world!";
	entry = ChunkArray_insert(&array, 1, string, sizeof(string));
	TestCase_assertUIntEqual(array.count, 3);
	TestCase_assertUIntEqual(array.offsets[0], 8);
	TestCase_assertUIntEqual(array.offsets[1], 16);
	TestCase_assertUIntEqual(array.offsets[2], 0);
	TestCase_assertUIntEqual(array.totalSize, 32);
	TestCase_assertPointerEqual(entry, array.data + 16);
	TestCase_assertBytesEqual(array.data + 16, string, sizeof(string));
	
	uint8_t uint8Value = 9;
	entry = ChunkArray_insert(&array, 2, &uint8Value, sizeof(uint8Value));
	TestCase_assertUIntEqual(array.count, 4);
	TestCase_assertUIntEqual(array.offsets[0], 8);
	TestCase_assertUIntEqual(array.offsets[1], 16);
	TestCase_assertUIntEqual(array.offsets[2], 32);
	TestCase_assertUIntEqual(array.offsets[3], 0);
	TestCase_assertUIntEqual(array.totalSize, 40);
	TestCase_assertPointerEqual(entry, array.data + 32);
	TestCase_assertBytesEqual(array.data + 32, &uint8Value, sizeof(uint8Value));
	
	entry = ChunkArray_insert(&array, 4, NULL, 8);
	TestCase_assertUIntEqual(array.count, 5);
	TestCase_assertUIntEqual(array.offsets[4], 40);
	TestCase_assertUIntEqual(array.totalSize, 48);
	TestCase_assertPointerEqual(entry, array.data + 40);
	ChunkArray_free(&array);
}

static void testRemove(void) {
	ChunkArray array = ChunkArray_init();
	uint32_t uint32Value = 1234;
	ChunkArray_append(&array, &uint32Value, sizeof(uint32Value));
	char string[] = "Hello world!";
	ChunkArray_append(&array, string, sizeof(string));
	uint8_t uint8Value = 9;
	ChunkArray_append(&array, &uint8Value, sizeof(uint8Value));
	uint8Value = 10;
	ChunkArray_append(&array, &uint8Value, sizeof(uint8Value));
	
	ChunkArray_remove(&array, 0);
	TestCase_assertUIntEqual(array.count, 3);
	TestCase_assertUIntEqual(array.offsets[0], 0);
	TestCase_assertUIntEqual(array.offsets[1], 16);
	TestCase_assertUIntEqual(array.offsets[2], 24);
	TestCase_assertUIntEqual(array.totalSize, 32);
	TestCase_assertBytesEqual(array.data, string, sizeof(string));
	uint8Value = 9;
	TestCase_assertBytesEqual(array.data + 16, &uint8Value, sizeof(uint8Value));
	uint8Value = 10;
	TestCase_assertBytesEqual(array.data + 24, &uint8Value, sizeof(uint8Value));
	
	ChunkArray_remove(&array, 1);
	TestCase_assertUIntEqual(array.count, 2);
	TestCase_assertUIntEqual(array.offsets[0], 0);
	TestCase_assertUIntEqual(array.offsets[1], 16);
	TestCase_assertUIntEqual(array.totalSize, 24);
	TestCase_assertBytesEqual(array.data, string, sizeof(string));
	TestCase_assertBytesEqual(array.data + 16, &uint8Value, sizeof(uint8Value));
	
	ChunkArray_removeAll(&array);
	TestCase_assertUIntEqual(array.count, 0);
	TestCase_assertUIntEqual(array.totalSize, 0);
	ChunkArray_free(&array);
}

static void testEntryAtIndex(void) {
	ChunkArray array = ChunkArray_init();
	
	void * entry = ChunkArray_entryAtIndex(&array, 0);
	TestCase_assertPointerNULL(entry);
	
	uint32_t uint32Value = 1234;
	ChunkArray_append(&array, &uint32Value, sizeof(uint32Value));
	char string[] = "Hello world!";
	ChunkArray_append(&array, string, sizeof(string));
	uint8_t uint8Value = 9;
	ChunkArray_append(&array, &uint8Value, sizeof(uint8Value));
	
	entry = ChunkArray_entryAtIndex(&array, 0);
	TestCase_assertPointerEqual(entry, array.data);
	entry = ChunkArray_entryAtIndex(&array, 1);
	TestCase_assertPointerEqual(entry, array.data + 8);
	entry = ChunkArray_entryAtIndex(&array, 2);
	TestCase_assertPointerEqual(entry, array.data + 24);
	entry = ChunkArray_entryAtIndex(&array, 3);
	TestCase_assertPointerNULL(entry);
	
	ChunkArray_free(&array);
}

static void testIndexOfEntry(void) {
	ChunkArray array = ChunkArray_init();
	uint32_t uint32Value = 1234;
	ChunkArray_append(&array, &uint32Value, sizeof(uint32Value));
	char string[] = "Hello world!";
	ChunkArray_append(&array, string, sizeof(string));
	uint8_t uint8Value = 9;
	ChunkArray_append(&array, &uint8Value, sizeof(uint8Value));
	
	size_t index = ChunkArray_indexOfEntry(&array, array.data);
	TestCase_assertUIntEqual(index, 0);
	index = ChunkArray_indexOfEntry(&array, array.data + 7);
	TestCase_assertUIntEqual(index, 0);
	index = ChunkArray_indexOfEntry(&array, array.data + 8);
	TestCase_assertUIntEqual(index, 1);
	index = ChunkArray_indexOfEntry(&array, array.data + 23);
	TestCase_assertUIntEqual(index, 1);
	index = ChunkArray_indexOfEntry(&array, array.data + 24);
	TestCase_assertUIntEqual(index, 2);
	index = ChunkArray_indexOfEntry(&array, array.data + 31);
	TestCase_assertUIntEqual(index, 2);
	index = ChunkArray_indexOfEntry(&array, array.data + 32);
	TestCase_assertUIntEqual(index, SIZE_MAX);
	index = ChunkArray_indexOfEntry(&array, array.data - 1);
	TestCase_assertUIntEqual(index, SIZE_MAX);
	
	ChunkArray_free(&array);
}

static void testAlignment(void) {
	ChunkArray array = ChunkArray_init();
	array.alignment = 1;
	uint32_t uint32Value = 1234;
	ChunkArray_append(&array, &uint32Value, sizeof(uint32Value));
	char string[] = "Hello world!";
	ChunkArray_append(&array, string, sizeof(string));
	uint8_t uint8Value = 9;
	ChunkArray_append(&array, &uint8Value, sizeof(uint8Value));
	
	TestCase_assertUIntEqual(array.offsets[0], 0);
	TestCase_assertUIntEqual(array.offsets[1], 4);
	TestCase_assertUIntEqual(array.offsets[2], 17);
	TestCase_assertUIntEqual(array.totalSize, 18);
	TestCase_assertBytesEqual(array.data, &uint32Value, sizeof(uint32Value));
	TestCase_assertBytesEqual(array.data + 4, string, sizeof(string));
	TestCase_assertBytesEqual(array.data + 17, &uint8Value, sizeof(uint8Value));
	ChunkArray_free(&array);
	
	array = ChunkArray_init();
	array.alignment = 32;
	ChunkArray_append(&array, &uint32Value, sizeof(uint32Value));
	ChunkArray_append(&array, string, sizeof(string));
	ChunkArray_append(&array, &uint8Value, sizeof(uint8Value));
	
	TestCase_assertUIntEqual(array.offsets[0], 0);
	TestCase_assertUIntEqual(array.offsets[1], 32);
	TestCase_assertUIntEqual(array.offsets[2], 64);
	TestCase_assertUIntEqual(array.totalSize, 96);
	TestCase_assertBytesEqual(array.data, &uint32Value, sizeof(uint32Value));
	TestCase_assertBytesEqual(array.data + 32, string, sizeof(string));
	TestCase_assertBytesEqual(array.data + 64, &uint8Value, sizeof(uint8Value));
	ChunkArray_free(&array);
}

static void testGetEntrySize(void) {
	ChunkArray array = ChunkArray_init();
	array.alignment = 4;
	size_t size = ChunkArray_getEntrySize(&array, 0);
	TestCase_assertSizeEqual(size, 0);
	
	char data[8] = {0, 1, 2, 3, 4, 5, 6, 7};
	ChunkArray_append(&array, data, 4);
	size = ChunkArray_getEntrySize(&array, 0);
	TestCase_assertSizeEqual(size, 4);
	
	ChunkArray_append(&array, data, 8);
	size = ChunkArray_getEntrySize(&array, 1);
	TestCase_assertSizeEqual(size, 8);
	
	ChunkArray_append(&array, data, 1);
	size = ChunkArray_getEntrySize(&array, 2);
	TestCase_assertSizeEqual(size, 4);
	
	size = ChunkArray_getEntrySize(&array, 3);
	TestCase_assertSizeEqual(size, 0);
	
	ChunkArray_insert(&array, 0, data, 7);
	size = ChunkArray_getEntrySize(&array, 0);
	TestCase_assertSizeEqual(size, 8);
	size = ChunkArray_getEntrySize(&array, 1);
	TestCase_assertSizeEqual(size, 4);
	size = ChunkArray_getEntrySize(&array, 2);
	TestCase_assertSizeEqual(size, 8);
	size = ChunkArray_getEntrySize(&array, 3);
	TestCase_assertSizeEqual(size, 4);
	ChunkArray_free(&array);
}

TEST_SUITE(ChunkArrayTest,
           testInit,
           testAppend,
           testCopy,
           testInsert,
           testRemove,
           testEntryAtIndex,
           testIndexOfEntry,
           testAlignment,
           testGetEntrySize)