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

#include "storage.h"
#include "bitset.h"

enum component_t
{
	C_TRANSFORM = (int) 0,
	C_COLLIDER,
};

typedef struct
{
	int x;
	int y;
} transform_t;

void
printTransform(transform_t *t)
{
	printf("Transform { .x = %i, .y = %i }\n", t->x, t->y);
}

typedef struct
{
	float width;
	float height;
	int collisionsCount;
} collider_t;

void
sys_collide(storage_t *storage, entity_t eid)
{
	printf("Inside collide, id = %i\n", eid);
	transform_t *transform = GET_COMPONENT(storage, transform_t, eid);
	// collider_t *collider = GET_COMPONENT(storage, collider_t, eid);
	printTransform(transform);
	printf("\n");
}

void
sys_move(storage_t *storage, entity_t eid)
{
	printf("Inside move, id = %i\n", eid);
	transform_t *transform = GET_COMPONENT(storage, transform_t, eid);
	printTransform(transform);
	printf("\n");
}


// Engine functions

void
initStorage(storage_t *storage)
{
	storage->componentsStored = 0;
	storage->objectsStored = 0;
	storage->objects = (component_pair_t *) malloc(MAX_COMPONENTS * sizeof(component_pair_t));
	bitarena_init(&storage->objectSignatures, MAX_OBJECTS);

	storage->systemsStored = 0;
	storage->systems = (system_t *) malloc(4096 * sizeof(system_t));
	bitarena_init(&storage->systemSignatures, 4096);

	REGISTER_COMPONENT(storage, transform_t);
	REGISTER_COMPONENT(storage, collider_t);
}

void
loadScene(storage_t *storage)
{
	// bitset_t s1 = bitarena_at(&storage->objectSignatures, 0);
	// bitset_t s2 = bitarena_at(&storage->objectSignatures, 1);

	// bitset_set(s1, 9);
	// bitset_set(s2, 9);

	// bitset_print(s1);
	// bitset_print(s2);

	// bitset_t sAnd = bitset_and(s1, s2);
	// printf("Bitset is zero: %i\n", bitset_isZero(sAnd));
	// printf("Bitset is equals: %i\n", bitset_equals(s1, s2));

	entity_t e1 = createEntity(storage);
	ADD_COMPONENT(storage, e1, transform_t);
	ADD_COMPONENT(storage, e1, collider_t);
	transform_t *t1 = GET_COMPONENT(storage, transform_t, e1);
	t1->x = 13;
	t1->y = 37;
	collider_t *c1 = GET_COMPONENT(storage, collider_t, e1);
	c1->height = 50;
	c1->width = 50;
	c1->collisionsCount = 5;

	entity_t e2 = createEntity(storage);
	ADD_COMPONENT(storage, e2, transform_t);
	transform_t *t2 = GET_COMPONENT(storage, transform_t, e2);
	t2->x = 14;
	t2->y = 88;

	entity_t e3 = createEntity(storage);
	ADD_COMPONENT(storage, e3, transform_t);
	transform_t *t3 = GET_COMPONENT(storage, transform_t, e3);
	t3->x = 123;
	t3->y = 456;

	entity_t e4 = createEntity(storage);
	ADD_COMPONENT(storage, e4, transform_t);
	transform_t *t4 = GET_COMPONENT(storage, transform_t, e4);
	t4->x = 1212;
	t4->y = 1212;

	entity_t e5 = createEntity(storage);
	ADD_COMPONENT(storage, e5, transform_t);
	transform_t *t5 = GET_COMPONENT(storage, transform_t, e5);
	t5->x = 777;
	t5->y = 666;

	{
		char *components[] = {"transform_t", "collider_t", NULL};
		bitset_t bitset = createSignature(storage, components);
		// printf("Collide bitset: ");
		// bitset_print(bitset);
		registerSystem(storage, sys_collide, bitset);
	}

	{
		char *components[] = {"transform_t", NULL};
		bitset_t bitset = createSignature(storage, components);
		// printf("Move bitset: ");
		// bitset_print(bitset);
		registerSystem(storage, sys_move, bitset);
	}
}

void
update(storage_t *storage)
{
	for (entity_t i = 0; i < storage->objectsStored; ++i)
	{
		for (int j = 0; j < storage->systemsStored; ++j)
		{
			bitset_t objBitset = bitarena_at(&storage->objectSignatures, i);
			bitset_t sysBitset = bitarena_at(&storage->systemSignatures, j);
			bitset_t bitAnd = bitset_and(objBitset, sysBitset);

			if (bitset_equals(bitAnd, sysBitset))
			{
				storage->systems[j](storage, i);
			}
		}
	}
}

int
main()
{
	storage_t storage;
	initStorage(&storage);
	loadScene(&storage);
	update(&storage);

	return 0;
}