#include "private.h"

void heliPairInit(HeliPair *p) {

	p->key = p->value = NULL;

	p->freeKey = p->freeValue = NULL;

}

void heliPairDestroy(HeliPair *p) {

	HeliPair pp;

	memcpy(&pp, p, sizeof(pp));

	heliPairInit(p);

	if (pp.key && pp.freeKey) pp.freeKey(pp.key);

	if (pp.value && pp.freeValue) pp.freeValue(pp.value);

}

void heliArrayInit(HeliArray *a) {

	a->items = NULL;

	a->count = a->allocated = 0;

}

void heliArrayDestroy(HeliArray *a) {

	heliArrayClear(a);

	free(a->items);

	heliArrayInit(a);

}

HeliPair* heliArrayGet(HeliArray *a, int i)

	{ return i >= 0 && i < a->count ? &a->items[i] : NULL; }

void* heliArrayGetKey(HeliArray *a, int i) {

	HeliPair *item = heliArrayGet(a, i);

	return item ? item->key : NULL;

}

void* heliArrayGetValue(HeliArray *a, int i) {

	HeliPair *item = heliArrayGet(a, i);

	return item ? item->value : NULL;

}

HeliPair* heliArrayInsertPair(HeliArray *a, int i, void *k, HeliFreeCallback fk, void *v, HeliFreeCallback fv) {

	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*sizeof(a->items[0]));

		memset(&a->items[a->count], 0, (a->allocated - a->count)*sizeof(a->items[0]));

	}

	if (i < a->count) {

		memmove(&a->items[i+1], &a->items[i], (a->count-i)*sizeof(a->items[0]));

		memset(&a->items[i], 0, sizeof(a->items[0]));

	}

	++a->count;

	HeliPair *item = &a->items[i];

	item->key = k;

	item->value = v;

	item->freeKey = fk;

	item->freeValue = fv;

	return item;

}

HeliPair* heliArrayInsert(HeliArray *a, int i, void *v, HeliFreeCallback fv)

	{ return heliArrayInsertPair(a, i, NULL, NULL, v, fv); }

void heliArrayRemove(HeliArray *a, int i) {

	if (i < 0 || i >= a->count) return;

	HeliPair item;

	memcpy(&item, &a->items[i], sizeof(item));

	memmove(&a->items[i], &a->items[i+1], (a->count-i-1)*sizeof(a->items[0]));

	--a->count;

	memset(&a->items[a->count], 0, sizeof(a->items[0]));

	heliPairDestroy(&item);

}

void heliArrayClear(HeliArray *a) {

	while(a->count > 0)

		heliArrayRemove(a, 0);

}

HeliPair* heliMapFind(HeliArray *a, const void *k, HeliCompareCallback cmp, int *gtOrEqIndex) {

	int i0 = 0;

	int i1 = a->count - 1;

	int c = i0 < a->count ? cmp(a->items[i0].key, k) : -1;

	if (c >= 0) {

		if (gtOrEqIndex) *gtOrEqIndex = i0;

		return c ? NULL : &a->items[i0];

	}

	if (i1 > i0) c = cmp(a->items[i1].key, k);

	if (c < 0) {

		if (gtOrEqIndex) *gtOrEqIndex = a->count;

		return NULL;

	}

	if (c == 0) {

		if (gtOrEqIndex) *gtOrEqIndex = i1;

		return &a->items[i1];

	}

	while(i0 + 1 < i1) {

		int i = (i0 + i1)/2;

		c = cmp(a->items[i].key, k);

		if (c == 0) {

			if (gtOrEqIndex) *gtOrEqIndex = i;

			return &a->items[i];

		}

		if (c < 0) i0 = i; else i1 = i;

	}

	if (gtOrEqIndex) *gtOrEqIndex = i1;

	return NULL;

}

HeliPair* heliMapGet(HeliArray *a, const void *k, HeliCompareCallback cmp)

	{ return heliMapFind(a, k, cmp, NULL); }

HeliPair* heliMapAdd(

	HeliArray *a, const void *k, HeliCompareCallback cmp,

	HeliCloneCallback ck, HeliFreeCallback fk,

	void *v, HeliFreeCallback fv )

{

	int i;

	HeliPair *item = heliMapFind(a, k, cmp, &i);

	if (item) {

		if (item->value != v) {

			void *vv = item->value;

			HeliFreeCallback ffvv = item->freeValue;

			item->value = v;

			item->freeValue = fv;

			if (vv && ffvv) ffvv(vv);

		}

	} else {

		item = heliArrayInsertPair(a, i, ck(k), fk, v, fv);

	}

	return item;

}

int heliMapRemove(HeliArray *a, const void *k, HeliCompareCallback cmp) {

	int i;

	if (heliMapFind(a, k, cmp, &i)) {

		heliArrayRemove(a, i);

		return TRUE;

	}

	return FALSE;

}

static int uintCompare(size_t a, size_t b)

	{ return a < b ? -1 : (a > b ? 1: 0); }

static size_t uintClone(size_t a)

	{ return a; }

HeliPair* heliUIntFind(HeliArray *a, size_t k, int *gtOrEqIndex)

	{ return heliMapFind(a, (const void*)k, (HeliCompareCallback)&uintCompare, gtOrEqIndex); }

HeliPair* heliUIntGet(HeliArray *a, size_t k)

	{ return heliUIntFind(a, k, NULL); }

HeliPair* heliUIntAdd(HeliArray *a, size_t k, void *v, HeliFreeCallback fv)

	{ return heliMapAdd(a, (const void*)k, (HeliCompareCallback)&uintCompare, (HeliCloneCallback)&uintClone, NULL, v, fv); }

int heliUIntRemove(HeliArray *a, size_t k)

	{ return heliMapRemove(a, (const void*)k, (HeliCompareCallback)&uintCompare); }

HeliPair* heliStringmapFind(HeliArray *a, const char *k, int *gtOrEqIndex)

	{ return heliMapFind(a, k, (HeliCompareCallback)&strcmp, gtOrEqIndex); }

HeliPair* heliStringmapGet(HeliArray *a, const char *k)

	{ return heliStringmapFind(a, k, NULL); }

HeliPair* heliStringmapAdd(HeliArray *a, const char *k, void *v, HeliFreeCallback fv)

	{ return heliMapAdd(a, k, (HeliCompareCallback)&strcmp, (HeliCloneCallback)&heliStringCopy, &free, v, fv); }

int heliStringmapRemove(HeliArray *a, const char *k)

	{ return heliMapRemove(a, k, (HeliCompareCallback)&strcmp); }