/*------------------------------------------------------------------
 * Glue for libpsyc.
 *------------------------------------------------------------------
 * test LPC code:
 *
	// doesn't work with (int *) yet
	mixed* x = psyc_parse(":_context\ttest\n\n:_topic\ttesting\n_notice_test_libpsyc\nJust [_topic] libpsyc.\n|\n");
	mixed y = psyc_render(x);
	mixed z = ({ ([ "_context": "test" ]), ([ "_topic": "testing" ]), "_notice_test_libpsyc", "Just [_topic] libpsyc." });
	z = psyc_render(z);
	// psyc_render currently having some memory corruption problems
	debug_message(sprintf("libpsyc returned %O, %O and %O (%s)\n", x, y, z,
			y == z? "success": "FAIL!"));
 *
 */

#include "array.h"
#include "interpret.h"
#include "mapping.h"
#include "mstrings.h"
#include "pkg-psyc.h"
#include "simulate.h"
#include "xalloc.h"

#ifdef USE_PSYC

# include "pkg-psyc.h"

# include <stdio.h>
# include <unistd.h>
# include <fcntl.h>

# include <psyc.h>
# include <psyc/parser.h>
# include <psyc/render.h>

/*-------------------------------------------------------------------------*/
// old: string  psyc_render(mapping, mapping, string, int* | string);
// new: string  psyc_render(mixed*);

svalue_t *
f_psyc_render(svalue_t *sp) {
    mp_int i;
    vector_t *v;
    psycPacket packet;
    string_t *out;
    char *meth, *body;
    size_t mlen, blen;
    mapping_t *map;

    // unless (sp->type == T_POINTER) return sp;
    v = sp->u.vec;
    if ((i = (mp_int)VEC_SIZE(v)) != 1+PSYC_BODY) {
	errorf("Wrong number of elements (%"PRIdMPINT") in array argument to psyc_render()\n", i);
	/* NOTREACHED */
	return sp;
    }
    if (v->item[PSYC_ROUTING].type == T_MAPPING) {
	map = v->item[PSYC_ROUTING].u.map;
    } else {
	map = NULL;
    }

#if 0
    if (v->item[PSYC_METHOD].type != T_STRING) {
	errorf("Wrong type for PSYC_METHOD element in PSYC packet.\n");
	/* NOTREACHED */
	return sp;
    }
    if (v->item[PSYC_BODY].type != T_STRING) {
	errorf("Wrong type for PSYC_BODY element in PSYC packet.\n");
	/* NOTREACHED */
	return sp;
    }
#else
    if (v->item[PSYC_METHOD].type == T_STRING) {
	meth = get_txt(v->item[PSYC_METHOD].u.str);
	mlen = mstrsize(v->item[PSYC_METHOD].u.str);
    } else {
	meth = NULL;
	mlen = 0;
    }
    if (v->item[PSYC_BODY].type == T_STRING) {
	body = get_txt(v->item[PSYC_BODY].u.str);
	blen = mstrsize(v->item[PSYC_BODY].u.str);
    } else {
	body = NULL;
	blen = 0;
    }
#endif
    // TODO: handle _lists
    // FIXME: handle mappings
    packet = psyc_newPacket2(NULL, 0, NULL, 0,
			     meth, mlen, body, blen,
			     PSYC_PACKET_CHECK_LENGTH);

    printf("rendering... packet.length = %ld\n", packet.length);
    // alloc_mstring creates an *untabled* string suitable for tmp data 
    memsafe(out = alloc_mstring(packet.length), packet.length, "f_psyc_render");
    psyc_render(&packet, get_txt(out), packet.length);

    free_svalue(sp);
    put_string(sp, out);
    // stack should take care of freeing the string after use
    return sp;

} /* f_psyc_render */

/*-------------------------------------------------------------------------*/
//  mixed   psyc_parse(int* | string);

svalue_t *
f_psyc_parse (svalue_t *sp) {
    string_t *str = NULL;
    vector_t *v;
    mapping_t *map;
    svalue_t *sv;
    mp_int i;
    char oper = 0;
    psycString name = {0,0}, value = {0,0}, elem = {0,0};
    psycParseListState listState;
    int ret;
    size_t len;

    psycState *state = O_GET_PSYC_STATE(current_object);
    if (!state) {
	state = pxalloc(sizeof(psycState));
	if (!state) errorf("Out of memory for psyc state struct.\n");
	O_GET_PSYC_STATE(current_object) = state;
	state->parser = pxalloc(sizeof(psycParseState));
	if (!state->parser) errorf("Out of memory for psyc parse state struct.\n");
	psyc_initParseState(state->parser);
    }

    i = 0;
    if (sp->type == T_POINTER) {
	errorf("\npsyc_parse got %ld int* bytes... not supported yet\n", i);
    }
    else if (sp->type == T_STRING) {
	printf("\npsyc_parse got a %ld bytes long string...\n", mstrsize(sp->u.str));
	psyc_setParseBuffer(state->parser, psyc_newString(get_txt(sp->u.str),
							  mstrsize(sp->u.str)));
    }

    if (!state->packet) {
	state->packet = allocate_array(4);
	if (!state->packet) errorf("Out of memory for psyc_parse array.\n");
    }
    v = state->packet;

    map = allocate_mapping( 0, 1 );	// empty mapping
    if (!map) errorf("Out of memory for psyc_parse routing header.\n");
    put_mapping(&v->item[PSYC_ROUTING], map);
    map = allocate_mapping( 0, 1 );	// empty mapping
    if (!map) errorf("Out of memory for psyc_parse entity header.\n");
    put_mapping(&v->item[PSYC_ENTITY], map);

    do {
	ret = psyc_parse(state->parser, &oper, &name, &value);

	switch (ret) {
	    case PSYC_PARSE_ENTITY_START: case PSYC_PARSE_BODY_START:
		if ((len = psyc_getParseValueLength(state->parser)))
		    state->tmp = pxalloc(len);
	    case PSYC_PARSE_ENTITY_CONT:  case PSYC_PARSE_BODY_CONT:
	    case PSYC_PARSE_ENTITY_END:   case PSYC_PARSE_BODY_END:
		memcpy(state->tmp + state->tmplen, value.ptr, value.length);
		state->tmplen += value.length;
	}

	switch (ret) {
	case PSYC_PARSE_ROUTING:
		if (oper != ':') {
			puts("_failure_unsupported_state");
			continue;
		}
		sv = pxalloc(sizeof(svalue_t));
		// new_n_tabled fetches a reference of a probably existing
		// shared string
		put_string(sv, new_n_tabled(name.ptr, name.length));
		sv = get_map_lvalue(v->item[PSYC_ROUTING].u.map, sv);
		// strings are capable of containing 0 so we can do this
		// for binary data too. let's use a tabled string even
		// for values of routing variables as they repeat a lot
		put_string(sv, new_n_tabled(value.ptr, value.length));
		break;
	case PSYC_PARSE_ENTITY_START:
	case PSYC_PARSE_ENTITY_CONT:
	case PSYC_PARSE_ENTITY_END:
	case PSYC_PARSE_ENTITY:
		if (oper && oper != ':') {
			puts("_failure_unsupported_state");
			continue;
		}
		if (name.length) {
		    sv = pxalloc(sizeof(svalue_t));
		    put_string(sv, new_n_tabled(name.ptr, name.length));
		    sv = get_map_lvalue(v->item[PSYC_ENTITY].u.map, sv);
		}

		// is it good to put entity variable values into the
		// shared string table? probably yes.. but it's a guess
		//t_string(sv, new_n_mstring(value.ptr, value.length));
		put_string(sv, new_n_tabled(value.ptr, value.length));

		// list parsing not supported yet.. TODO
		if (name.length >= 5 && memcmp(name.ptr, "_list", 5) == 0)
		{
			write(1, ">>> LIST START\n", 15);
			psyc_initParseListState(&listState);
			psyc_setParseListBuffer(&listState, value);
			while ((ret = psyc_parseList(&listState, &name, &value, &elem)))
			{
				switch (ret)
				{
					case PSYC_PARSE_LIST_END:
					case PSYC_PARSE_LIST_ELEM:
						write(1, "|", 1);
						write(1, elem.ptr, elem.length);
						write(1, "\n", 1);
						break;
					default:
						errorf("Error while parsing PSYC list: %i\n", ret);
						/* NOTREACHED */
						return sp;
				}

				if (ret == PSYC_PARSE_LIST_END)
				{
					write(1, ">>> LIST END\n", 13);
					break;
				}
			}
		}
		break;
	case PSYC_PARSE_BODY_START:
	case PSYC_PARSE_BODY_CONT:
	case PSYC_PARSE_BODY_END:
	case PSYC_PARSE_BODY:
		if (str) errorf("Got two PSYC methods in the same packet!?\n");
		// new_n_tabled gets the shared string for the method
		put_string(&v->item[PSYC_METHOD],
		    new_n_tabled(name.ptr, name.length));

		// allocate an untabled string for the packet body
		put_string(&v->item[PSYC_BODY],
			   new_n_mstring(value.ptr, value.length));

		break;
	case PSYC_PARSE_COMPLETE:
		ret = 0;
		break;
	case PSYC_PARSE_INSUFFICIENT:
		errorf("Insufficient PSYC data.\n");
		/* NOTREACHED */
		return sp;
	default:
		errorf("Error while parsing PSYC: %i\n", ret);
		/* NOTREACHED */
		return sp;
	}
    } while (ret);

    free_svalue(sp);
    put_array(sp, v);
    state->packet = 0;
    return sp;

} /* f_psyc_parse */

#endif /* USE_PSYC */