#include "prb.h"

typedef struct {
	S32 first;
	S32 second;
	B32 flags;
} SomeStruct;

typedef struct SLLNode {
	S32 val;
	struct SLLNode *next;
} SLLNode;

typedef struct DLLNode {
	S32 val;
	struct DLLNode *next;
	struct DLLNode *prev;
} DLLNode;

int main(void)
{
	F32	verts[] = {
		1.0f, 0.0f, 0.0f,
		0.0f, 1.0f, 0.0f,
		0.0f, 0.0f, 1.0f
	};

	ASSERT(v3a(1.0f).y);

	printf("OFFSETOF(SomeStruct, flags): %ld\n\n", OFFSETOF(SomeStruct, flags));

	F32	range_min = 0.0f,
		range_max = 1.0f,
		clamped_number = 1.5f,
		another_clamped_number = -0.2f;

	printf("CLAMPBOT(%f, %f): %f\n", range_min,
	       another_clamped_number, CLAMPBOT(another_clamped_number, range_min));
	printf("CLAMPTOP(%f, %f): %f\n", range_max,
	       clamped_number, CLAMPTOP(clamped_number, range_max));

	printf("CLAMP(%f, %f, %f): %f\n", range_min, clamped_number, range_max,
	       CLAMP(range_min, clamped_number, range_max));
	printf("CLAMP(%f, %f, %f): %f\n\n", range_min, another_clamped_number, range_max,
	       CLAMP(range_min, another_clamped_number, range_max));

	F32	swap_test_first = 10.0f,
		swap_test_second = 20.0f;

	printf("Before SWAP: swap_test_first = %f, swap_test_second = %f\n",
	       swap_test_first, swap_test_second);
	SWAP(F32, swap_test_first, swap_test_second);
	printf("After SWAP: swap_test_first = %f, swap_test_second = %f\n\n",
	       swap_test_first, swap_test_second);

	SomeStruct	some_stuct = { 10, 20, 30 };
	printf("SomeStruct: first: %d, second: %d, flags: %d\n",
	       some_stuct.first, some_stuct.second, some_stuct.flags);
	MEM0(&some_stuct, sizeof(SomeStruct));
	printf("After MEM0(&some_stuct, sizeof(SomeStruct)):\n");
	printf("some_stuct: first: %d, second: %d, flags: %d\n\n",
	       some_stuct.first, some_stuct.second, some_stuct.flags);

	some_stuct = (SomeStruct){ 10, 20, 30 };
	printf("some_stuct: first: %d, second: %d, flags: %d\n",
	       some_stuct.first, some_stuct.second, some_stuct.flags);
	MEM0STRUCT(&some_stuct);
	printf("After MEM0STRUCT(&some_stuct):\n");
	printf("some_stuct: first: %d, second: %d, flags: %d\n\n",
	       some_stuct.first, some_stuct.second, some_stuct.flags);

	S32	dynamic_array_length = 10;
	U64	dynamic_array_size = dynamic_array_length*sizeof(S32);
	F32	*dynamic_array_first = malloc(dynamic_array_size);
	F32	*dynamic_array_second = malloc(dynamic_array_size);

	printf("first dynamic array:\n");
	for (S32 i = 0; i < dynamic_array_length; ++i) {
		F32 *element = dynamic_array_first+i;
		*element = i+420;
		printf("%f%c", *element, (i == dynamic_array_length-1) ? '\n' : ' ');
	}
	printf("second dynamic array:\n");
	for (S32 i = 0; i < dynamic_array_length; ++i) {
		F32 *element = dynamic_array_second+i;
		printf("%f%c", *element, (i == dynamic_array_length-1) ? '\n' : ' ');
	}
	MEMCPY(dynamic_array_second, dynamic_array_first, dynamic_array_size);
	printf("After MEMCPY(dynamic_array_second, dynamic_array_first, dynamic_array_size):\n");
	printf("second dynamic array:\n");
	for (S32 i = 0; i < dynamic_array_length; ++i) {
		F32 *element = dynamic_array_second+i;
		printf("%f%c", *element, (i == dynamic_array_length-1) ? '\n' : ' ');
	}
	S32 memory_match = MEMMATCH(dynamic_array_first, dynamic_array_second, dynamic_array_size);
	printf("And MEMMATCH(dynamic_array_first, dynamic_array_second, dynamic_array_size): %d\n\n", memory_match);
	free(dynamic_array_first);
	free(dynamic_array_second);

	printf("Linked Lists:\n");
	printf("Singly linked list: ");
	S32 list_length = 5;
	U64 list_size = list_length*sizeof(SLLNode);
	SLLNode *sllist = malloc(list_size);
	SLLNode *sllfirst = 0;
	SLLNode *slllast = 0;
	for (S32 i = 0; i < list_length; ++i) {
		SLLNode *new = sllist+i;
		new->val = i;
		SLLPUSH(sllfirst, slllast, new);
	}
	for (SLLNode *node = sllfirst; node; node = node->next)
		printf("%d%s", node->val, ((node->next) ? " -> " : "\n"));
	SLLPOP(sllfirst, slllast);
	printf("After SLLPOP(sllfirst, slllast): ");
	for (SLLNode *node = sllfirst; node; node = node->next)
		printf("%d%s", node->val, ((node->next) ? " -> " : "\n"));
	free(sllist);

	printf("Doubly linked list: ");
	list_length = 8;
	list_size = list_length*sizeof(DLLNode);
	DLLNode *dllist = malloc(list_size);
	DLLNode *dllfirst = 0;
	DLLNode *dlllast = 0;
	for (S32 i = 0; i < list_length; ++i) {
		DLLNode *new = dllist+i;
		new->val = i;
		DLLPUSHBACK(dllfirst, dlllast, new);
	}
	for (DLLNode *node = dllfirst; node; node = node->next)
		printf("%d%s", node->val, ((node->next) ? " -> " : "\n"));
	printf("Remove odd numbers: ");
	for (DLLNode *node = dllfirst; node; node = node->next)
		if (node->val % 2 == 1)
			DLLREMOVE(dllfirst, dlllast, node);
	for (DLLNode *node = dllfirst; node; node = node->next)
		printf("%d%s", node->val, ((node->next) ? " -> " : "\n"));
	free(dllist);
	printf("\n");

	printf("I'm pretty sure the vectors are fine.\nAt least for the last few months :)\n\n");

	printf("Matrices:\n");
	printf("Identity:\n");
	MAT4 m = MAT4_IDENTITY;
	printmat4(m);
	m = scalemat4(m, v3a(10.0f));
	m = translmat4(m, v3a(1.0f));
	m = translmat4(m, v3(0.0f, 68.0f, 0.0f));
	printmat4(m);
	printf("Determinant: %f\n", detmat4(m));
	printf("Transpose:\n"); printmat4(transpmat4(m));
	printf("mat4rotate(MAT4_IDENTITY, v3(0.0f, 45.0f, 0.0f)):\n");
	printmat4(rotatemat4(MAT4_IDENTITY, v3(0.0f, 45.0f, 0.0f)));

	sys_printf("Example of using sys_printf without args\n");
	sys_printf("And with some of number : %x : <- like that or string : %s : for example\n", 69, "yeah");

	printf("Using Arenas:\n");

	Arena	*a;
	U8	*df,
		*ds;
	Arena	*tmpa;
	
	a = alloc_arena(10);
	df = push_arena(a, 5);
	memset(df, 5, 5);
	ds = push_arena(a, 5);
	memset(ds, 10, 5);

	tmpa = alloc_arena(0);

	flsprint(FLSLIT("|"));
	for (S32 i = 0; i < 10; i++)
		flsprint(flspushf(tmpa, "%x%s", df[i], ((i+1) % 5 == 0) ? "|" : " "));
	flsprint(FLSLIT("\n"));

	release_arena(tmpa);
	release_arena(a);

	a = alloc_arena(0);
	SLLNode *first = 0;
	SLLNode *last = 0;
	S32 node_count = 10;
	for (S32 i = 0; i < node_count; ++i) {
		SLLNode *new = push_arena(a, sizeof(SLLNode));
		new->val = i;
		SLLPUSH(first, last, new);
	}
	for (SLLNode *node = first; node; node = node->next)
		printf("%d%s", node->val, ((node->next) ? " -> " : "\n"));
	release_arena(a);

	a = alloc_arena(sizeof(verts));
	S32 verts_count = ARRCNT(verts);
	F32 *dynamic_verts = push_arena(a, sizeof(verts));
	MEM0(dynamic_verts, verts_count*sizeof(F32));
	for (S32 i = 0; i < verts_count; ++i) {
		F32 *vert = dynamic_verts+i;
		printf("%f%c", *vert, (i == verts_count-1) ? '\n' : ' ');
	}
	release_arena(a);
	printf("\n");

	Arena *str_arena = alloc_arena(0);
	printf("Strings:\n");
	char *cstr = "This is a C str\n";
	FLS str = flsfromcstr(cstr);
	str = flschopstart(str, 10);
	cstr = flstocstr(a, str);
	printf("%s", cstr);
	flsprint(str);
	FLS choped_str = flschopend(str, 3);
	flsprint(choped_str);
	printf("\n");
	FLSList *list = flslist(str_arena);
	flslistpush(str_arena, list, str, 0);
	flslistpush(str_arena, list, flsfromcstr("test"), 0);
	flslistpush(str_arena, list, flsfromcstr("and this is also a test\n"), 0);
	flslistpush(str_arena, list, flsfromcstr("Kinda works!"), 1);
	printf("FLSList: ");
	flslistprint(list);
	release_arena(str_arena);
	flslistprint(list);

	str_arena = alloc_arena(KB(10));
	U32 memory_size = 512;
	U32 count = memory_size/sizeof(S32);
	S32 *some = push_arena(str_arena, memory_size);
	printf("str_arena(size): %ld\nMemory:\n", str_arena->cap);
	for (S32 i = 0; i < count; i++) {
		S32 *e = some+i;
		*e = 69;
		printf("%d: %d%c", i, *e, ((i == count-1) ? '\n' : ' '));
	}
	printf("Memory used: %lu\n", str_arena->used);
	printf("Remaining memory: %lu\n",
	       str_arena->cap-str_arena->used);

	pop_arena(str_arena, memory_size);

	printf("After arena pop\n");
	printf("Memory used: %lu\n", str_arena->used);
	printf("Remaining memory: %lu\n",
	       str_arena->cap-str_arena->used);
	printf("some ptr is %s\n", some ? "not null" : "null");
	printf("str_arena(size): %lu\nMemory:\n", str_arena->cap);

	FLS new_str = flspushf(str_arena, "Test of the formatted string: %d\n", 69);
	flsprint(new_str);

	list = flslist(str_arena);
	flslistpushf(str_arena, list, 0, "This is a list %d", 34);
	flslistpushf(str_arena, list, 0, " of formatted strings: %d", 35);
	flslistpushf(str_arena, list, 1, "And you can push to the start");
	/* TODO(pryazha): Think about simpler way of using string literals.
	 * Maybe you don't need to, I dunno */
	flslistpushf(str_arena, list, 1, "The most interesting part is that you can include the whole string like that: %*s\n",
		      FLSEXP(FLSLIT("Absolutely random string with absolutely random content (or not).")));
	flslistprint(list);

	release_arena(str_arena);

	a = alloc_arena(MB(1));
	flsprint(FLSLIT("build.sh content:\n"));
	FLS file_content = fls_read_entire_file(a, FLSLIT("build.sh"));
	if (file_content.p)
		flsprint(file_content);
	else
		flsprint(FLSLIT("failed to read build.sh\n"));
	release_arena(a);

	return(0);
}