/*

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

* CXmlGenerator - Used to generate the xml file containing registry information.

*

*/

/**

 @file 

 @released

 @internalTechnology

*/

#include "xmlgenerator.h"

#include "is_utils.h"

#include <xercesc/dom/DOM.hpp>

#include <xercesc/util/XMLString.hpp>

#include <xercesc/util/PlatformUtils.hpp>

#include <xercesc/framework/StdOutFormatTarget.hpp>

#include <xercesc/framework/LocalFileFormatTarget.hpp>

#include <xercesc/framework/XMLFormatter.hpp>

#include <xercesc/framework/MemBufFormatTarget.hpp>

#include <xercesc/util/XercesVersion.hpp>

#include <exception>

#include <string>

#include <vector>

#include <memory>

#include <cstdio>

#include <stdexcept>

#include "toolsconf.h"

XERCES_CPP_NAMESPACE_USE

// these function pointers is used to call appropriate release methods of 

// which are member function of a class. 

typedef void (XERCES_CPP_NAMESPACE::DOMDocument::*releaseDOMDoc) ();

typedef void (XERCES_CPP_NAMESPACE::DOMWriter::*releaseDOMWriter) ();

typedef void (*xmlPlatform) ();

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

CXmlGenerator::CXmlGenerator()

	{}

CXmlGenerator::~CXmlGenerator()

	{}

	{

	try 

		{

		XMLPlatformUtils::Initialize();

		static_fn_auto_ptr<xmlPlatform> xmlPlatformTerm(&XMLPlatformUtils::Terminate);

		DOMImplementation* domImpl = DOMImplementation::getImplementation() ;

		mem_fn_auto_ptr<releaseDOMWriter, DOMWriter*> domWriter( &XERCES_CPP_NAMESPACE::DOMWriter::release, ((DOMImplementationLS*)domImpl)->createDOMWriter() );

		SetWriterFeatures(domWriter.get());

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

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

		std::auto_ptr < XMLFormatTarget > outputFile( new LocalFileFormatTarget( aXmlFileName.c_str() ) );	

		if(NULL == epocRoot)

			{

			throw std::runtime_error("EPOCROOT environment variable not specified.");

			}

		std::string epocRootStr(epocRoot); 

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

		DOMElement* rootElement = domDocument->getDocumentElement();

		// SoftwareTypeName

		std::vector<XmlDetails::TScrPreProvisionDetail::TComponent>::const_iterator compIter;

		for(compIter = aPreProvisionDetail.iComponents.begin(); compIter != aPreProvisionDetail.iComponents.end() ; ++compIter)

			{

			rootElement->appendChild(component);

			}

		// do the serialization through DOMWriter::writeNode();

		}

        catch (const XMLException& toCatch) 

			{

            char* message = XMLString::transcode(toCatch.getMessage());

            XMLString::release(&message);

			}

        catch (const DOMException& toCatch) 

			{

            char* message = XMLString::transcode(toCatch.msg);

            XMLString::release(&message);

			}

        catch (...) 

			{

			} 

	}

void CXmlGenerator::SetWriterFeatures(DOMWriter* aDomWriter)

	{

	if (aDomWriter->canSetFeature(XMLUni::fgDOMWRTEntities, true))

		aDomWriter->setFeature(XMLUni::fgDOMWRTEntities, true);

	if (aDomWriter->canSetFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true))

		 aDomWriter->setFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true);

	if (aDomWriter->canSetFeature(XMLUni::fgDOMWRTNormalizeCharacters, false))

		aDomWriter->setFeature(XMLUni::fgDOMWRTNormalizeCharacters, false);

	if (aDomWriter->canSetFeature(XMLUni::fgDOMWRTSplitCdataSections, true))

		 aDomWriter->setFeature(XMLUni::fgDOMWRTSplitCdataSections, true);

	if (aDomWriter->canSetFeature(XMLUni::fgDOMWRTValidation, false))

		aDomWriter->setFeature(XMLUni::fgDOMWRTValidation, false);

	if (aDomWriter->canSetFeature(XMLUni::fgDOMWRTWhitespaceInElementContent, true))

		 aDomWriter->setFeature(XMLUni::fgDOMWRTWhitespaceInElementContent, true);

	if (aDomWriter->canSetFeature(XMLUni::fgDOMWRTBOM, true))

		aDomWriter->setFeature(XMLUni::fgDOMWRTBOM, true);

	if (aDomWriter->canSetFeature(XMLUni::fgDOMXMLDeclaration, true))

		 aDomWriter->setFeature(XMLUni::fgDOMXMLDeclaration, true);

	}

	{

	WriteComponentVersion(aRootElement, aDocument, aComponent.iComponentDetails.iVersion);

	WriteComponentLocalizables(aRootElement, aDocument, aComponent.iComponentLocalizables);

	WriteComponentProperties(aRootElement, aDocument, aComponent.iComponentProperties);

	WriteComponentFiles(aRootElement, aDocument, aComponent.iComponentFiles);

	WriteComponentDependencies(aRootElement, aDocument, aComponent.iComponentDependency);

	}

void CXmlGenerator::WriteComponentVersion

				(

				DOMElement* aRootElement, 

				DOMDocument* aDocument, 

				XmlDetails::TScrPreProvisionDetail::TComponentDetails::TVersion aVersion

				)

	{

	aRootElement->appendChild(version);

	}

void CXmlGenerator::WriteComponentLocalizables

					(	

						DOMElement* aRootElement, DOMDocument* aDocument, 

						const std::vector<ComponentLocalizable>& aComponentLocalizable 

					)

	{

	std::vector<ComponentLocalizable>::const_iterator compLocIter;

	for( compLocIter = aComponentLocalizable.begin() ; compLocIter != aComponentLocalizable.end() ; ++compLocIter)

		{

		}

	}

void CXmlGenerator::WriteComponentProperties	

					( 

						DOMElement* aRootElement, DOMDocument* aDocument, 

						const std::vector<ComponentProperty>& aComponentProperties 

					)

	{

	std::vector<ComponentProperty>::const_iterator compPropIter;

	for( compPropIter = aComponentProperties.begin() ; compPropIter != aComponentProperties.end() ; ++compPropIter)

		{

		if(compPropIter->iIsIntValue)

			{

			}

		else

			{

			}

		}

	}

void CXmlGenerator::WriteComponentFiles	

					( 

						DOMElement* aRootElement, DOMDocument* aDocument, 

						const std::vector<ComponentFile>& aComponentFiles 

					)

	{

	std::vector<ComponentFile>::const_iterator compFileIter;

	for( compFileIter = aComponentFiles.begin() ; compFileIter != aComponentFiles.end() ; ++compFileIter)

		{

		WriteFileProperties(compFileRoot, aDocument, compFileIter->iFileProperties);

		}

	}

void CXmlGenerator::WriteFileProperties	

					( 

						DOMElement* aRootElement, DOMDocument* aDocument, 

						const std::vector<FileProperty>& aFileProperties 

					)

	{

	std::vector<FileProperty>::const_iterator filePropIter;

	for( filePropIter = aFileProperties.begin() ; filePropIter != aFileProperties.end() ; ++filePropIter)

		{

		if(filePropIter->iIsIntValue)

			{

			}

		else

			{

			}

		}

	}

void CXmlGenerator::WriteComponentDependencies	

					( 

						DOMElement* aRootElement, 

						DOMDocument* aDocument, 

						const ComponentDependency& aComponentDependency 

					)

	{

	if( aComponentDependency.iDependentId.empty())

		return;

	std::vector<ComponentDependencyDetail> componentDependencyList = aComponentDependency.iComponentDependencyList;

	std::vector<ComponentDependencyDetail>::const_iterator compDepIter;

	for( compDepIter = componentDependencyList.begin() ; compDepIter != componentDependencyList.end() ; ++compDepIter)

		{

		}

	}

	{

	DOMElement*  element = aDocument->createElement(aElementName);

	aRootElement->appendChild(element);

	DOMText* textValue = aDocument->createTextNode(aTextValue);

	element->appendChild(textValue);

	}

	{

	DOMElement*  tagName = aDocument->createElement(aTagName);

	aRootElement->appendChild(tagName);

	return tagName;

	}

/**

 * Handles all warnings received while xml parsing. 

 */

bool SchemaDomErrorHandler::handleError(const DOMError& domError)

	{

	return false;

	}