/* 
*
*  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 <gtk/gtk.h>
#include <pthread.h>
#include "RepositoryCommand.hpp"
#include "DataRef.hpp"
#include "CmdList.hpp"
#include "Thread.hpp"

/* Datastore for List Views */
extern ListStorePtr listStorePtr;
extern ThreadPtr threadPtr;

/* BuiltIn Functions */
extern BiAppnPtr biAppnPtr;
extern BiAppnDevPtr biAppnDevPtr;
extern BiDataModelStatusPtr biDataModelStatusPtr;
extern BiErrorReturnPtr biErrorReturnPtr;
extern BiValidateStatusPtr biValidateStatusPtr;
extern BiSqlInfoPtr biSqlInfoPtr;
extern BiSqlReturnPtr biSqlReturnPtr;
extern BiSqlStatusPtr biSqlStatusPtr;
extern BiRepositoryStatusPtr biRepositoryStatusPtr;
extern BiTableStatusPtr biTableStatusPtr;
extern BiThreadStatusPtr biThreadStatusPtr;
//extern CaPassPtr caPassPtr;
extern BiTextStatusPtr biTextStatusPtr;
extern BiUserPtr biUserPtr;
extern BiXmlStatusPtr biXmlStatusPtr;
extern BiQuitLastScreenPtr biQuitLastScreenPtr;

void ResetBuiltIns()
{
	biAppnPtr->setAppn("Administrator");
	biAppnDevPtr->setAppnDev("");
	biDataModelStatusPtr->setDataModelStatus(0);
	biErrorReturnPtr->setErrorReturn(0);
	biValidateStatusPtr->setValidateStatus(0);
	biSqlInfoPtr->setSqlInfo(NULL);
	biSqlReturnPtr->setSqlReturn(0);
	biSqlStatusPtr->setSqlStatus(0);
	biRepositoryStatusPtr->setRepositoryStatus(0);
	biTableStatusPtr->setTableStatus(0);
	biQuitLastScreenPtr->setQuitLastScreen(0);
	biThreadStatusPtr->setThreadStatus(0);
	biTextStatusPtr->setTextStatus(0);
	biXmlStatusPtr->setXmlStatus(0);
//	biPassPtr->setPass(BI_TYPE_INT, (void *)0);
}

/* START APPN */

BiAppn::BiAppn()
{
	strcpy(appn, "");
}

BiAppn::~BiAppn()
{
	return;
}

char *BiAppn::getAppn()
{
	return appn;
}

void BiAppn::setAppn(const char *application)
{
	strcpy(appn, application);
}

/* END APPN */

/* START APPN DEV*/

BiAppnDev::BiAppnDev()
{
	strcpy(appnDev, "");
}

BiAppnDev::~BiAppnDev()
{
	return;
}

char *BiAppnDev::getAppnDev()
{
	return appnDev;
}

void BiAppnDev::setAppnDev(const char *application)
{
	strcpy(appnDev, application);
}

/* END APPN DEV*/

/* START DATASESSION */

CaDataSession::CaDataSession()
{
	sessionId = NULL;
	dataSourceName = NULL;
	extDataSource = NULL;
	nextPtr = NULL;
}

CaDataSession::~CaDataSession()
{
	if (sessionId != NULL)
		delete sessionId;

	if (dataSourceName != NULL)
		delete dataSourceName;

	if (extDataSource != NULL)
		delete extDataSource;
}

char *CaDataSession::getDataSessionId(CaDataSession *caDataSesPtr, const char *dataSource)
{
	CaDataSessionPtr curPtr;

	/* Get DataSessionId (if exists) */
	curPtr = caDataSesPtr;

	while (curPtr != NULL)
	{
		if (strcmp(curPtr->dataSourceName, dataSource) == 0)
			return curPtr->sessionId;

		curPtr = curPtr->nextPtr;
	}
	return NULL;
}

char *CaDataSession::getExternalDataSource(CaDataSession *caDataSesPtr, const char *dataSource)
{
	CaDataSessionPtr curPtr;

	/* Get Ext DataSourceName (if exists) */
	curPtr = caDataSesPtr;

	while (curPtr != NULL)
	{
		if (strcmp(curPtr->dataSourceName, dataSource) == 0)
			return curPtr->extDataSource;

		curPtr = curPtr->nextPtr;
	}
	return NULL;
}

void CaDataSession::putDataSession(CaDataSession **caDataSesPtr, const char *session, const char *dataSource, const char *external)
{
	CaDataSessionPtr curPtr, newPtr;

	/* Get Session Id or DataSourceName (if exists) */
	curPtr = *caDataSesPtr;

	while (curPtr != NULL)
	{
		if ((strcmp(curPtr->sessionId, session) == 0) || (strcmp(curPtr->dataSourceName, dataSource) == 0))
		{
			/* Clean up */
			if (curPtr->sessionId != NULL)
				delete curPtr->sessionId;

			if (curPtr->dataSourceName != NULL)
				delete curPtr->dataSourceName;

			if (curPtr->extDataSource != NULL)
				delete curPtr->extDataSource;

			curPtr->sessionId = new char[strlen(session)+1];
			strcpy(curPtr->sessionId, session);

			curPtr->dataSourceName = new char[strlen(dataSource)+1];
			strcpy(curPtr->dataSourceName, dataSource);

			curPtr->extDataSource = new char[strlen(external)+1];
			strcpy(curPtr->extDataSource, external);
			return;		
		}

		curPtr = curPtr->nextPtr;
	}
	
	/* Create new value */
	newPtr = new CaDataSession;
	newPtr->sessionId = new char[strlen(session)+1];
	newPtr->dataSourceName = new char[strlen(dataSource)+1];
	newPtr->extDataSource = new char[strlen(external)+1];
	strcpy(newPtr->sessionId, session);
	strcpy(newPtr->dataSourceName, dataSource);
	strcpy(newPtr->extDataSource, external);

	/* Prepend in list */
	newPtr->nextPtr = *caDataSesPtr;
	*caDataSesPtr = newPtr;
}

int CaDataSession::deleteDataSession(CaDataSession **caDataSesPtr, const char *dataSource)
{

	CaDataSessionPtr prevPtr, curPtr, nextPtr;
	int retStatus = 44444;

	prevPtr = NULL;
	curPtr = *caDataSesPtr;
	nextPtr = NULL;

	while (curPtr != 0)
	{
		nextPtr = curPtr->nextPtr;
		
		if (strcmp(curPtr->dataSourceName, dataSource) == 0)
		{
			/* Unlink DataSession */
			if (prevPtr == NULL)
				*caDataSesPtr = nextPtr;
			else
				prevPtr->nextPtr = nextPtr;

			/* Delete DataSession */
			delete curPtr;

			/* Set Return Status */
			retStatus = 0;
			break;
		}

		prevPtr = curPtr;
		curPtr = nextPtr;
	}

	/* Return */
	return retStatus;
}

void CaDataSession::deleteList(CaDataSession **caDataSesPtr)
{
	CaDataSessionPtr tmpPtr;
                                                                                                   
        while (*caDataSesPtr != NULL)
        {
                tmpPtr = *caDataSesPtr;
                *caDataSesPtr = (*caDataSesPtr)->nextPtr;
                delete tmpPtr;
        }
}
                                                                                                   
void CaDataSession::printList(CaDataSession *caDataSesPtr) const
{
        CaDataSessionPtr curPtr;
                                                                                                   
        curPtr = caDataSesPtr;
        while (curPtr != NULL)
        {
                printf("Session Id %s - DataSource Name %s\n", curPtr->sessionId, curPtr->dataSourceName);
                curPtr = curPtr->nextPtr;
        }
}

/* END DATASESSION */


/* START DATAMODELSTATUS */

BiDataModelStatus::BiDataModelStatus()
{
	dataModelStatus = 0;
}

BiDataModelStatus::~BiDataModelStatus()
{
	return;
}

int BiDataModelStatus::getDataModelStatus()
{
	return dataModelStatus;
}

void BiDataModelStatus::setDataModelStatus(int status)
{
	dataModelStatus = status;
}

/* END DATAMODELSTATUS */


/* START ERRORRETURN */

BiErrorReturn::BiErrorReturn()
{
	errorReturn = 0;
}

BiErrorReturn::~BiErrorReturn()
{
	/* Nothing */
}

int BiErrorReturn::getErrorReturn()
{
	return errorReturn;
}

void BiErrorReturn::setErrorReturn(int error)
{
	errorReturn = error;
}

/* END ERRORRETURN */

/* START VALIDATESTATUS */

BiValidateStatus::BiValidateStatus()
{
	validateStatus = 0;
}

BiValidateStatus::~BiValidateStatus()
{
	return;
}

int BiValidateStatus::getValidateStatus()
{
	return validateStatus;
}

void BiValidateStatus::setValidateStatus(int status)
{
	validateStatus = status;
}

/* END VALIDATESTATUS */

/* START SQLINFO */

BiSqlInfo::BiSqlInfo()
{
	sqlInfo = NULL;
}

BiSqlInfo::~BiSqlInfo()
{
	if (sqlInfo != NULL)
		delete sqlInfo;
}

char *BiSqlInfo::getSqlInfo()
{
	return sqlInfo;
}

void BiSqlInfo::setSqlInfo(const char *info)
{
	if (sqlInfo != NULL)
		delete sqlInfo;

	if (info == NULL)
		sqlInfo = NULL;
	else
	{
		sqlInfo = new char[(strlen(info)+1)];
		strcpy(sqlInfo, info);
	}
}

/* END SQLINFO */

/* START SQLRETURN */

BiSqlReturn::BiSqlReturn()
{
	sqlReturn = 0;
}

BiSqlReturn::~BiSqlReturn()
{
	return;
}

int BiSqlReturn::getSqlReturn()
{
	return sqlReturn;
}

void BiSqlReturn::setSqlReturn(int returnVal)
{
	sqlReturn = returnVal;
}

/* END SQLRETURN */

/* START SQLSTATUS */

BiSqlStatus::BiSqlStatus()
{
	sqlStatus = 0;
}

BiSqlStatus::~BiSqlStatus()
{
	return;
}

int BiSqlStatus::getSqlStatus()
{
	return sqlStatus;
}

void BiSqlStatus::setSqlStatus(int status)
{
	sqlStatus = status;
}

/* END SQLSTATUS */

/* START REPOSITORYSTATUS */

BiRepositoryStatus::BiRepositoryStatus()
{
	repositoryStatus = 0;
}

BiRepositoryStatus::~BiRepositoryStatus()
{
	return;
}

int BiRepositoryStatus::getRepositoryStatus()
{
	return repositoryStatus;
}

void BiRepositoryStatus::setRepositoryStatus(int status)
{
	repositoryStatus = status;
}

/* END REPOSITORYSTATUS */

/* START TABLESTATUS */

BiTableStatus::BiTableStatus()
{
	tableStatus = 0;
}

BiTableStatus::~BiTableStatus()
{
	return;
}

int BiTableStatus::getTableStatus()
{
	return tableStatus;
}

void BiTableStatus::setTableStatus(int status)
{
	tableStatus = status;
}

/* END TABLESTATUS */

/* START THREADEXIT */

BiThreadExit::BiThreadExit()
{
	return;
}

BiThreadExit::~BiThreadExit()
{
	return;
}

bool BiThreadExit::getThreadExit(pthread_t tid)
{
//	if ( threadPtr->getExitFlagByTid(threadPtr, tid) == false )
//	{
//		printf("FALSE!!!!!%ld!!!!!!!!\n", tid);
//		return false;
//	}
//	else
//	{
//		printf("TRUE!!!!!!%ld!!!!!!!\n", tid);
//		return true;
//	}

	return threadPtr->getExitFlagByTid(threadPtr, tid);
}

/* END THREADEXIT */

/* START THREADSTATUS */

BiThreadStatus::BiThreadStatus()
{
	threadStatus = 0;
}

BiThreadStatus::~BiThreadStatus()
{
	return;
}

int BiThreadStatus::getThreadStatus()
{
	return threadStatus;
}

void BiThreadStatus::setThreadStatus(int status)
{
	threadStatus = status;
}

/* END THREADSTATUS */

/* START LISTCOLCOUNT */

BiListColCount::BiListColCount()
{
	return;
}

BiListColCount::~BiListColCount()
{
	return;
}

int BiListColCount::getListColCount(char *value)
{
	return listStorePtr->getNumberColumns(listStorePtr, value);
}

/* END LISTCOLCOUNT */

/* START LISTROWCOUNT */

BiListRowCount::BiListRowCount()
{
	return;
}

BiListRowCount::~BiListRowCount()
{
	return;
}

int BiListRowCount::getListRowCount(char *value, bool isMainThread)
{
	return listStorePtr->getNumberRows(listStorePtr, value, isMainThread);
}


/* END LISTROWCOUNT */

/* START TEXTSTATUS */

BiTextStatus::BiTextStatus()
{
	textStatus = 0;
}

BiTextStatus::~BiTextStatus()
{
	return;
}

int BiTextStatus::getTextStatus()
{
	return textStatus;
}

void BiTextStatus::setTextStatus(int status)
{
	textStatus = status;
}

/* END TEXTSTATUS */

/* START FALSE */

BiFalse::BiFalse()
{
	xmlDocPtr docRes;
	xmlXPathContextPtr ctxRes;
	xmlXPathObjectPtr resRes;
	int retStatus;

	/* Get True value from administrator */
	retStatus = repGet(&docRes, "Administrator", "System", "System");
	if (retStatus == 0)
	{
		/* Create XPath environment */
	       	ctxRes = xmlXPathNewContext(docRes);

		/* Get true value */
		resRes = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/System/FalseValue", ctxRes);

		falseValue = new char[strlen((char *)xmlXPathCastToString(resRes)+1)];
		strcpy(falseValue, (char *)xmlXPathCastToString(resRes));

		/* Free */
		xmlXPathFreeObject(resRes);
		xmlXPathFreeContext(ctxRes);
		xmlFreeDoc(docRes);
	}
	else
	{
		falseValue = new char[6];
		strcpy(falseValue, "False");
	}
}

BiFalse::~BiFalse()
{
	if (falseValue != NULL)
		delete falseValue;
}

char *BiFalse::getFalse()
{
	return falseValue;
}

void BiFalse::setFalse(char *value)
{
	falseValue = value;
}

/* END FALSE */

/* START TRUE */

BiTrue::BiTrue()
{
	xmlDocPtr docRes;
	xmlXPathContextPtr ctxRes;
	xmlXPathObjectPtr resRes;
	int retStatus;

	/* Get True value from administrator */
	retStatus = repGet(&docRes, "Administrator", "System", "System");
	if (retStatus == 0)
	{
		/* Create XPath environment */
	       	ctxRes = xmlXPathNewContext(docRes);

		/* Get true value */
		resRes = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/System/TrueValue", ctxRes);

		trueValue = new char[strlen((char *)xmlXPathCastToString(resRes)+1)];
		strcpy(trueValue, (char *)xmlXPathCastToString(resRes));

		/* Free */
		xmlXPathFreeObject(resRes);
		xmlXPathFreeContext(ctxRes);
		xmlFreeDoc(docRes);
	}
	else
	{
		trueValue = new char[5];
		strcpy(trueValue, "True");
	}
}

BiTrue::~BiTrue()
{
	if (trueValue != NULL)
		delete trueValue;
}

char *BiTrue::getTrue()
{
	return trueValue;
}

void BiTrue::setTrue(char *value)
{
	trueValue = value;
}

/* END TRUE */

/* START XMLSTATUS */

BiXmlStatus::BiXmlStatus()
{
	xmlStatus = 0;
}

BiXmlStatus::~BiXmlStatus()
{
	return;
}

int BiXmlStatus::getXmlStatus()
{
	return xmlStatus;
}

void BiXmlStatus::setXmlStatus(int status)
{
	xmlStatus = status;
}

/* END XMLSTATUS */

/* START WEBPARAMETER */
BiWebParameter::BiWebParameter()
{
	strcpy(paramName, "");
	paramValue = NULL;
	nextPtr = NULL;
}

BiWebParameter::~BiWebParameter()
{
	delete paramValue;
}

char *BiWebParameter::getValue(BiWebParameter *biWebPtr, const char *name)
{
	BiWebParameterPtr curPtr;

	/* Get parameter (if exists) */
	curPtr = biWebPtr;

	while (curPtr != NULL)
	{
		if (strcmp(curPtr->paramName, name) == 0)
			return curPtr->paramValue;

		curPtr = curPtr->nextPtr;
	}

	/* Return */
	return NULL;
}

void BiWebParameter::putValue(BiWebParameterPtr *biWebPtr, const char *name, const char *value)
{
	BiWebParameterPtr curPtr, newPtr;

	/* Get parameter (if exists) */
	curPtr = *biWebPtr;

	while (curPtr != NULL)
	{
		if (strcmp(curPtr->paramName, name) == 0)
		{
			if (curPtr->paramValue != NULL)
				delete curPtr->paramValue;

			curPtr->paramValue = new char[strlen(value)];
			strcpy(curPtr->paramValue, value);
			return;
		}
		curPtr = curPtr->nextPtr;
	}

	/* Prepend value */
	newPtr = new BiWebParameter;
	strcpy(newPtr->paramName, name);
	newPtr->paramValue = new char[strlen(value)];
	strcpy(newPtr->paramValue, value);
	
	/* Prepend in list */
	newPtr->nextPtr = *biWebPtr;
	*biWebPtr = newPtr;
}

void BiWebParameter::deleteList(BiWebParameterPtr *biWebPtr)
{
	BiWebParameterPtr tmpPtr;

	while (*biWebPtr != NULL)
	{
		tmpPtr = *biWebPtr;
		*biWebPtr = (*biWebPtr)->nextPtr;
		delete tmpPtr;
	}
}

void BiWebParameter::printList(BiWebParameterPtr biWebPtr) const
{
	BiWebParameterPtr curPtr;

	curPtr = biWebPtr;
	while (curPtr != NULL)
	{
		printf("Name %s - Value %s\n", curPtr->paramName, curPtr->paramValue);
		curPtr = curPtr->nextPtr;
	}
}

/* END WEBPARAMETER */

/* START USER */

BiUser::BiUser()
{
	strcpy(user, "");
}

BiUser::~BiUser()
{
	return;
}

char *BiUser::getUser()
{
	return user;
}

void BiUser::setUser(char *userName)
{
	strcpy(user, userName);
}

/* END USER */

/* START QUITLASTSCREEN */

BiQuitLastScreen::BiQuitLastScreen()
{
	quitLastScreenSetting = 0;
}

BiQuitLastScreen::~BiQuitLastScreen()
{
	return;
}

int BiQuitLastScreen::getQuitLastScreen()
{
	return quitLastScreenSetting;
}

void BiQuitLastScreen::setQuitLastScreen(int setting)
{
	quitLastScreenSetting = setting;
}

/* END QUITLASTSCREEN */