#include "hstore.h"
#include "utils/array.h"
#include "catalog/pg_type.h"
#include "funcapi.h"
#include <access/heapam.h>
#include <fmgr.h>


static HEntry *
findkey(HStore *hs, char *key, int keylen) {
	HEntry *StopLow  = ARRPTR(hs);
	HEntry *StopHigh = StopLow + hs->size;
	HEntry  *StopMiddle;
	int    difference;
	char *base = STRPTR(hs);

	while (StopLow < StopHigh) {
		StopMiddle = StopLow + (StopHigh - StopLow) / 2;

		if ( StopMiddle->keylen == keylen )
			difference=strncmp(base+StopMiddle->pos, key, StopMiddle->keylen);
		else
			difference=(StopMiddle->keylen > keylen) ? 1 : -1;

		if (difference == 0)
			return StopMiddle;
		else if (difference < 0)
			StopLow = StopMiddle + 1;
		else
			StopHigh = StopMiddle;
	}
		
	return NULL;
}

PG_FUNCTION_INFO_V1(fetchval);
Datum           fetchval(PG_FUNCTION_ARGS);
Datum
fetchval(PG_FUNCTION_ARGS) {
	HStore *hs  = PG_GETARG_HS(0);
	text   *key = PG_GETARG_TEXT_P(1);
	HEntry	*entry;
	text *out;

	if ((entry=findkey(hs,VARDATA(key), VARSIZE(key)-VARHDRSZ))==NULL || entry->valisnull) {
		PG_FREE_IF_COPY(hs,0);
		PG_FREE_IF_COPY(key,1);
		PG_RETURN_NULL();
	}

	out=palloc(VARHDRSZ+entry->vallen);
	memcpy(VARDATA(out),STRPTR(hs) + entry->pos + entry->keylen, entry->vallen);
	VARATT_SIZEP(out) = VARHDRSZ+entry->vallen;

	PG_FREE_IF_COPY(hs,0);
	PG_FREE_IF_COPY(key,1);
	PG_RETURN_POINTER(out);
}

PG_FUNCTION_INFO_V1(exists);
Datum           exists(PG_FUNCTION_ARGS);
Datum
exists(PG_FUNCTION_ARGS) {
	HStore *hs  = PG_GETARG_HS(0);
	text   *key = PG_GETARG_TEXT_P(1);
	HEntry	*entry;

	entry=findkey(hs,VARDATA(key), VARSIZE(key)-VARHDRSZ);

	PG_FREE_IF_COPY(hs,0);
	PG_FREE_IF_COPY(key,1);

	PG_RETURN_BOOL(entry);
}

PG_FUNCTION_INFO_V1(defined);
Datum           defined(PG_FUNCTION_ARGS);
Datum
defined(PG_FUNCTION_ARGS) {
	HStore *hs  = PG_GETARG_HS(0);
	text   *key = PG_GETARG_TEXT_P(1);
	HEntry	*entry;
	bool res;

	entry=findkey(hs,VARDATA(key), VARSIZE(key)-VARHDRSZ);

	res = ( entry && !entry->valisnull ) ? true : false;

	PG_FREE_IF_COPY(hs,0);
	PG_FREE_IF_COPY(key,1);

	PG_RETURN_BOOL(res);
}

PG_FUNCTION_INFO_V1(delete);
Datum           delete(PG_FUNCTION_ARGS);
Datum
delete(PG_FUNCTION_ARGS) {
	HStore *hs  = PG_GETARG_HS(0);
	text   *key = PG_GETARG_TEXT_P(1);
	HStore *out = palloc(hs->len);
	char *ptrs, *ptrd;
	HEntry	*es, *ed;

	out->len=hs->len;
	out->size=hs->size; /* temprorary! */

	ptrs=STRPTR(hs);
	es  =ARRPTR(hs);
	ptrd=STRPTR(out);
	ed  =ARRPTR(out);

	while( es - ARRPTR(hs) < hs->size ) { 
		if ( !(es->keylen == VARSIZE(key) - VARHDRSZ && strncmp(ptrs, VARDATA(key), es->keylen)==0) ) {
			memcpy( ed, es, sizeof(HEntry) );
			memcpy( ptrd, ptrs, es->keylen + ( (es->valisnull) ? 0 : es->vallen ) );
			ed->pos = ptrd - STRPTR(out);
			ptrd += es->keylen + ( (es->valisnull) ? 0 : es->vallen );
			ed++;
		}
		ptrs += es->keylen + ( (es->valisnull) ? 0 : es->vallen );
		es++;
	}

	if ( ed - ARRPTR(out) != out->size ) {
		int buflen=ptrd-STRPTR(out);
		ptrd = STRPTR(out);

		out->size = ed - ARRPTR(out);

		memmove( STRPTR(out), ptrd, buflen);
		out->len = CALCDATASIZE(out->size, buflen);
	}
		

	PG_FREE_IF_COPY(hs,0);
	PG_FREE_IF_COPY(key,1);

	PG_RETURN_POINTER(out);
}

PG_FUNCTION_INFO_V1(hs_concat);
Datum           hs_concat(PG_FUNCTION_ARGS);
Datum
hs_concat(PG_FUNCTION_ARGS) {
	HStore *s1  = PG_GETARG_HS(0);
	HStore *s2  = PG_GETARG_HS(1);
	HStore *out = palloc( s1->len + s2->len );
	char *ps1, *ps2, *pd;
	HEntry *es1, *es2, *ed;

	out->len = s1->len + s2->len;
	out->size = s1->size + s2->size;

	ps1=STRPTR(s1);
	ps2=STRPTR(s2);
	pd=STRPTR(out);
	es1=ARRPTR(s1);
	es2=ARRPTR(s2);
	ed=ARRPTR(out);

	while( es1 - ARRPTR(s1) < s1->size && es2 - ARRPTR(s2) < s2->size ) {
		int difference;
		if ( es1->keylen == es2->keylen )
			difference=strncmp(ps1, ps2, es1->keylen);
		else
			difference=(es1->keylen > es2->keylen) ? 1 : -1;

		if ( difference == 0 ) {
			memcpy( ed, es2, sizeof(HEntry) );
			memcpy( pd, ps2, es2->keylen + ( (es2->valisnull) ? 0 : es2->vallen ) );
			ed->pos = pd - STRPTR(out);
			pd += es2->keylen + ( (es2->valisnull) ? 0 : es2->vallen );
			ed++;
			
			ps1 += es1->keylen + ( (es1->valisnull) ? 0 : es1->vallen );
			es1++;
			ps2 += es2->keylen + ( (es2->valisnull) ? 0 : es2->vallen );
			es2++;
		} else if ( difference > 0 ) {
			memcpy( ed, es2, sizeof(HEntry) );
			memcpy( pd, ps2, es2->keylen + ( (es2->valisnull) ? 0 : es2->vallen ) );
			ed->pos = pd - STRPTR(out);
			pd += es2->keylen + ( (es2->valisnull) ? 0 : es2->vallen );
			ed++;
			
			ps2 += es2->keylen + ( (es2->valisnull) ? 0 : es2->vallen );
			es2++;
		} else {
			memcpy( ed, es1, sizeof(HEntry) );
			memcpy( pd, ps1, es1->keylen + ( (es1->valisnull) ? 0 : es1->vallen ) );
			ed->pos = pd - STRPTR(out);
			pd += es1->keylen + ( (es1->valisnull) ? 0 : es1->vallen );
			ed++;
			
			ps1 += es1->keylen + ( (es1->valisnull) ? 0 : es1->vallen );
			es1++;
		}
	}

	while( es1 - ARRPTR(s1) < s1->size ) {
		memcpy( ed, es1, sizeof(HEntry) );
		memcpy( pd, ps1, es1->keylen + ( (es1->valisnull) ? 0 : es1->vallen ) );
		ed->pos = pd - STRPTR(out);
		pd += es1->keylen + ( (es1->valisnull) ? 0 : es1->vallen );
		ed++;
			
		ps1 += es1->keylen + ( (es1->valisnull) ? 0 : es1->vallen );
		es1++;
	}

	while( es2 - ARRPTR(s2) < s2->size ) {
		memcpy( ed, es2, sizeof(HEntry) );
		memcpy( pd, ps2, es2->keylen + ( (es2->valisnull) ? 0 : es2->vallen ) );
		ed->pos = pd - STRPTR(out);
		pd += es2->keylen + ( (es2->valisnull) ? 0 : es2->vallen );
		ed++;
		
		ps2 += es2->keylen + ( (es2->valisnull) ? 0 : es2->vallen );
		es2++;
	}

	if ( ed - ARRPTR(out) != out->size ) {
		int buflen=pd-STRPTR(out);
		pd = STRPTR(out);

		out->size = ed - ARRPTR(out);

		memmove( STRPTR(out), pd, buflen);
		out->len = CALCDATASIZE(out->size, buflen);
	}
		
	PG_FREE_IF_COPY(s1,0);
	PG_FREE_IF_COPY(s2,1);

	PG_RETURN_POINTER(out);
}

PG_FUNCTION_INFO_V1(tconvert);
Datum           tconvert(PG_FUNCTION_ARGS);
Datum
tconvert(PG_FUNCTION_ARGS) {
	text   *key = PG_GETARG_TEXT_P(0);
	text   *val = PG_GETARG_TEXT_P(1);
	int len;
	HStore	*out;

	len=CALCDATASIZE(1, VARSIZE(key) + VARSIZE(val) - 2*VARHDRSZ);
	out = palloc(len);
	out->len=len;
	out->size=1;

	ARRPTR(out)->keylen = VARSIZE(key) - VARHDRSZ;
	ARRPTR(out)->vallen = VARSIZE(val) - VARHDRSZ;
	ARRPTR(out)->valisnull = false;
	ARRPTR(out)->pos=0;

	memcpy( STRPTR(out), VARDATA(key), ARRPTR(out)->keylen );
	memcpy( STRPTR(out) + ARRPTR(out)->keylen, VARDATA(val), ARRPTR(out)->vallen );
		
	PG_FREE_IF_COPY(key,0);
	PG_FREE_IF_COPY(val,1);

	PG_RETURN_POINTER(out);
}

PG_FUNCTION_INFO_V1(akeys);
Datum           akeys(PG_FUNCTION_ARGS);
Datum
akeys(PG_FUNCTION_ARGS) { 
	HStore *hs  = PG_GETARG_HS(0);
	Datum	*d;
	ArrayType *a;
	HEntry *ptr=ARRPTR(hs);
	char *base=STRPTR(hs);

	d=(Datum*)palloc(sizeof(Datum)*(hs->size+1));
	while( ptr-ARRPTR(hs) < hs->size ) {
		text *item=(text*)palloc(VARHDRSZ + ptr->keylen);
		VARATT_SIZEP(item) = VARHDRSZ+ptr->keylen;
		memcpy(VARDATA(item), base + ptr->pos, ptr->keylen);
		d[ ptr-ARRPTR(hs) ] = PointerGetDatum(item);
		ptr++;
	}
	
	a = construct_array(
		d,
		hs->size,
		TEXTOID,
		-1,
		false,
		'i'
	);

	ptr=ARRPTR(hs);
	while( ptr-ARRPTR(hs) < hs->size ) {
		pfree(DatumGetPointer(d[ ptr-ARRPTR(hs) ]));
		ptr++;
	}

	pfree(d);
	PG_FREE_IF_COPY(hs,0);

	PG_RETURN_POINTER(a);
}

PG_FUNCTION_INFO_V1(avals);
Datum           avals(PG_FUNCTION_ARGS);
Datum
avals(PG_FUNCTION_ARGS) { 
	HStore *hs  = PG_GETARG_HS(0);
	Datum	*d;
	ArrayType *a;
	HEntry *ptr=ARRPTR(hs);
	char *base=STRPTR(hs);

	d=(Datum*)palloc(sizeof(Datum)*(hs->size+1));
	while( ptr-ARRPTR(hs) < hs->size ) {
		int vallen = (ptr->valisnull) ? 0 : ptr->vallen; 
		text *item=(text*)palloc(VARHDRSZ + vallen);
		VARATT_SIZEP(item) = VARHDRSZ+vallen;
		memcpy(VARDATA(item), base + ptr->pos + ptr->keylen, vallen);
		d[ ptr-ARRPTR(hs) ] = PointerGetDatum(item);
		ptr++;
	}
	
	a = construct_array(
		d,
		hs->size,
		TEXTOID,
		-1,
		false,
		'i'
	);

	ptr=ARRPTR(hs);
	while( ptr-ARRPTR(hs) < hs->size ) {
		pfree(DatumGetPointer(d[ ptr-ARRPTR(hs) ]));
		ptr++;
	}

	pfree(d);
	PG_FREE_IF_COPY(hs,0);

	PG_RETURN_POINTER(a);
}

typedef struct {
	HStore  *hs;
	int 	i;
} AKStore;

static void
setup_firstcall(FuncCallContext  *funcctx, HStore *hs) {
	MemoryContext     oldcontext;
	AKStore     *st;

	oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);

	st=(AKStore*)palloc( sizeof(AKStore) );
	st->i=0;
	st->hs = (HStore*)palloc(hs->len);
	memcpy( st->hs, hs, hs->len );

	funcctx->user_fctx = (void*)st;
	MemoryContextSwitchTo(oldcontext);
}

PG_FUNCTION_INFO_V1(skeys);
Datum           skeys(PG_FUNCTION_ARGS);
Datum
skeys(PG_FUNCTION_ARGS) {
	FuncCallContext  *funcctx;
	AKStore *st;

	if (SRF_IS_FIRSTCALL()) {
		HStore *hs = PG_GETARG_HS(0);
		funcctx = SRF_FIRSTCALL_INIT();
		setup_firstcall(funcctx, hs);
		PG_FREE_IF_COPY(hs,0);
	}

	funcctx = SRF_PERCALL_SETUP();
	st = (AKStore*)funcctx->user_fctx;
	
	if ( st->i < st->hs->size ) {
		HEntry *ptr = &(ARRPTR(st->hs)[st->i]);
		text *item=(text*)palloc(VARHDRSZ + ptr->keylen);

		VARATT_SIZEP(item) = VARHDRSZ+ptr->keylen;
		memcpy(VARDATA(item), STRPTR(st->hs) + ptr->pos, ptr->keylen);
		st->i++;

		SRF_RETURN_NEXT(funcctx, PointerGetDatum(item));
	}
	
	pfree( st->hs );
	pfree( st );

	SRF_RETURN_DONE(funcctx); 
}

PG_FUNCTION_INFO_V1(svals);
Datum           svals(PG_FUNCTION_ARGS);
Datum
svals(PG_FUNCTION_ARGS) {
	FuncCallContext  *funcctx;
	AKStore *st;

	if (SRF_IS_FIRSTCALL()) {
		HStore *hs = PG_GETARG_HS(0);
		funcctx = SRF_FIRSTCALL_INIT();
		setup_firstcall(funcctx, hs);
		PG_FREE_IF_COPY(hs,0);
	}

	funcctx = SRF_PERCALL_SETUP();
	st = (AKStore*)funcctx->user_fctx;
	
	if ( st->i < st->hs->size ) {
		HEntry *ptr = &(ARRPTR(st->hs)[st->i]);

		if ( ptr->valisnull ) {
			ReturnSetInfo      *rsi;

			st->i++;
			(funcctx)->call_cntr++;
			rsi = (ReturnSetInfo *) fcinfo->resultinfo;
			rsi->isDone = ExprMultipleResult;
			PG_RETURN_NULL();
		} else {
			int vallen = ptr->vallen; 
			text *item=(text*)palloc(VARHDRSZ + vallen);

			VARATT_SIZEP(item) = VARHDRSZ+vallen;
			memcpy(VARDATA(item), STRPTR(st->hs) + ptr->pos + ptr->keylen, vallen);
			st->i++;

			SRF_RETURN_NEXT(funcctx, PointerGetDatum(item));
		}
	}
	
	pfree( st->hs );
	pfree( st );

	SRF_RETURN_DONE(funcctx); 
}

PG_FUNCTION_INFO_V1(hs_contains);
Datum           hs_contains(PG_FUNCTION_ARGS);
Datum
hs_contains(PG_FUNCTION_ARGS) {
	HStore *val   = PG_GETARG_HS(0);
	HStore *tmpl  = PG_GETARG_HS(1);
	bool res = true;
	HEntry	*te = ARRPTR(tmpl);
	char	*vv = STRPTR(val);
	char	*tv = STRPTR(tmpl);

	while(res && te-ARRPTR(tmpl) < tmpl->size) {
		HEntry *entry = findkey(val, tv + te->pos, te->keylen);
		if ( entry ) {
			if ( ! te->valisnull ) {
				if ( entry->valisnull || !(
						te->vallen==entry->vallen && 
						strncmp( 
							vv + entry->pos + entry->keylen, 
							tv + te->pos + te->keylen, 
						te->vallen ) == 0
					) )
					res=false;
			}
		} else
			res = false;
		te++;
	}

	PG_FREE_IF_COPY(val,0);
	PG_FREE_IF_COPY(tmpl,1);

	PG_RETURN_BOOL(res);
}
	
PG_FUNCTION_INFO_V1(hs_contained);
Datum           hs_contained(PG_FUNCTION_ARGS);
Datum
hs_contained(PG_FUNCTION_ARGS) {
	PG_RETURN_DATUM( DirectFunctionCall2(
		hs_contains,
		PG_GETARG_DATUM(1),
		PG_GETARG_DATUM(0)
	));
}

PG_FUNCTION_INFO_V1(each);
Datum           each(PG_FUNCTION_ARGS);
Datum
each(PG_FUNCTION_ARGS) {
	FuncCallContext  *funcctx;
	AKStore *st;

	if (SRF_IS_FIRSTCALL()) {
		TupleDesc            tupdesc;
		MemoryContext     oldcontext;
		HStore *hs = PG_GETARG_HS(0);

		funcctx = SRF_FIRSTCALL_INIT();
		oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
		st=(AKStore*)palloc( sizeof(AKStore) );
		st->i=0;
		st->hs = (HStore*)palloc(hs->len);
		memcpy( st->hs, hs, hs->len );
		funcctx->user_fctx = (void*)st;		
			
		tupdesc = RelationNameGetTupleDesc("hs_each");
		funcctx->slot = TupleDescGetSlot(tupdesc);
		funcctx->attinmeta = TupleDescGetAttInMetadata(tupdesc);

		MemoryContextSwitchTo(oldcontext);
		PG_FREE_IF_COPY(hs,0);
	}

	funcctx = SRF_PERCALL_SETUP();
	st = (AKStore*)funcctx->user_fctx;
	
	if ( st->i < st->hs->size ) {
		HEntry *ptr = &(ARRPTR(st->hs)[st->i]);
		Datum res, dvalues[2];
		char       nulls[] = {' ', ' '};
		text *item;
		HeapTuple       tuple;

		item=(text*)palloc(VARHDRSZ + ptr->keylen);
		VARATT_SIZEP(item) = VARHDRSZ+ptr->keylen;
		memcpy(VARDATA(item), STRPTR(st->hs) + ptr->pos, ptr->keylen);
		dvalues[0] = PointerGetDatum(item);

		if ( ptr->valisnull ) {
			dvalues[1]=(Datum)0;
			nulls[1]='n';
		} else {
			int vallen = ptr->vallen; 

			item=(text*)palloc(VARHDRSZ + vallen);
			VARATT_SIZEP(item) = VARHDRSZ+vallen;
			memcpy(VARDATA(item), STRPTR(st->hs) + ptr->pos + ptr->keylen, vallen);
			dvalues[1] = PointerGetDatum(item);
		}
		st->i++;

		tuple = heap_formtuple(funcctx->attinmeta->tupdesc, dvalues, nulls);
		res = TupleGetDatum(funcctx->slot, tuple);

		pfree( DatumGetPointer(dvalues[0]) );
		if ( nulls[1] != 'n' ) 
			pfree( DatumGetPointer(dvalues[1]) );

		SRF_RETURN_NEXT(funcctx, PointerGetDatum(res));
	}
	
	pfree( st->hs );
	pfree( st );

	SRF_RETURN_DONE(funcctx); 
}