/* 
*
*  ProLinga-Run
*
*  Copyright (C) 2002-2009 Xobas Software.
*  All rights reserved.
*  
*  This file is part of ProLinga-Run.
*
*  ProLinga-Run is free software: you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  ProLinga-Run is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with ProLinga-Run.  If not, see <http://www.gnu.org/licenses/>.
*
*  More information is available at the following addresses:
*
*  Website     : http://www.prolinga.org
*
*  Email       : prolinga-list@prolinga.org
*
*
*/
#include "RunCommon.h"
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include <libxml/xpath.h>
//#include <glade/glade.h>
#include "DocMgmt.hpp"
#include "RunExec.hpp"
#include "LogicCommands.hpp"
#include "DataRef.hpp"
#include "Logic.hpp"
#include "RepositoryCommand.hpp"

/* Stack with pointers to Local Variable Lists */
extern LocalDicPtr ldicPtr;
extern ParameterStackPtr pstackPtr;
extern DataReturnStackPtr dstackPtr;
extern BiAppnPtr biAppnPtr;

/* Current/Active Local Variable List */
DataDictionaryPtr dicPtr = NULL;

/* Current/Active Parameter List */
ParameterPtr paramPtr = NULL;

/* Current/Active Data Return List */
DataReturnPtr dataPtr = NULL;

/* Command : CALL */
/* Syntax  : [ ret_value = ] CALL logic_name [ argument ...] [ RETURNING ret_value [ ret_value ...] ] */
void CmdCall(const char **argList, int argHits, bool isMainThread, bool idleEvent)
{
	xmlDocPtr doc = NULL, docVal = NULL;
	xmlXPathContextPtr ctxVal;
	xmlXPathObjectPtr resVal;
	int i, j, dataReturnNumber = 0, status;
	char tmpValue[255], *logicName, *returnStatus, returnRef[255];
	char *dataRefName, *dataRefValue, *errorStart, *errorEnd;
	const char *errorList[5];
	ParameterPtr paramLocalPtr = NULL;

	/* Get Logic Name */
	logicName = getDataRef(argList[1], isMainThread, tmpValue, false);

	/* Get Parameters */

	/* One of the parameters can be a local variable 
	so we need to get to that value before we stack it */
	paramLocalPtr = paramLocalPtr->createList();
	j = 0;
	for (i = 2; i <= argHits; i++)
	{
		if (strcmp(argList[i], "RETURNING") == 0)
			break;

		/* Get Value data reference */
		getDataRef(argList[i], isMainThread, returnRef, false);

		/* Put Value */
		paramLocalPtr->putValue(&paramLocalPtr, j, returnRef);

		/* Raise counter */
		j++;
	}

	/* Prepare parameter list */
	paramPtr = paramPtr->createList();
	pstackPtr->push(&pstackPtr, paramPtr);

	/* Prepare data return list */
	dataPtr = dataPtr->createList();
	dstackPtr->push(&dstackPtr, dataPtr);

	/* Prepare logic variable list */
	dicPtr = dicPtr->createList();
	ldicPtr->push(&ldicPtr, dicPtr);

	/* Set Parameters in current list */
	j = 0;
	for (i = 2; i <= argHits; i++)
	{
		if (strcmp(argList[i], "RETURNING") == 0)
			break;

		/* Put Value */
		paramPtr->putValue(&paramPtr, j, paramLocalPtr->getValue(paramLocalPtr, j));

		/* Raise counter */
		j++;
	}

	/* Delete local parameter list */
	paramPtr->deleteList(&paramLocalPtr);

	/* Get Data Return dataReference Values */
	if ( (i <= argHits ) &&  (strcmp(argList[i], "RETURNING") == 0) )
	{
		i++;
		dataReturnNumber = 0;
		for (j = i; j <= argHits; j++)
		{
			/* Put Dataref Name */
			dataPtr->putDataRefName(&dataPtr, dataReturnNumber, argList[j]);
			//printf("Returning : %s\n", argList[j]);
			
			/* Raise counter */
			dataReturnNumber++;
		}
	}
	/* Load Validated Logic */
	docVal = RC_Get(biAppnPtr->getAppn(), "RunControl", logicName);

	/* Init Xpath */
//	xmlXPathInit();

	/* Create XPath environment */
	ctxVal = xmlXPathNewContext(docVal);

	/* Check status */
	resVal = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/@Status", ctxVal);
	returnStatus = (char *)xmlXPathCastToString(resVal);
	if ( strcmp(returnStatus, "Ok") != 0)
	{
		errorStart = new char[7];
		strncpy(errorStart, "Logic [", 7);
		errorEnd = new char[17];
		strncpy(errorEnd, "] does not exist.", 17);
		errorList[1] = errorStart;
		errorList[2] = logicName;
		errorList[3] = errorEnd;
		CmdError(errorList, 3, isMainThread, NULL, idleEvent);
		delete errorStart;
		delete errorEnd;
		return;

		/* Old situation. To be removed when all transformed */
//		printf("Non transformed logic : %s\n", logicName);
//
//		strcpy(fileName, "./");
//		strcat(fileName, tmpValue);
//		//strcat(fileName, argList[1]);
//		strcat(fileName,".xml");
//
//		/* Load run document */
//		status = RunOpen(fileName, &doc);
//		if (status != 0) return;
	}
	else
	{
		//printf("Transformed logic : %s\n", logicName);

		status = RunLoad(docVal, &doc);
		if (status != 0) return;
	}

	/* Run statements */
	status = RunExec(&doc, idleEvent);

	/* Clean up local dictionaries */
	dicPtr->deleteList(&dicPtr);
	ldicPtr->pop(&ldicPtr);
	dicPtr = ldicPtr->getValue(ldicPtr);

	/* Assign returning values to data references */
	if (dataReturnNumber > 0 )
	{
		for (i = 0; i < dataReturnNumber; i++)
		{
			/* Get Data Reference Name */
			dataRefName = dataPtr->getDataRefName(dataPtr, i);

			/* Get Data Reference Value */
			dataRefValue = dataPtr->getDataRefValue(dataPtr, i);

			/* Assign value to data reference */
			if (dataRefValue == NULL)
				putDataRef(dataRefName, NULL, 0, isMainThread);
			else
				putDataRef(dataRefName, dataRefValue, 0, isMainThread);
		}
	}
	

	/* Cleanup */
 	RunCleanup(&doc);
	xmlFreeDoc(docVal);

	paramPtr->deleteList(&paramPtr);
	pstackPtr->pop(&pstackPtr);
	paramPtr = pstackPtr->getValue(pstackPtr);

	dataPtr->deleteList(&dataPtr);
	dstackPtr->pop(&dstackPtr);
	dataPtr = dstackPtr->getValue(dstackPtr);

}