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

#include <expValue.h>
#include <bbtree.h>
#include <ident.h>
#include <identList.h>


struct identList
{
	s_bbTree * idIdx;
	s_bbTree * idHash;
};


/*
 * statische Funktionen (interner gebrauch)
 */
static
	int
idHashCmp (void * _a, void * _b)
{
	s_ident * a = (s_ident *) _a;
	s_ident * b = (s_ident *) _b;

	return strcmp (identGetKey (a), identGetKey (b));
}

static
	int
idIdxCmp (void * _a, void * _b)
{
	s_ident * a = (s_ident *) _a;
	s_ident * b = (s_ident *) _b;

	return identGetIdx (a) - identGetIdx (b);
}


/*
 * nicht statische Funktionen (Interface)
 */

/*
 * Contructors / Destructors for identList
 */
	s_identList *
identListNew (void)
{
	s_identList * ret = (s_identList *) malloc (sizeof (s_identList));

	ret->idIdx  = bbTreeNew (idIdxCmp);
	ret->idHash = bbTreeNew (idHashCmp);

	return ret;
}

void
identListFree (s_identList * l)
{
	s_ident ** idArray,
	        ** _run;

	for (_run = idArray = (s_ident **) identListToArray (l);
			*_run != NULL;
			_run++)
	{
		identDequeue (*_run);
		if (! identIsQueued (*_run))
			identFree (*_run);
	}
	
	free (idArray);

	bbTreeFree (l->idIdx);
	bbTreeFree (l->idHash);

	free (l);
}

/*
 * insertions or deletion into a identList
 */
	s_ident *
identListPutVal (s_identList * l, s_ident * val)
{
	s_ident * oldVal;
	int    idx	= identGetIdx (val);
	char * key	= identGetKey (val);

	identEnqueue (val);

	if ((idx < 0 && key[0] == '\0') || idx != -1 && key[0] != '\0')
		/* calling error: either key or idx must be valid. But not both. */
		return NULL;

	if (idx >= 0)
		oldVal = (s_ident *) bbTreeInsert (l->idIdx, val);
	else
		oldVal = (s_ident *) bbTreeInsert (l->idHash, val);

	if (oldVal != NULL)
	/* 
	 * these are few lines with a lot behind them. The not obvious question 
	 * here is: What happens if oldval points to the same address than val?
	 * well, this could only happen if val was was formally queued, because
	 * else oldVal would be NULL. Knowing this makes clear that the queue
	 * state is not changed at all, because first it was increased above with
	 * identEnqueue and the it will be decreased in this if block again. But as
	 * it was formally queued it will not be freed (Good)!
	 */
	{
		identDequeue (oldVal);
		if (! identIsQueued (oldVal))
			identFree (oldVal);
	}

	return val;
}

	s_ident *
identListPutExpByIdx (s_identList * l, int idx, s_expVal * val)
{
	return identListPutVal (l, identExpNew (idx, NULL, val));
}

	s_ident *
identListPutIdlByIdx (s_identList * l, int idx, s_identList * val)
{
	return identListPutVal (l, identIdlNew (idx, NULL, val));
}

	s_ident *
identListPutExpByKey (s_identList * l, const char * key, s_expVal * val)
{
	return identListPutVal (l, identExpNew (-1, key, val));
}

	s_ident *
identListPutIdlByKey (s_identList * l, const char * key, s_identList * val)
{
	return identListPutVal (l, identIdlNew (-1, key, val));
}

	void
identListRemoveByIdx (s_identList * l, int idx)
{
	s_ident * seek = (s_ident *) identNew (idx, NULL);
	s_ident * val  = bbTreeRemove (l->idIdx, seek);

#ifdef DEBUG2
	printf ("[!DEBUG!] seek (remove) identNew: %d/%s\n", idx, "");
#endif

	identFree (seek);

	if (val != NULL)
	{
		identDequeue (val);
		if (! identIsQueued (val))
			identFree (val);
	}
}

	void
identListRemoveByKey (s_identList * l, const char * key)
{
	s_ident * seek = (s_ident *) identNew (-1, key);
	s_ident * val  = bbTreeRemove (l->idIdx, seek);

#ifdef DEBUG2
	printf ("[!DEBUG!] seek (remove) identNew: %d/%s\n", -1, key);
#endif

	identFree (seek);

	if (val != NULL)
	{
		identDequeue (val);
		if (! identIsQueued (val))
			identFree (val);
	}
}

/*
 * seeking in identList
 */
	s_ident *
identListSeekIdx (s_identList * l, int idx)
{
	s_ident * seek = (s_ident *) identNew (idx, NULL);
	s_ident * val  = (s_ident *) bbTreeSeek (l->idIdx, seek);

#ifdef DEBUG2
	printf ("[!DEBUG!] seek identNew: %d/%s\n", idx, "");
#endif

	identFree (seek);

	return val;
}

	s_ident *
identListSeekKey (s_identList * l, const char * key)
{
	s_ident * seek = (s_ident *) identNew (-1, key);
	s_ident * val  = (s_ident *) bbTreeSeek (l->idHash, seek);

#ifdef DEBUG2
	printf ("[!DEBUG!] seek identNew: %d/%s\n", -1, key);
#endif

	identFree (seek);

	return val;
}

/*
 * identList to other DataStructures 
 */
	s_ident **
identListToArray (s_identList * l)
{
	int        idIdxLen  = bbTreeSize (l->idIdx);
	int        idHashLen = bbTreeSize (l->idHash);
	int        retLen    = idIdxLen + idHashLen + 1;
	s_ident ** ret       = (s_ident **) malloc (sizeof (s_ident *) * retLen);

	memset (ret, 0, sizeof (s_ident **) * retLen);

	bbTreeInOrder (l->idIdx, (void **) ret);
	bbTreeInOrder (l->idHash, (void **) &(ret[idIdxLen]));

	return ret;
}