/* 
*
*  ProLinga-UI
*
*  Copyright (C) 2002-2008 Xobas Software.
*  All rights reserved.
*  
*  This file is part of ProLinga-UI.
*
*  ProLinga-UI 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-UI 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-UI.  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 "UICommon.h"
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include <libxml/xpath.h>
#include "UIConfig.hpp"
#include "UIMain.hpp"

ConfigUI::ConfigUI(const char *configFileName)
{
        xmlDocPtr docConf;
        xmlNodePtr curConf;
        xmlXPathContextPtr ctxConf;
        xmlXPathObjectPtr resConf;
        char productPath[255], configValue[255];

	/* Init */
	startPtr = new ConfigUISetting;

        /* Parsing file */
        docConf = xmlParseFile(configFileName);
        if (docConf == NULL)
        {
                fprintf(stderr, "Error parsing config file. \n");
                xmlFreeDoc(docConf);
                return;
        }

        curConf = xmlDocGetRootElement(docConf);
        if (curConf == NULL)
        {
                fprintf(stderr, "Empty document. \n");
                xmlFreeDoc(docConf);
                return;
        }

        if (xmlStrcmp(curConf->name, (const xmlChar *)"ProLinga"))
        {
                fprintf(stderr, "Invalid Config File");
                xmlFreeDoc(docConf);
                return;
        }

        /* Init Xpath */
        xmlXPathInit();

        /* Create XPath environment */
        ctxConf = xmlXPathNewContext(docConf);

        /* Create config path Server */
	strcpy(productPath, "/ProLinga/Configuration/Service[@Name='" PRODUCT_NAME "']/Client/");

        /* Get Client Host */
        strcpy(configValue, productPath);
        strcat(configValue, "ClientHost");
        resConf = xmlXPathEval((const xmlChar *)configValue, ctxConf);
        if (resConf->nodesetval != NULL && resConf->nodesetval->nodeNr > 0)
                startPtr->putStringValue(&startPtr, "ClientHost", (char *)xmlXPathCastToString(resConf));

        /* Get Client Port */
        strcpy(configValue, productPath);
        strcat(configValue, "ClientPort");
        resConf = xmlXPathEval((const xmlChar *)configValue, ctxConf);
        if (resConf->nodesetval != NULL && resConf->nodesetval->nodeNr > 0)
                startPtr->putNumberValue(&startPtr, "ClientPort", (int)xmlXPathCastToNumber(resConf));

        /* Get Client Compression Level */
        strcpy(configValue, productPath);
        strcat(configValue, "ClientCompressionLevel");
        resConf = xmlXPathEval((const xmlChar *)configValue, ctxConf);
        if (resConf->nodesetval != NULL && resConf->nodesetval->nodeNr > 0)
                startPtr->putNumberValue(&startPtr, "ClientCompressionLevel", (int)xmlXPathCastToNumber(resConf));

        /* Create config path Server */
	strcpy(productPath, "/ProLinga/Configuration/Service[@Name='" PRODUCT_NAME "']/Server/");

        /* Get Remote server name/ip */
        strcpy(configValue, productPath);
        strcat(configValue, "ServerHost");
        resConf = xmlXPathEval((const xmlChar *)configValue, ctxConf);
        if (resConf->nodesetval != NULL && resConf->nodesetval->nodeNr > 0)
                startPtr->putStringValue(&startPtr, "ServerHost", (char *)xmlXPathCastToString(resConf));

        /* Get Remote port number */
        strcpy(configValue, productPath);
        strcat(configValue, "ServerPort");
        resConf = xmlXPathEval((const xmlChar *)configValue, ctxConf);
        if (resConf->nodesetval != NULL && resConf->nodesetval->nodeNr > 0)
                startPtr->putNumberValue(&startPtr, "ServerPort", (int)xmlXPathCastToNumber(resConf));

        /* Get Number of Threads */
        strcpy(configValue, productPath);
        strcat(configValue, "NumberOfThreads");
        resConf = xmlXPathEval((const xmlChar *)configValue, ctxConf);
        if (resConf->nodesetval != NULL && resConf->nodesetval->nodeNr > 0)
                startPtr->putNumberValue(&startPtr, "NumberOfThreads", (int)xmlXPathCastToNumber(resConf));

        /* Get Log File */
        strcpy(configValue, productPath);
        strcat(configValue, "LogFile");
        resConf = xmlXPathEval((const xmlChar *)configValue, ctxConf);
        if (resConf->nodesetval != NULL && resConf->nodesetval->nodeNr > 0)
                startPtr->putStringValue(&startPtr, "LogFile", (char *)xmlXPathCastToString(resConf));

        /* Get LogLevel */
        strcpy(configValue, productPath);
        strcat(configValue, "LogLevel");
        resConf = xmlXPathEval((const xmlChar *)configValue, ctxConf);
        if (resConf->nodesetval != NULL && resConf->nodesetval->nodeNr > 0)
                startPtr->putNumberValue(&startPtr, "LogLevel", (int)xmlXPathCastToNumber(resConf));

        /* Get Server Compression Level */
        strcpy(configValue, productPath);
        strcat(configValue, "ServerCompressionLevel");
        resConf = xmlXPathEval((const xmlChar *)configValue, ctxConf);
        if (resConf->nodesetval != NULL && resConf->nodesetval->nodeNr > 0)
                startPtr->putNumberValue(&startPtr, "ServerCompressionLevel", (int)xmlXPathCastToNumber(resConf));

        /* Get Run host name/ip */
        strcpy(configValue, productPath);
        strcat(configValue, "RunHost");
        resConf = xmlXPathEval((const xmlChar *)configValue, ctxConf);
        if (resConf->nodesetval != NULL && resConf->nodesetval->nodeNr > 0)
                startPtr->putStringValue(&startPtr, "RunHost", (char *)xmlXPathCastToString(resConf));

        /* Get Run port number */
        strcpy(configValue, productPath);
        strcat(configValue, "RunPort");
        resConf = xmlXPathEval((const xmlChar *)configValue, ctxConf);
        if (resConf->nodesetval != NULL && resConf->nodesetval->nodeNr > 0)
                startPtr->putNumberValue(&startPtr, "RunPort", (int)xmlXPathCastToNumber(resConf));

        /* Get Run Compression setting  */
        strcpy(configValue, productPath);
        strcat(configValue, "RunCompressionLevel");
        resConf = xmlXPathEval((const xmlChar *)configValue, ctxConf);
        if (resConf->nodesetval != NULL && resConf->nodesetval->nodeNr > 0)
                startPtr->putNumberValue(&startPtr, "RunCompressionLevel", (int)xmlXPathCastToNumber(resConf));

        /* Get ExternalScreenPainter Compression setting  */
        strcpy(configValue, productPath);
        strcat(configValue, "ExternalScreenPainter");
        resConf = xmlXPathEval((const xmlChar *)configValue, ctxConf);
        if (resConf->nodesetval != NULL && resConf->nodesetval->nodeNr > 0)
                startPtr->putStringValue(&startPtr, "ExternalScreenPainter", (char *)xmlXPathCastToString(resConf));


	/* Clean up */
	xmlXPathFreeContext(ctxConf);
	xmlFreeDoc(docConf);
}

ConfigUI::~ConfigUI()
{
	if (startPtr != NULL)
		startPtr->deleteList(&startPtr);
}
                                                                                                                                             
char *ConfigUI::getStringValue(const char *name, const char *defValue)
{
	return startPtr->getStringValue(startPtr, name, defValue);
}
                                                                                                                                             
int ConfigUI::getNumberValue(const char *name, const int defValue)
{
	return startPtr->getNumberValue(startPtr, name, defValue);
}
                                                                                                                                             
void ConfigUI::putStringValue(const char *name, const char *value)
{
	startPtr->putStringValue(&startPtr, name, value);
}
                                                                                                                                             
void ConfigUI::putNumberValue(const char *name, const int value)
{
	startPtr->putNumberValue(&startPtr, name, value);
}

void ConfigUI::writeConfig(const char *logFileName) const
{
	FILE *log;
	time_t t;
	time(&t);

	/* Open log file */	
	log = fopen(startPtr->getStringValue(startPtr, "LogFile", DEF_LOG_FILE), "a");

	/* Write settings */
	fprintf(log,"-----------------------------------------------------------------\n");
	fprintf(log, "Configuration ProLinga-UI Server - %s \n", ctime(&t));
	fprintf(log, "Log File                  : %s\n", startPtr->getStringValue(startPtr, "LogFile", DEF_LOG_FILE));
	fprintf(log, "Log Level                 : %d\n", startPtr->getNumberValue(startPtr, "LogLevel", DEF_LOG_LEVEL));
	fprintf(log, "Server Host               : %s\n", startPtr->getStringValue(startPtr, "ServerHost", DEF_SERVER_HOST));
	fprintf(log, "Server Port               : %d\n", startPtr->getNumberValue(startPtr, "ServerPort", DEF_SERVER_PORT));
	fprintf(log, "Server Compression Level  : %d\n", startPtr->getNumberValue(startPtr, "ServerCompressionLevel", DEF_SERVER_COMP_LEVEL));
	fprintf(log, "Number of Threads		: %d\n", startPtr->getNumberValue(startPtr, "NumberOfThreads", DEF_NUMBER_THREADS));
	fprintf(log, "External Screen Painter	: %s\n", startPtr->getStringValue(startPtr, "ExternalScreenPainter", DEF_EXT_SCREEN_PAINTER));
	fprintf(log,"-----------------------------------------------------------------\n");

	/*Close log file */
	fclose(log);
}

void ConfigUI::printList(void) const
{
	startPtr->printList(startPtr);
}

ConfigUISetting::ConfigUISetting()
{
        strcpy(confsetName, "");
        confsetStringValue = NULL;
        confsetNumberValue = 0;
        nextPtr = NULL;
}

ConfigUISetting::~ConfigUISetting()
{
        /* Nothing ? */
}

char *ConfigUISetting::getStringValue(ConfigUISettingPtr confsetPtr, const char *name, const char *defValue)
{
        ConfigUISettingPtr curPtr;

        /* Get value from memory */
        curPtr = confsetPtr;

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

                curPtr = curPtr->nextPtr;
        }

	/* Return */
        return (char *)defValue;
}

int ConfigUISetting::getNumberValue(ConfigUISettingPtr confsetPtr, const char *name, const int defValue)
{
        ConfigUISettingPtr curPtr;

        /* Get value from memory */
        curPtr = confsetPtr;

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

                curPtr = curPtr->nextPtr;
        }

	/* Return */
        return defValue;
}

void ConfigUISetting::putStringValue(ConfigUISettingPtr *confsetPtr, const char *name, const char *value)
{
        ConfigUISettingPtr curPtr, newPtr;

        /* First check if already in list (update) */
        curPtr = *confsetPtr;

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

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

        /* Create new Config instance */
        newPtr = new ConfigUISetting;
        strcpy(newPtr->confsetName, name);
	newPtr->confsetStringValue = new char[(strlen(value)+1)];
        strcpy(newPtr->confsetStringValue, value);

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

void ConfigUISetting::putNumberValue(ConfigUISettingPtr *confsetPtr, const char *name, const int value)
{
        ConfigUISettingPtr curPtr, newPtr;

        /* First check if already in list (update) */
        curPtr = *confsetPtr;

        while (curPtr != NULL)
        {
                if (strcmp(curPtr->confsetName, name) == 0)
                {
			curPtr->confsetNumberValue = value;
                        return;
                }
                curPtr = curPtr->nextPtr;
        }

        /* Create new Config instance */
        newPtr = new ConfigUISetting;
        strcpy(newPtr->confsetName, name);
        newPtr->confsetNumberValue = value;

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

void ConfigUISetting::deleteList(ConfigUISettingPtr *confsetPtr)
{
        ConfigUISettingPtr tmpPtr;
                                                                                                                                             
        while (*confsetPtr != NULL)
        {
                tmpPtr = *confsetPtr;
                *confsetPtr = (*confsetPtr)->nextPtr;
                delete tmpPtr;
        }
}
                                                                                                                                             
void ConfigUISetting::printList(ConfigUISettingPtr confsetPtr) const
{
        ConfigUISettingPtr curPtr;
                                                                                                                                             
        curPtr = confsetPtr;
        while (curPtr != NULL)
        {
                printf("Config Setting Name %s\n", curPtr->confsetName);
                curPtr = curPtr->nextPtr;
        }
}