/* 
*
*  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
*
*
*/


#ifndef __DATA_REF_HPP
#define __DATA_REF_HPP

#include "BuiltIn.hpp"
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include <libxml/xpath.h>

/* Data Types */
#define	PL_DT_STRING		1	/* Any characters */
#define	PL_DT_SIGNED_DECIMAL	2	/* Signed Integer */
#define PL_DT_UNSIGNED_DECIMAL	3	/* Unsigned Integer */
#define PL_DT_DATE		4	/* Date / Time according date format field */
#define PL_DT_BOOLEAN		5	/* True/False */

/* Date Types */
#define PL_DT_FORMAT_1		1	/* CCYY-MM-DD */
#define PL_DT_FORMAT_2		2	/* DD/MM/CCYY */
#define PL_DT_FORMAT_3		3	/* MM/DD/CCYY */
#define PL_DT_FORMAT_4		4	/* CCYYMMDD */

/* Justification */
#define PL_JTF_LEFT_CHAR	'L'     /* Left */
#define PL_JTF_CENTER_CHAR	'C'     /* Center */
#define PL_JTF_NONE_CHAR	'N'     /* None */
#define PL_JTF_RIGHT_CHAR	'R'     /* Right */

/* get data ref value from mem */
char *getDataRef(const char *dataRef, bool isMainThread, char *dataRefValue, bool allocate_mem);

/* get unformatted data ref value from mem */
char *getDataRefRaw(const char *dataRef, bool isMainThread, char *dataRefValue, bool allocate_mem);

/* store data ref value in mem */
void putDataRef(const char *dataRef, const char *dataRefValue, int dateFormat, bool isMainThread);

/* Format date from one format to another */
void FormatDate(const char *valueIn, int dateFormatIn, char *valueOut, int dateFormatOut);

/* Get Date Format DataRef */
int getDateFormatDataRef(const char *dataRef);

void ResetBuffers(void);

/* Get non-memory resident data refs */


/* Text Document */
char *getContentsTextDocument(const char *name, char *retValue);

/* Data Ref Structs */
class DataDictionary
{
	public:
		DataDictionary();
		~DataDictionary();
		DataDictionary *createList();
		void clearList(DataDictionary **dicPtr);
		void deleteList(DataDictionary **dicPtr);
		char *getValue(DataDictionary **dicPtr, const char *name);
		char *getValueData(DataDictionary **dicPtr, const char *name, int &retLength, char &retPadChar, char &retJustification);
		char *getNameSeqNo(DataDictionary **dicPtr, const int sequence);
		char *getValueSeqNo(DataDictionary **dicPtr, const int sequence);
		int getDateFormat(DataDictionary *dicPtr, const char *name);
		int getDateFormatSeqNo(DataDictionary *dicPtr, const int sequence);
		void putValue(DataDictionary **dicPtr, const char *name, const int sequence, const char *value);
		void putValueSeqNo(DataDictionary **dicPtr, const int sequence, const char *value);
		void printList(DataDictionary *dicPtr) const;
	private:

		char dicName[32];
		int seqNo;
		int maxLength;
		int editCode;
		int dateFormat;
		int decimalPlaces;
		char padCharacter;
		char justification;
		char *dicValue;
		DataDictionary *nextPtr;
};
typedef DataDictionary *DataDictionaryPtr;


/* Local DataDictionary (L-) */
class LocalDataDictionary
{
	public:
		LocalDataDictionary();
		void push(LocalDataDictionary **topPtr, DataDictionary *dicPtr);
		void pop(LocalDataDictionary **topPtr);
		void deleteStack(LocalDataDictionary **topPtr);
		DataDictionary *getValue(LocalDataDictionary *topPtr);

	private:
		DataDictionary *startPtr;
		LocalDataDictionary *nextPtr;
};
typedef LocalDataDictionary *LocalDicPtr;


/* Global Variable (V-) */
class Variable
{
	public:
		Variable();
		~Variable();
		char *getValue(Variable **varPtr, const char *name);
		char *getValueData(Variable **varPtr, const char *name, int &retLength, char &retPadChar, char &retJustification);
		int getDateFormat(Variable *varPtr, const char *name);
		void putValue(Variable **varPtr, const char *name, const char *value);
		void deleteOne(Variable **varPtr, const char *name);
		void deleteList(Variable **varPtr);
		void printList(Variable *varPtr) const;

	private:
		char varName[32];
		char dicName[32];
		DataDictionary *startPtr;
		Variable *nextPtr;
};

typedef Variable *VariablePtr;

/* VariableGroup (G-) */
class VariableGroup
{
	public:
		VariableGroup();
		~VariableGroup();
		char *getValue(VariableGroup **vgrpPtr, const char *name);
		char *getValueData(VariableGroup **vgrpPtr, const char *name, int &retLength, char &retPadChar, char &retJustification);
		char *getValueSeqNo(VariableGroup **vgrpPtr, const char *vargroup, const int sequence);
		int getNumEntries(VariableGroup **vgrpPtr, const char *vargroup);
		int getDateFormat(VariableGroup *vgrpPtr, const char *name);
		int getDateFormatSeqNo(VariableGroup *vgrpPtr, const char *vargroup, const int sequence);
		void putValue(VariableGroup **vgrpPtr, const char *name, const char *value);
		void putValueSeqNo(VariableGroup **vgrpPtr, const char *vargroup, const int sequence, const char *value);
		void deleteOne(VariableGroup **vgrpPtr, const char *name);
		void deleteList(VariableGroup **vgrpPtr);
		void printList(VariableGroup *vgrpPtr) const;

	private:
		char vgrpName[32];
		int numEntries;
		DataDictionary *startPtr;
		VariableGroup *nextPtr;
};

typedef VariableGroup *VariableGroupPtr;

/* Record (To be used by Table only) */
class Record
{
	friend class Table;

	public:
		Record();
		~Record();

	private:
		char recName[32];
		int numEntries;
		DataDictionary *startPtr;
		Record *nextPtr;
		char *getValue(Record **recPtr, const char *name);
		char *getValueData(Record **recPtr, const char *name, int &retLength, char &retPadChar, char &retJustification);
		char *getNameSeqNo(Record **recPtr, const char *record, const int sequence);
		char *getValueSeqNo(Record **recPtr, const char *record, const int sequence);
		int getNumEntries(Record **recPtr, const char *record);
		int getDateFormat(Record *recPtr, const char *name);
		int getDateFormatSeqNo(Record *recPtr, const char *record, const int sequence);
		void putValue(Record **recPtr, const char *name, const char *value);
		void putValueSeqNo(Record **recPtr, const char *record, const int sequence, const char *value);
		void clearOne(Record **recPtr, const char *name);
		void deleteOne(Record **recPtr, const char *name);
		void deleteList(Record **recPtr);
		void printList(Record *recPtr) const;
};

typedef Record *RecordPtr;

/* Table (F-dd.table.rec) */
class Table
{
	public:
		Table();
		~Table();
		char *getValue(Table **tablePtr, const char *name);
		char *getValueData(Table **tablePtr, const char *name, int &retLength, char &retPadChar, char &retJustification);
		char *getNameSeqNo(Table **tablePtr, const char *tabrec, const int sequence);
		char *getValueSeqNo(Table **tablePtr, const char *tabrec, const int sequence);
		int getNumEntries(Table **tablePtr, const char *tabrec);
		char *getExternalName(Table **tablePtr, const char *name);
		char *getDataSourceName(Table **tablePtr, const char *name);
		int getDateFormat(Table *tablePtr, const char *name);
		int getDateFormatSeqNo(Table *tablePtr, const char *tabrec, const int sequence);
		void putValue(Table **tablePtr, const char *name, const char *value);
		void putValueSeqNo(Table **recPtr, const char *tabrec, const int sequence, const char *value);
		void clearOneRecord(Table **tablePtr, const char *tableName, const char *recordName);
		void deleteOne(Table **tablePtr, const char *name);
		void deleteList(Table **tablePtr);
		void printList(Table *tablePtr) const;
		void putDocBuffer(Table **tablePtr, const char *name, const xmlDocPtr docBuf);
		xmlDocPtr getDocBuffer(Table **tablePtr, const char *name);
	
	private:
		char tableName[32];
		char defRecordName[32];
		char externalName[64];
		char dataSourceName[64];
		xmlDocPtr docTable;
		Record *startPtr;
		Table *nextPtr;

};

typedef Table *TablePtr;


/* PickList Entry Structs */
class PickListEntry
{
	friend class PickList;

	public:
		PickListEntry();
		~PickListEntry();
	private:
		int entry;
		char *plentryValue;
		PickListEntry *nextPtr;
		void initList(PickListEntry **plentryPtr, const char *name);
		char *getValue(PickListEntry **plentryPtr, const int entry);
		char *getValuePtr(PickListEntry **plentryPtr, const int entry);
		void putValue(PickListEntry **plentryPtr, const int entry, const char *value);
		//void populateGList(PickListEntry *plentryPtr, GList ***items);
		int tableCount(PickListEntry *plentryPtr);
		void deleteList(PickListEntry **plentryPtr);
		void printList(PickListEntry *plentryPtr) const;
};
typedef PickListEntry *PickListEntryPtr;

/* PickList (P-) */
class PickList
{
	public:
		PickList();
		~PickList();
		char *getValue(PickList **pickPtr, const char *name);
		char *getValueEntry(PickList **pickPtr, const char *name, const int entry);
		char *getValueEntryPtr(PickList **pickPtr, const char *name, const int entry);
		void putValue(PickList **pickPtr, const char *name, const char *value);
		//void populateGList(PickList **pickPtr, GList **items, const char *name);
		int tableCount(PickList **pickPtr, const char *name);
		void deleteList(PickList **pickPtr);
		void printList(PickList *pickPtr) const;

	private:
		char pickName[32];
		PickListEntry *startPtr;
		PickList *nextPtr;
};

typedef PickList *PickListPtr;

/* Constant (C-) */
class Constant
{
	public:
		Constant();
		~Constant();
		char *getValue(Constant **consPtr, const char *name);
		char *getValueData(Constant **consPtr, const char *name, int &retLength, char &retPadChar, char &retJustification);
		int getDateFormat(Constant *consPtr, const char *name);
		void deleteOne(Constant **consPtr, const char *name);
		void deleteList(Constant **consPtr);
		void printList(Constant *consPtr) const;

	private:
		char consName[32];
		char dicName[32];
		DataDictionary *startPtr;
		Constant *nextPtr;
};
typedef Constant *ConstantPtr;

/* DataModel Entry */
class DataModelEntry
{
	friend class DataModel;

	public:
		DataModelEntry();
		~DataModelEntry();
	private:
		int colNo;
		char *colName;
		char *dataValue;
		int dataLength;
		DataModelEntry *nextPtr;

		char *getDataValueColNo(DataModelEntry *dmentryPtr, const int col);
		char *getDataValueColName(DataModelEntry *dmentryPtr, const char *colname);
		char *getColName(DataModelEntry *dmentryPtr, const int col);
		void putDataValue(DataModelEntry **dmentryPtr, const int col, const char *colname, const char *value, const int length);
		void updateDataValue(DataModelEntry **dmentryPtr, const int col, const char *value);
		void updateDataValueName(DataModelEntry **dmentryPtr, const char *name, const char *value);
		void deleteList(DataModelEntry **dmentryPtr);
		void printList(DataModelEntry *dmentryPtr) const;
};
typedef DataModelEntry *DataModelEntryPtr;

/* Datamodel (M-) */
class DataModel
{
	public:
		DataModel();
		~DataModel();
		bool existsDataModel(DataModel *dmPtr, const char *name);
		char *getDataSource(DataModel *dmPtr, const char *name);
		int getColumns(DataModel *dmPtr, const char *name);
		int getRows(DataModel *dmPtr, const char *name);
		int getCurrentRow(DataModel *dmPtr, const char *name);
		void putDataSource(DataModel **dmPtr, const char *name, const char *dataSource);
		void putColumns(DataModel **dmPtr, const char *name, const int numberCols);
		void putRows(DataModel **dmPtr, const char *name, const int numberRows);
		void putCurrentRow(DataModel **dmPtr, const char *name, const int currentRow);
		char *getValue(DataModel *dmPtr, const char *reference);
		char *getDataValueColNo(DataModel *dmPtr, const char *name, const int col);
		char *getDataValueColName(DataModel *dmPtr, const char *name, const char *colname);
		char *getColName(DataModel *dmPtr, const char *name, const int col);
		void putDataValue(DataModel **dmPtr, const char *name, const int col, const char *colname, const char *value, const int length);
		void updateDataValue(DataModel **dmPtr, const char *name, const int col, const char *value);
		void updateDataValueCol(DataModel **dmPtr, const char *name, const char *value);
		void deleteOne(DataModel **dmPtr, const char *name);
		void deleteList(DataModel **dmPtr);
		void printList(DataModel *dmPtr) const;

	private:
		char dmName[32];
		char *dmDataSource;
		int dmNumberCols;
		int dmNumberRows;
		int dmCurrentRow;
		DataModelEntry *startPtr;
		DataModel *nextPtr;
};
typedef DataModel *DataModelPtr;

/* TextDocument (X-) */
class TextDocument
{
        public:
                TextDocument();
                ~TextDocument();
                char *getValue(TextDocument **txtPtr, const char *name);
                void appendStringValue(TextDocument **txtPtr, const char *name, const char *value);
                void clearDocument(TextDocument **txtPtr, const char *name);
                void deleteDocument(TextDocument **txtPtr, const char *name);
                void deleteList(TextDocument **txtPtr);
                void printList(TextDocument *txtPtr) const;
        private:
                char txtName[32];
                char *txtValue;
                TextDocument *nextPtr;
};
typedef TextDocument *TextDocumentPtr;

/* XmlDocument */
class XmlDocument
{
	public:
		XmlDocument();
		~XmlDocument();
		xmlDocPtr getDocument(XmlDocument **xmlPtr, const char *name);
		xmlNodePtr getNode(XmlDocument *xmlPtr, const char *name);
		char *getRootElementName(XmlDocument *xmlPtr, const char *name);
		char *getNavPath(XmlDocument *xmlPtr, const char *name);
		void putDocument(XmlDocument **xmlPtr, const char *name, xmlDocPtr doc);
		void putNode(XmlDocument **xmlPtr, const char *name, xmlNodePtr node);
		void putRootElementName(XmlDocument **xmlPtr, const char *name, char *root);
		void putNavPath(XmlDocument **xmlPtr, const char *name, char *path);
                void deleteDocument(XmlDocument **xmlPtr, const char *name);
		void deleteList(XmlDocument **xmlPtr);
		void printList(XmlDocument *xmlPtr) const;
	private:
		char xmlName[32];
		char *rootElementName;
		char *navPath;
		xmlDocPtr docXml;
		xmlNodePtr curXml;
		XmlDocument *nextPtr;
};
typedef XmlDocument *XmlDocumentPtr;


#endif /* __DATAREF_HPP */