#include "private.h"



static char* heliStringCopy(char *x) {
	int len = strlen(x) + 1;
	char *cp = malloc(len + 1);
	memcpy(cp, x, len);
	return cp;
}

static void heliLowercase(char *x)
	{ while(*x) *x = tolower(*x); }



int heliArrayInit(HeliArray *a) {
	a->items = NULL;
	a->count = a->allocated = 0;
}

void heliArrayClear(HeliArray *a, int freeData) {
	if (freeData)
		for(int i = 0; i < a->count; ++i)
			free(a->items[i]);
	a->count = 0;
}

int heliArrayDestroy(HeliArray *a, int freeData) {
	heliArrayClear(a, freeData);
	free(a->items);
	a->items = NULL;
	a->count = a->allocated = 0;
}

void* heliArrayGet(HeliArray *a, int i)
	{ return i >= 0 && i < a->count ? a->items[i] : NULL; }

void heliArrayInsert(HeliArray *a, int i, void *item) {
	if (i < 0 || i > a->count)
		i = a->count;
	if (a->allocated < a->count + 1) {
		a->allocated += a->allocated/4 + 32;
		a->items = realloc(a->items, a->allocated);
	}
	if (i < a->count)
		memmove(&a->items[i+1], &a->items[i], (a->count-i)*sizeof(a->items[0]));
	++a->count;
	a->items[i] = item;
}

void heliArrayAppend(HeliArray *a, void *data)
	{ heliArrayInsert(a, a->count, data); }

void heliArrayRemove(HeliArray *a, int i, int freeData) {
	if (i < 0 || i >= a->count)
		return;
	if (freeData) free(a->items[i]);
	memmove(&a->items[i], &a->items[i+1], (a->count-i-1)*sizeof(a->items[0]));
	--a->count;
}

int heliStringsetFind(HeliArray *a, char *x, int *gtOrEqIndex) {
	for(int i = 0; i < a->count; ++i) {
		int cmp = strcmp((char*)a->items[i], x);
		if (cmp < 0) continue;
		if (gtOrEqIndex) *gtOrEqIndex = i;
		return cmp == 0;
	}
	if (gtOrEqIndex) *gtOrEqIndex = a->count;
	return 0;
}

int heliStringsetGet(HeliArray *a, char *x)
	{ return heliStringsetFind(a, x, NULL); }

void heliStringsetAdd(HeliArray *a, char *x) {
	int i;
	if (heliStringsetFind(a, x, &i)) return;
	heliArrayInsert(a, i, heliStringCopy(x));
}

void heliStringsetRemove(HeliArray *a, char *x) {
	int i;
	if (!heliStringsetFind(a, x, &i)) return;
	heliArrayRemove(a, i, TRUE);
}



int heliCheckCollision(HeliCollider *a, HeliCollider *b, double *normX, double *normY) {
	// corner with side
	// corner with circle
	// circle with circle
	#warning "TODO: heliCheckCollision: not implemented yet"
	return FALSE;
}

int heliPointCollision(HeliCollider *c, double x, double y) {
	x -= c->x;
	y -= c->y;
	if (c->type == COLLIDER_CIRCLE) {
		return x*x + y*y <= c->radius*c->radius;
	} else
	if (c->type == COLLIDER_RECTANGLE) {
		double a = c->rotation/180.0*M_PI;
		double sn = sin(a);
		double cn = cos(a);
		return fabs(x*cn - y*sn) <= c->width*0.5
			&& fabs(x*sn + y*cn) <= c->height*0.5;
	}
	return FALSE;
}