/*

* Copyright (c) 2008-2009 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 "util.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>

XERCES_CPP_NAMESPACE_USE

// 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);

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> tagInstallerSid( &XMLString::release, XMLString::transcode("InstallerSid") );

	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagExecutionLayerSid( &XMLString::release, XMLString::transcode("ExecutionLayerSid") );

	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 = std::wstring(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* installerSid = aEnvironment->getElementsByTagName(tagInstallerSid.get());

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

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

	int installerSidValue = 0;

	sscanf(installerSidText.get(),"%x",&installerSidValue);

	scrEnvDetails.iInstallerSid = installerSidValue;

	DOMNodeList* executionLayerSid = aEnvironment->getElementsByTagName(tagExecutionLayerSid.get());

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

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

	int executionLayerSidValue = 0;

	sscanf(executionLayerSidText.get(),"%x",&executionLayerSidValue);

	scrEnvDetails.iExecutionLayerSid = executionLayerSidValue;

	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();

		scrEnvDetails.iMIMEDetails.push_back(textContent);

		}

	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 = std::wstring(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)

	{

	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") );

	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()))

			{

			XmlDetails::TScrPreProvisionDetail::TComponentFile componentFile = GetComponentFile(currentElement);

			component.iComponentFiles.push_back(componentFile);

			}

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

			{

			XmlDetails::TScrPreProvisionDetail::TComponentDependency componentDependency = GetComponentDependency(currentElement);

			component.iComponentDependency = componentDependency;

			}

		}

	return component;

	}

XmlDetails::TScrPreProvisionDetail::TComponentLocalizable CScrXmlParser::GetComponentLocalizable(const DOMElement* aDOMElement)

	{

	// tags in ComponentLocalizable

	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentLocalizableLocale( &XMLString::release, XMLString::transcode("ComponentLocalizable_Locale") );

	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentLocalizableName( &XMLString::release, XMLString::transcode("ComponentLocalizable_Name") );

	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentLocalizableVendor( &XMLString::release, XMLString::transcode("ComponentLocalizable_Vendor") );

	DOMNodeList* locale = aDOMElement->getElementsByTagName(tagComponentLocalizableLocale.get());

	DOMNodeList* name	= aDOMElement->getElementsByTagName(tagComponentLocalizableName.get());

	DOMNodeList* vendor = aDOMElement->getElementsByTagName(tagComponentLocalizableVendor.get());

	XmlDetails::TScrPreProvisionDetail::TComponentLocalizable componentLocalizable;

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

		{

		const XMLCh* textLocale = locale->item(0)->getTextContent();

		componentLocalizable.iLocale = Util::WideCharToInteger(textLocale);

		}

	const XMLCh* textName = name->item(0)->getTextContent();

	componentLocalizable.iName = textName;

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

		{

		const XMLCh* textVendor = vendor->item(0)->getTextContent();

		componentLocalizable.iVendor = textVendor;

		}

	return componentLocalizable;

	}

XmlDetails::TScrPreProvisionDetail::TComponentProperty CScrXmlParser::GetComponentProperty(const DOMElement* aEnvironment)

	{

	// tags in ComponentProperty

	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentPropertyName( &XMLString::release, XMLString::transcode("Name") );

	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentPropertyLocale( &XMLString::release, XMLString::transcode("ComponentProperty_Locale") );

	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentPropertyValue( &XMLString::release, XMLString::transcode("ComponentProperty_Value") );

	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentPropertyIsBinary( &XMLString::release, XMLString::transcode("ComponentProperty_IsBinary") );

	// tags of ComponentProperty_Value

	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentPropertyIntValue( &XMLString::release, XMLString::transcode("ComponentProperty_IntValue") );

	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentPropertyStrValue( &XMLString::release, XMLString::transcode("ComponentProperty_StrValue") );

	// attribute - name

	DOMNamedNodeMap* attributes = aEnvironment->getAttributes();

	DOMNode* name = attributes->getNamedItem(tagComponentPropertyName.get());

	DOMNodeList* locale = aEnvironment->getElementsByTagName(tagComponentPropertyLocale.get());

	DOMNodeList* value = aEnvironment->getElementsByTagName(tagComponentPropertyValue.get());

	DOMNodeList* isBinary = aEnvironment->getElementsByTagName(tagComponentPropertyIsBinary.get());

	XmlDetails::TScrPreProvisionDetail::TComponentProperty componentProperty;

	const XMLCh* textName = name->getTextContent();

	componentProperty.iName	= textName;

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

		{

		const XMLCh* textLocale = locale->item(0)->getTextContent();

		componentProperty.iLocale = Util::WideCharToInteger(textLocale);

		}

	DOMNodeList* childNodes = value->item(0)->getChildNodes();

	const XMLSize_t nodeCount = childNodes->getLength();

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

		{

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

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

			{

			componentProperty.iIsIntValue = true;

			componentProperty.iValue = currentElement->getTextContent();

			break;

			}

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

			{

			componentProperty.iIsIntValue = false;

			componentProperty.iValue = currentElement->getTextContent();

			break;

			}

		}

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

		{

		const XMLCh* textIsBinary = isBinary->item(0)->getTextContent();

		componentProperty.iIsStr8Bit = Util::WideCharToInteger(textIsBinary);		

		}

	return componentProperty;

	}

XmlDetails::TScrPreProvisionDetail::TComponentFile CScrXmlParser::GetComponentFile( const DOMElement* aDOMElement)

	{