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

#include <expValue.h>
#include <ident.h>
#include <evalExpr.h>
#include <evalCond.h>
#include <variable.h>
#include <assign.h>
#include <cast.h>
#include <tepal_pars.h>
#include <block.h>

#include <statement.h>

/*
 * Deklaration und Definition
 */
#include <stmtQueue.h>

struct stmt
{
	int           sId;
	s_stmtQueue * sQueue;
	u_stmtType    sConst;
	int           sConstTyp;
};

/*
 * statische Funktionen (interner gebrauch)
 */
static
inline
	u_stmtType
stmtEval(s_stmt * stmt, s_block * actBlock, int op)
{
	s_stmtQueue * args = stmt->sQueue;
	s_expVal    * op1  = stmtDo(stmtQueueGet(args, 0), actBlock).eVal,
	            * op2  = stmtDo(stmtQueueGet(args, 1), actBlock).eVal,
				* ret;

	ret = evalExpr(op, op1, op2);

	if (op1 != NULL) expValueFree(op1);
	if (op2 != NULL) expValueFree(op2);

	return (u_stmtType)ret;
}

static
inline
	u_stmtType
stmtIdentVar(s_stmt * stmt, s_block * actBlock)
{
	s_ident * ret = NULL;

	s_stmtQueue * args = stmt->sQueue;
	s_expVal    * _op  = stmtDo(stmtQueueGet(args, 0), actBlock).eVal;
	char        * op   = expValueString(_op);
	s_block     * run  = actBlock;

	while (ret == NULL && run != NULL) {
		ret = identListSeekKey(blockIdl(run), op);
		run = blockPrev(run);
	}

	if (ret == NULL) {
		ret = identListPutVal(blockIdl(actBlock), identUndefNew(-1, op));
	}

	expValueFree(_op);
	free(op);

	return (u_stmtType)ret;
}

static
inline
	u_stmtType
stmtIdentArray(s_stmt * stmt, s_block * actBlock)
{
	s_stmtQueue * args = stmt->sQueue;
	s_ident     * op1  = stmtDo(stmtQueueGet(args, 0), actBlock).idVal;
	s_expVal    * op2  = stmtDo(stmtQueueGet(args, 1), actBlock).eVal;
	s_ident     * ret;

	ret = getArray(op1, op2);

	if (op2 != NULL) expValueFree(op2);

	return (u_stmtType)ret;
}

static
inline
	u_stmtType
stmtIdentVal(s_stmt * stmt, s_block * actBlock)
{
	s_stmtQueue * args = stmt->sQueue;
	s_ident     * op1  = stmtDo(stmtQueueGet(args, 0), actBlock).idVal;

	return (u_stmtType)identExp(op1);
}

static
inline
	u_stmtType
stmtEvalComp(s_stmt * stmt, s_block * actBlock, int op)
{
	s_stmtQueue * args = stmt->sQueue;
	s_expVal    * op1  = stmtDo(stmtQueueGet(args, 0), actBlock).eVal,
	            * op2  = stmtDo(stmtQueueGet(args, 1), actBlock).eVal;
	int           ret;

	ret = evalComp(op, op1, op2);

	if (op1 != NULL) expValueFree(op1);
	if (op2 != NULL) expValueFree(op2);

	return (u_stmtType)ret;
}

static
inline
	u_stmtType
stmtAssign(s_stmt * stmt, s_block * actBlock)
{
	s_stmtQueue * args = stmt->sQueue;
	s_ident     * op1 = stmtDo(stmtQueueGet(args, 0), actBlock).idVal;
	s_expVal    * op2 = stmtDo(stmtQueueGet(args, 1), actBlock).eVal,
                * ret;

	if (op1 == NULL) op1 = getVariable(NULL, NULL);

	ret = assign(op1, op2);

	if (op2 != NULL) expValueFree(op2);

	return (u_stmtType)ret;
}

static
inline
	u_stmtType
stmtPrint(s_stmt * stmt, s_block * actBlock)
{
	s_stmtQueue * args = stmt->sQueue;
	s_expVal    * op   = stmtDo(stmtQueueGet(args, 0), actBlock).eVal;

	if (op != NULL) {
		printExpr(op);
		expValueFree(op);
	}

	return (u_stmtType)0;
}

static
inline
	u_stmtType
stmtEvalCondExpr(s_stmt * stmt, s_block * actBlock)
{
	s_stmtQueue * args = stmt->sQueue;
	s_expVal    * op   = stmtDo(stmtQueueGet(args, 0), actBlock).eVal;
	int           ret;

	ret = evalCondExpr(op);

	if (op != NULL) expValueFree(op);

	return (u_stmtType)ret;
}

static
inline
	u_stmtType
stmtEvalCond(s_stmt * stmt, s_block * actBlock, int op)
{
	s_stmtQueue * args = stmt->sQueue;
	int           op1  = stmtDo(stmtQueueGet(args, 0), actBlock).cond;

	switch (op) {
		case LOGAND:
			{
				int op2 = stmtDo(stmtQueueGet(args, 1), actBlock).cond;
				return (u_stmtType)(op1 && op2);
			}
		case LOGOR:
			{
				int op2 = stmtDo(stmtQueueGet(args, 1), actBlock).cond;
				return (u_stmtType)(op1 || op2);
			}
		case LOGNEG:
			return (u_stmtType)(! op1);
	}
}

static
inline
	u_stmtType
stmtCastInt(s_stmt * stmt, s_block * actBlock)
{
	s_stmtQueue * args = stmt->sQueue;
	s_expVal    * op   = stmtDo(stmtQueueGet(args, 0), actBlock).eVal,
                * ret;

	ret = castExprToInt(op);

	if (op != NULL) expValueFree(op);

	return (u_stmtType)ret;
}

static
inline
	u_stmtType
stmtCastFloat(s_stmt * stmt, s_block * actBlock)
{
	s_stmtQueue * args = stmt->sQueue;
	s_expVal * op = stmtDo (stmtQueueGet (args, 0), actBlock).eVal,
	         * ret;

	ret = castExprToFloat(op);

	if (op != NULL) expValueFree(op);

	return (u_stmtType)ret;
}

static
inline
	u_stmtType
stmtCastString(s_stmt * stmt, s_block * actBlock)
{
	s_stmtQueue * args = stmt->sQueue;
	s_expVal    * op   = stmtDo(stmtQueueGet (args, 0), actBlock).eVal,
	            * ret;

	ret = castExprToString(op);

	if (op != NULL) expValueFree(op);

	return (u_stmtType)ret;
}

static
inline
	u_stmtType
stmtBlock(s_stmt * stmt, s_block * actBlock)
{
	unsigned int  i;

	s_stmtQueue * gIds   = stmtQueueGet(stmt->sQueue, 0)->sQueue;
	s_stmtQueue * args   = stmtQueueGet(stmt->sQueue, 1)->sQueue;
	s_block     * gBlock = NULL;

	gBlock = actBlock = blockPush(&actBlock, blockNew (args));

	/* find the global block */
	while (blockPrev(gBlock) != NULL)
		gBlock = blockPrev(gBlock);

	if (gIds != NULL) {
		for (i=0; i < stmtQueueGetSize(gIds); i++) {
			s_expVal * tmp = stmtDo(stmtQueueGet (gIds, i), actBlock).eVal;
			char     * _id;
			s_ident  * id;

			if (tmp == NULL) exitError (0);

			_id = expValueString(tmp);
			id = identListSeekKey(blockGetIdl (gBlock), _id);
			expValueFree(tmp);
			free(_id);

			if (id == NULL) exitError (0);

			blockSetNonLocalId(gBlock, id);
		}
	}

	blockDo(actBlock);
	blockFree(actBlock);

	return (u_stmtType)0;
}

static
inline
	u_stmtType
stmtIf(s_stmt * stmt, s_block * actBlock)
{
	s_stmtQueue * args = stmt->sQueue;
	int           cond = stmtDo(stmtQueueGet (args, 0), actBlock).cond;
	s_stmt *      _do;

	if (cond) _do = stmtQueueGet(args, 1);
	else _do = stmtQueueGet(args, 2);

	if (_do != NULL) stmtDo(_do, actBlock);

	return (u_stmtType)0;
}

static
inline
	u_stmtType
stmtForeach(s_stmt * stmt, s_block * actBlock)
{
	s_stmtQueue * args = stmt->sQueue;
	s_expVal    * _id  = stmtDo(stmtQueueGet (args, 0), actBlock).eVal,
	            * _key = stmtDo(stmtQueueGet (args, 1), actBlock).eVal,
	            * _val = stmtDo(stmtQueueGet (args, 2), actBlock).eVal;
	char        * id   = expValueString(_id);
	char        * key  = expValueString(_key);
	char        * val  = expValueString(_val);

	printf("[DEBUG]found foreach statement: id=%s, key=%s, val=%s\n",
			id, key, val);

	free(id);
	free(key);
	free(val);

	expValueFree(_id);
	expValueFree(_key);
	expValueFree(_val);

	return (u_stmtType)0;
}

static
inline
	u_stmtType
stmtRepeat(s_stmt * stmt, s_block * actBlock)
{
	s_stmtQueue * args   = stmt->sQueue;
	s_expVal    * _id    = stmtDo(stmtQueueGet (args, 0), actBlock).eVal,
	            * _count = stmtDo(stmtQueueGet (args, 1), actBlock).eVal;
	char        * id     = expValueString(_id);
	int           count  = expValueInt(_count);

	printf("[DEBUG]found repeat statement: id=%s, count=%d\n", id, count);

	free(id);

	expValueFree(_id);
	expValueFree(_count);

	return (u_stmtType)0;
}

/*
 * Interface
 */
	s_stmt *
stmtNew(int id, s_stmtQueue * queue, int conTyp, u_stmtType con)
{
	s_stmt * new = (s_stmt *)malloc(sizeof(s_stmt));

	new->sId       = id;
	new->sQueue    = queue;
	new->sConstTyp = conTyp;
	new->sConst    = con;

	return new;
}

	s_stmtQueue *
stmtGetArgs(s_stmt * stmt)
{
	return stmt->sQueue;
}

	u_stmtType
stmtGetVal(s_stmt * stmt)
{
	return stmt->sConst;
}

	int
stmtGetConstTyp(s_stmt * stmt)
{
	return stmt->sConstTyp;
}

	void
stmtFree(s_stmt * stmt)
{
	if (stmt == NULL) return;

	switch(stmt->sConstTyp) {
		case STYP_NONE: stmtQueueFree (stmt->sQueue); break;
		case STYP_EVAL: expValueFree (stmt->sConst.eVal); break;
		case STYP_IDVAL: identFree (stmt->sConst.idVal); break;
	}

	free(stmt);
}

	u_stmtType
stmtDo(s_stmt * stmt, s_block * actBlock)
{
	if (stmt == NULL) return (u_stmtType)0;

	switch (stmt->sId) {
		case STMT_CONST:
			return (u_stmtType)expValueClone(stmt->sConst.eVal);
		case STMT_BLOCK:
			return stmtBlock(stmt, actBlock);
		case STMT_PRINT:
			return stmtPrint(stmt, actBlock);
		case STMT_IF:
			return stmtIf(stmt, actBlock);
		case STMT_FOREACH:
			return stmtForeach(stmt, actBlock);
		case STMT_REPEAT:
			return stmtRepeat(stmt, actBlock);
		case STMT_ASSIGN:
			return stmtAssign(stmt, actBlock);
		case STMT_UNSET:
			return (u_stmtType)0;
		case STMT_EVAL_PLUS:
			return stmtEval(stmt, actBlock, PLUS);
		case STMT_EVAL_MINUS:
			return stmtEval(stmt, actBlock, MINUS);
		case STMT_EVAL_TIMES:
			return stmtEval(stmt, actBlock, TIMES);
		case STMT_EVAL_OVER:
			return stmtEval(stmt, actBlock, OVER);
		case STMT_EVAL_MODULO:
			return stmtEval(stmt, actBlock, MODULO);
		case STMT_EVAL_NEG:
			return stmtEval(stmt, actBlock, NEG);
		case STMT_IDENT_VAR:
			return stmtIdentVar(stmt, actBlock);
		case STMT_IDENT_ARRAY:
			return stmtIdentArray(stmt, actBlock);
		case STMT_IDENT_VAL:
			return stmtIdentVal(stmt, actBlock);
		case STMT_CAST_INT:
			return stmtCastInt(stmt, actBlock);
		case STMT_CAST_FLOAT:
			return stmtCastFloat(stmt, actBlock);
		case STMT_CAST_STRING:
			return stmtCastString(stmt, actBlock);
		case STMT_COMP_EQ:
			return stmtEvalComp(stmt, actBlock, EQ);
		case STMT_COMP_NE:
			return stmtEvalComp(stmt, actBlock, NE);
		case STMT_COMP_LT:
			return stmtEvalComp(stmt, actBlock, LT);
		case STMT_COMP_GT:
			return stmtEvalComp(stmt, actBlock, GT);
		case STMT_COMP_LE:
			return stmtEvalComp(stmt, actBlock, LE);
		case STMT_COMP_GE:
			return stmtEvalComp(stmt, actBlock, GE);
		case STMT_COND_EXPR:
			return stmtEvalCondExpr(stmt, actBlock);
		case STMT_COND_AND:
			return stmtEvalCond(stmt, actBlock, LOGAND);
		case STMT_COND_OR:
			return stmtEvalCond(stmt, actBlock, LOGOR);
		case STMT_COND_NEG:
			return stmtEvalCond(stmt, actBlock, LOGNEG);
	}
}