#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);
	}
}