/*

* Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

* CScrXmlParser - Used to retrieve details from xml files for creating database and 

* Software environment updates.

*

*/

/**

 @file 

 @released

 @internalTechnology

*/

#include "xmlparser.h"

#include "logs.h"

#include "exception.h"

#include "utf8_wrapper.h"

#include "util.h"

#include "utility.h"

#include <xercesc/sax2/XMLReaderFactory.hpp>

#include <xercesc/sax2/DefaultHandler.hpp>

#include <xercesc/util/XMLString.hpp>

#include <xercesc/util/PlatformUtils.hpp>

#include <xercesc/framework/LocalFileInputSource.hpp>

#include <xercesc/util/OutOfMemoryException.hpp>

#include <string>

#include <vector>

#include <memory>

#include <cstdio>

#ifndef _WIN32

#include <ctype.h>

//__ctype_b was removed from glibc. This is a workaround to fix the linking problem

extern "C"

    {

    const unsigned short int** __ctype_b()

        {

        return __ctype_b_loc();

        }

    }

#endif // _WIN32

XERCES_CPP_NAMESPACE_USE

//------------------------------------------------------------------------------------------------------------------------------

//											UTILITY FUNCTIONS

//------------------------------------------------------------------------------------------------------------------------------

int XercesStringToInteger(const XercesString& aWideStr)

	{

	int strLen = aWideStr.length();

	const XMLCh* source = aWideStr.c_str();	

  char* buffer = new char[strLen << 2];

	// Using a temp variable in place of buffer as ConvertUTF16toUTF8 modifies the source pointer passed.

	char* temp = buffer;	

	ConvertUTF16toUTF8(&source, aWideStr.c_str() + strLen, &temp,  temp + (strLen << 2));

	// Appending NUL to the converted buffer.

	*temp = 0;

	int value = 0;

	sscanf(buffer, "%d", &value);

	delete[] buffer;

	return value;

	}

// these function pointers are used to call appropriate release methods of XMLString

// present in the xerces library. 

typedef void (*releaseXmlChPtr) (XMLCh** buf);

typedef void (*releaseChPtr) (char** buf);

#ifdef _WIN32

// We need not do anything for WINDOWS, since XMLCh string(XercesString)

// and WString both are same and will be in UTF-16 encoding format.

#define XMLChToWString(aParameter) (aParameter)

#else

inline std::wstring XMLChToWString(const XercesString& aXercesString)

	{

	return XercesStringToWString (aXercesString);

	}

#endif // _WIN32

DllExport CScrXmlParser::CScrXmlParser()

	{}

DllExport CScrXmlParser::~CScrXmlParser()

	{}

/**

	Initializes the xml framework for DOM parsing. Registers an error handler for retrieving

	all errors while xml parsing.

	Retrieves database creation statements from the xml file. The DTD for the same is 

	specified in the xml document.

	@param	aDbFile	name of the database file in xml format.

	@return list of database create statements in the form of a vector.

 */

DllExport std::vector<std::string>* CScrXmlParser::ParseDbSchema(const std::string& aDbFile)

	{

	std::vector<std::string>* dbSchema = NULL;

	try

		{

		LOGENTER("CScrXmlParser::GetDBSchema()");

		XMLPlatformUtils::Initialize();

		std::auto_ptr<xercesc::XercesDOMParser> configFileParser(new XercesDOMParser());

		ConfigDomParser(*configFileParser);

		// set the error handler for the xml parser

		std::auto_ptr<SchemaErrorHandler> errHandler(new SchemaErrorHandler());

		configFileParser->setErrorHandler(errHandler.get());

		fn_auto_ptr<releaseXmlChPtr, XMLCh> tagSQLQuery( &XMLString::release, XMLString::transcode("SQLQuery") );

		fn_auto_ptr<releaseXmlChPtr, XMLCh> dbFileName( &XMLString::release, XMLString::transcode(aDbFile.c_str()) );

		dbSchema = new std::vector<std::string>();

		LocalFileInputSource dbFile( dbFileName.get() );

		configFileParser->parse(dbFile);

		// no need to free this pointer - owned by the parent parser object

		DOMDocument* xmlDoc = configFileParser->getDocument();

		// Get the top-level element

		DOMElement* elementRoot = xmlDoc->getDocumentElement();

		// Retrieve the nodes for CreateDatabase.

		DOMNodeList* createDbNode = elementRoot->getChildNodes();

		const  XMLSize_t createDbNodeCount = createDbNode->getLength();

		// for each Transaction retrieve all tags

		for( XMLSize_t count = 0; count < createDbNodeCount; ++count )

			{

			DOMNode* currentNode = createDbNode->item(count);

			DOMElement* currentElement = static_cast< xercesc::DOMElement* >( currentNode );

			if( XMLString::equals(currentElement->getTagName(), tagSQLQuery.get()))

				{

				fn_auto_ptr<releaseChPtr, char> cleanupText( &XMLString::release, XMLString::transcode( currentElement->getTextContent()) );

				std::string query(cleanupText.get());

				dbSchema->push_back(query);

				}

			} // for

		}

		catch(XMLException& aXmlException)

			{

			delete dbSchema;

			XMLPlatformUtils::Terminate();

			const XMLCh* msg = aXmlException.getMessage();

			std::string msgStr = XMLString::transcode(msg);

			int errCode = aXmlException.getCode();

			throw CException(msgStr,errCode);

			}

		catch(CException& aXmlException)

			{

			delete dbSchema;

			XMLPlatformUtils::Terminate();

			throw aXmlException;

			}

	XMLPlatformUtils::Terminate(); 

	LOGEXIT("CScrXmlParser::GetDBSchema()");

	return dbSchema;

	}

/**

	Initializes the xml framework for DOM parsing. Registers an error handler for retrieving

	all errors while xml parsing.

	Retrieves software environment details from the xml file. The DTD for the same is 

	specified in the xml document.

	@param	aEnvDetailFile	name of the s/w environment file in xml format.

	@return list of details in the form of a vector.

 */

DllExport std::vector<XmlDetails::TScrEnvironmentDetails>* CScrXmlParser::GetEnvironmentDetails( const std::string aEnvDetailFile )

	{	

	std::vector<XmlDetails::TScrEnvironmentDetails>* environmentDetails = NULL;

	try

		{

		LOGENTER("CScrXmlParser::GetEnvironmentDetails()");

		XMLPlatformUtils::Initialize();

		std::auto_ptr<xercesc::XercesDOMParser> configFileParser(new XercesDOMParser());

		ConfigDomParser(*configFileParser);

		// set the error handler for the xml parser

		std::auto_ptr<SchemaErrorHandler> errHandler(new SchemaErrorHandler());

		configFileParser->setErrorHandler(errHandler.get());

		// Tags and attributes used in XML file.

		// Can't call transcode till after Xerces Initialize()

		fn_auto_ptr<releaseXmlChPtr, XMLCh> tagEnvironment( &XMLString::release, XMLString::transcode("Environment") );

		environmentDetails = new std::vector<XmlDetails::TScrEnvironmentDetails>();

		fn_auto_ptr<releaseXmlChPtr, XMLCh> envFileName( &XMLString::release, XMLString::transcode(aEnvDetailFile.c_str()) );

		LocalFileInputSource envFile( envFileName.get() );

		configFileParser->parse( envFile );

		// no need to free this pointer - owned by the parent parser object

		DOMDocument* xmlDoc = configFileParser->getDocument();

		// Get the top-level element which is SoftwareEnvironments.

		DOMElement* elementRoot = xmlDoc->getDocumentElement();

		// Retrieve the nodes for Environment.

		DOMNodeList* entryNodes = elementRoot->getChildNodes();

		const  XMLSize_t nodeCount = entryNodes->getLength();

		// for each Environment retrieve all tags

		for( XMLSize_t xx = 0; xx < nodeCount; ++xx )

			{

			DOMNode* currentNode = entryNodes->item(xx);

			DOMElement* currentElement = static_cast< xercesc::DOMElement* >( currentNode );

			// is not null and is an element

			if( XMLString::equals(currentElement->getTagName(), tagEnvironment.get()))

				{

				XmlDetails::TScrEnvironmentDetails scrEnvDetails = GetEnvironmentData(currentElement);

				environmentDetails->push_back(scrEnvDetails);

				}				

			}

		}

		catch(XMLException& aXmlException)

			{

			XMLPlatformUtils::Terminate();

			std::string msgStr = XMLString::transcode(aXmlException.getMessage());

			int errCode = aXmlException.getCode();

			throw CException(msgStr,errCode);

			}

		catch (CException& aXmlException)

			{

			XMLPlatformUtils::Terminate(); 

			delete environmentDetails;

			throw aXmlException;

			}

	XMLPlatformUtils::Terminate(); 

	LOGEXIT("CScrXmlParser::GetEnvironmentDetails()");

	return environmentDetails;

	}

/**

	Retrieves details from the s/w environment xml file. It retrieves details specific

	to the tags as specfied in the DTD which is part of the xml file.

	@param	aElement		the current Environment tag being processed.

	@param	aParamDetails	pointer to the vector to be populated with the details.

 */

XmlDetails::TScrEnvironmentDetails CScrXmlParser::GetEnvironmentData( const DOMElement* aEnvironment)

	{

	LOGENTER("CScrXmlParser::GetEnvironmentData()");

	XmlDetails::TScrEnvironmentDetails scrEnvDetails;

	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagSoftwareTypeNames( &XMLString::release, XMLString::transcode("SoftwareTypeNames") );

	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagUniqueSoftwareTypeName( &XMLString::release, XMLString::transcode("UniqueSoftwareTypeName") );

	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagLocalizableSwTypeName( &XMLString::release, XMLString::transcode("LocalizableSoftwareTypeName") );

	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagSifPluginUid( &XMLString::release, XMLString::transcode("SifPluginUid") );

	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagLauncherExecutable( &XMLString::release, XMLString::transcode("LauncherExecutable") );

	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagMIMEDetails( &XMLString::release, XMLString::transcode("MIMEDetails") );

	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagMIMEType( &XMLString::release, XMLString::transcode("MIMEType") );

	DOMNodeList* swTypeNames = aEnvironment->getElementsByTagName(tagSoftwareTypeNames.get());

	DOMNode* swTypeNamesRoot	= swTypeNames->item(0);

	DOMElement* swTypeNamesNode = static_cast< xercesc::DOMElement* >( swTypeNamesRoot );

	DOMNodeList* uniqueSwTypeName = swTypeNamesNode->getElementsByTagName(tagUniqueSoftwareTypeName.get());

	const XMLCh* textContent = uniqueSwTypeName->item(0)->getTextContent();

	scrEnvDetails.iUniqueSoftwareTypeName = XMLChToWString(textContent);

	DOMNodeList* localizableSwTypeNames = swTypeNamesNode->getElementsByTagName(tagLocalizableSwTypeName.get());

	const  XMLSize_t localizableSwTypeNamesCount = localizableSwTypeNames->getLength();

	for( XMLSize_t count=0 ; count<localizableSwTypeNamesCount ; ++count )

		{

		DOMNode* localizableSwTypeNameRoot = localizableSwTypeNames->item(count);

		DOMElement* localizableSwTypeNameNode = static_cast< xercesc::DOMElement* >( localizableSwTypeNameRoot );

		XmlDetails::TScrEnvironmentDetails::TLocalizedSoftwareTypeName localizedSwTypeName = GetLocalizedSoftwareTypeName(localizableSwTypeNameNode);

		scrEnvDetails.iLocalizedSoftwareTypeNames.push_back(localizedSwTypeName);

		}

	DOMNodeList* sifPluginUid = aEnvironment->getElementsByTagName(tagSifPluginUid.get());

	textContent = (sifPluginUid->item(0))->getTextContent();

	fn_auto_ptr<releaseChPtr,char> sifPluginUidText(&XMLString::release, XMLString::transcode(textContent));

	int sifPluginUidValue = 0;

	sscanf(sifPluginUidText.get(),"%x",&sifPluginUidValue);

	scrEnvDetails.iSifPluginUid = sifPluginUidValue;

    DOMNodeList* launcherExecutable = aEnvironment->getElementsByTagName(tagLauncherExecutable.get());

    if(0 != launcherExecutable->getLength())

        {

		textContent = launcherExecutable->item(0)->getTextContent();

		const XMLCh* launcherExecutableValue = launcherExecutableText.get();

		scrEnvDetails.iLauncherExecutable = XMLChToWString(launcherExecutableValue);

		}

		{

		}

	DOMNodeList* mimeDetails = aEnvironment->getElementsByTagName(tagMIMEDetails.get());

	DOMNode* mimeDetailRoot	= mimeDetails->item(0);

	DOMElement* mimeDetailNode = static_cast< xercesc::DOMElement* >( mimeDetailRoot );

	DOMNodeList* mimes = mimeDetailNode->getElementsByTagName(tagMIMEType.get());

	const  XMLSize_t mimeCount = mimes->getLength();

	for( XMLSize_t count=0 ; count<mimeCount ; ++count )

		{

		const XMLCh* textContent = mimes->item(count)->getTextContent();

		std::wstring textString = XMLChToWString(textContent);

		scrEnvDetails.iMIMEDetails.push_back(textString);

		}

	LOGEXIT("CScrXmlParser::GetEnvironmentData()");

	return scrEnvDetails;

	}

XmlDetails::TScrPreProvisionDetail CScrXmlParser::GetPreProvisionDetails( const std::string aPreProvisionFile )	

	{

	XmlDetails::TScrPreProvisionDetail preProvisionDetail;

	try

		{

		LOGENTER("CScrXmlParser::GetPreProvisionDetails()");

		XMLPlatformUtils::Initialize();

		std::auto_ptr<xercesc::XercesDOMParser> configFileParser(new XercesDOMParser());

		ConfigDomParser(*configFileParser);

		// set the error handler for the xml parser

		std::auto_ptr<SchemaErrorHandler> errHandler(new SchemaErrorHandler());

		configFileParser->setErrorHandler(errHandler.get());

		// Tags and attributes used in XML file.

		// Can't call transcode till after Xerces Initialize()

		// root tag

		fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponent( &XMLString::release, XMLString::transcode("Component") );

		fn_auto_ptr<releaseXmlChPtr, XMLCh> preProvisionFileName( &XMLString::release, XMLString::transcode(aPreProvisionFile.c_str()) );

		LocalFileInputSource envFile( preProvisionFileName.get() );

		configFileParser->parse( envFile );

		// no need to free this pointer - owned by the parent parser object

		DOMDocument* xmlDoc = configFileParser->getDocument();

		// Get the top-level element which is Component.

		DOMElement* elementRoot = xmlDoc->getDocumentElement();

		fn_auto_ptr<releaseXmlChPtr, XMLCh> tagSoftwareTypeName( &XMLString::release, XMLString::transcode("SoftwareTypeName") );

		DOMNodeList* softwaretype = elementRoot->getElementsByTagName(tagSoftwareTypeName.get());

		const XMLCh* textContent = softwaretype->item(0)->getTextContent();

		preProvisionDetail.iSoftwareTypeName = XMLChToWString(textContent);

		// Retrieve the nodes for Component.

		DOMNodeList* componentNodes = elementRoot->getElementsByTagName(tagComponent.get());

		const  XMLSize_t nodeCount = componentNodes->getLength();

		// for each Component retrieve all tags

		for( XMLSize_t index = 0; index < nodeCount; ++index )

			{

			DOMNode* currentNode = componentNodes->item(index);

			DOMElement* currentElement = static_cast< xercesc::DOMElement* >( currentNode );

			preProvisionDetail.iComponents.push_back(GetPreProvisionData(currentElement));

			}

		}

		catch(XMLException& aXmlException)

			{

			XMLPlatformUtils::Terminate();

			std::string msgStr = XMLString::transcode(aXmlException.getMessage());

			int errCode = aXmlException.getCode();

			throw CException(msgStr,errCode);

			}

		catch (CException& aXmlException)

			{

			XMLPlatformUtils::Terminate(); 

			throw aXmlException;

			}

	XMLPlatformUtils::Terminate(); 

	return preProvisionDetail;

	}

XmlDetails::TScrPreProvisionDetail::TComponent CScrXmlParser::GetPreProvisionData( const DOMElement* aDOMElement)

	{

	LOGENTER("CScrXmlParser::GetPreProvisionData()");

	XmlDetails::TScrPreProvisionDetail::TComponent component;

	DOMNodeList* childNodes = aDOMElement->getChildNodes();

	const XMLSize_t nodeCount = childNodes->getLength();

	// tags contained in Component

	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentLocalizable( &XMLString::release, XMLString::transcode("ComponentLocalizable") );

	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentProperty( &XMLString::release, XMLString::transcode("ComponentProperty") );

	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentFile( &XMLString::release, XMLString::transcode("ComponentFile") );

	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentDetails( &XMLString::release, XMLString::transcode("ComponentDetails") );

	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentDependency( &XMLString::release, XMLString::transcode("ComponentDependency") );

	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagApplicationRegistrationInfo( &XMLString::release, XMLString::transcode("ApplicationRegistrationInfo") );

	XmlDetails::TScrPreProvisionDetail::TComponentDetails componentDetails = GetComponentDetails(aDOMElement);

	component.iComponentDetails = componentDetails;

	// for each ComponentProperty retrieve all tags

	for( XMLSize_t index = 0; index < nodeCount; ++index )

		{

		DOMElement* currentElement = static_cast< xercesc::DOMElement* >( childNodes->item(index) );

		// is not null and is an element

		if( XMLString::equals(currentElement->getTagName(), tagComponentLocalizable.get()))

			{

			XmlDetails::TScrPreProvisionDetail::TComponentLocalizable componentLocalizable = GetComponentLocalizable(currentElement);

			component.iComponentLocalizables.push_back(componentLocalizable);

			}

		else if( XMLString::equals(currentElement->getTagName(), tagComponentProperty.get()))

			{

			XmlDetails::TScrPreProvisionDetail::TComponentProperty componentProperty = GetComponentProperty(currentElement);

			component.iComponentProperties.push_back(componentProperty);

			}

		else if( XMLString::equals(currentElement->getTagName(), tagComponentFile.get()))