/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:  Definitions for the class CATDataSaver.

*

*/

#include "../inc/catdatasaver.h"

#include <xercesc/util/OutOfMemoryException.hpp>

#if defined(XERCES_NEW_IOSTREAMS)

#include <iostream>

#else

#include <iostream.h>

#endif

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

// CATDataSaver::CATDataSaver

// Constructor.

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

CATDataSaver::CATDataSaver( void )

{

	LOG_FUNC_ENTRY("CATDataSaver::CATDataSaver");

	m_iLoggingLevel = DEFAULT_LOGGING_LEVEL;

	m_bPrintImmediately = true;

	m_bXMLInitOk = false;

	m_bUdebBuild = true;

	m_iRunNumber = 1;

	m_pDomDoc = NULL;

	m_pRootElem = NULL;

	m_Serializer = NULL;

	m_pCurrentLeakElem = NULL;

	m_pRunElement = NULL;

	m_pMemoryLeaks = NULL;

	m_pHandleLeaks = NULL;

	m_pCurrentSubTestElem = NULL;

	m_pSubtestMemoryLeaks = NULL;

}

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

// CATDataSaver::~CATDataSaver

// Destructor.

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

CATDataSaver::~CATDataSaver(void)

{

	LOG_FUNC_ENTRY("CATDataSaver::~CATDataSaver");

	if( m_bXMLInitOk )

	{

		if( m_Serializer )

			delete m_Serializer;

		m_pDomDoc->release();

		xercesc::XMLPlatformUtils::Terminate();

	}

}

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

// CATDataSaver::SaveLinesToFile

// Gets logging level.

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

void CATDataSaver::SaveLinesToFile( const char* pFileName, int iDataToSave )

{

	LOG_FUNC_ENTRY("CATDataSaver::SaveLinesToFile");

	// Nothing to print?

	if( m_vLines.empty() )

	{

		printf( "No output data." );

		return;

	}

	if( iDataToSave != XML_DATA )

	{

		ofstream out( pFileName );

		if( !out.good() )

		{

			printf( "Can not open file: %s\n", pFileName );

			return;

		}

		switch( iDataToSave )

		{

			case TEXT_DATA:

				for( int i = 0 ; i < (int)m_vLines.size() ; i++ )

				{

					out << m_vLines[i].c_str();

				}

			break;

		}

		out.close();

	}

	else

	{

		if( m_bXMLInitOk )

		{

			xercesc::XMLFormatTarget* myFormTarget = NULL;

			try

			{

				myFormTarget = new xercesc::LocalFileFormatTarget( pFileName );

				m_Serializer->writeNode(myFormTarget, *m_pDomDoc);

			}

			catch(...)

			{

				printf( "Can not save output file: %s.", pFileName );

			}

			if( myFormTarget )

				delete myFormTarget; //lint !e118

		}

	}

}

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

// CATDataSaver::PrintLinesToScreen

// Prints all saved lines to screen.

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

void CATDataSaver::PrintLinesToScreen( void )

{

	LOG_FUNC_ENTRY("CATDataSaver::PrintLinesToScreen");

	// Nothing to print?

	if( m_vLines.empty() )

	{

		printf( "No output data." );

		return;

	}

	for( int i = 0 ; i < (int)m_vLines.size() ; i++ )

	{

		printf( m_vLines[i].c_str() );	

	}

}

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

// CATDataSaver::AddLineToFirst

// Adds saved line to first in database.

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

void CATDataSaver::AddLineToFirst( void )

{

	LOG_LOW_FUNC_ENTRY("CATDataSaver::AddLineToFirst");

	m_sLine.append( "\n" );

	m_vLines.insert( m_vLines.begin(), m_sLine );

	m_sLine.clear();

}

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

// CATDataSaver::AddLineToLast

// Adds saved line to last in database.

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

void CATDataSaver::AddLineToLast()

{

	LOG_LOW_FUNC_ENTRY("CATDataSaver::AddLineToLast");

	m_sLine.append( "\n" );

	string sTempDataLine;

	m_vLines.push_back( m_sLine );

	SaveXML( m_sCarbideDataLine, ITEM );

	if( m_bPrintImmediately )

	{

		printf( m_sLine.c_str() );

	}

	m_sCarbideDataLine.clear();

	m_sLine.clear();

}

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

// CATDataSaver::AddString

// Adds string to current line.

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

void CATDataSaver::AddString( const char* pData, bool bSaveCarbideData )

{

	LOG_LOW_FUNC_ENTRY("CATDataSaver::AddString");

	m_sLine.append( pData );

	if( bSaveCarbideData )

	{

		m_sCarbideDataLine.append( pData );

		m_sCarbideDataLine.append(";");

	}

}

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

// CATDataSaver::AddInteger

// Converts integer to string and adds it to current line.

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

void CATDataSaver::AddInteger( int iValue, bool bSaveCarbideData )

{

	LOG_LOW_FUNC_ENTRY("CATDataSaver::AddInteger");

	char cTemp[128];

	string sValue( itoa( iValue, cTemp, 10 ) );

	m_sLine.append( sValue );

	if( bSaveCarbideData )

	{

		m_sCarbideDataLine.append( sValue );

		m_sCarbideDataLine.append(";");

	}

}

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

// CATDataSaver::SetLoggingLevel

// Sets logging level.

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

void CATDataSaver::SetLoggingLevel( int iLoggingLevel )

{

	LOG_FUNC_ENTRY("CATDataSaver::SetLoggingLevel");

	// Check that new logging level is valid 

	// Acceptable values are between MIN_LOGGING_LEVEL and 

    // MAX_LOGGING_LEVEL including them

	if( iLoggingLevel >= MIN_LOGGING_LEVEL && iLoggingLevel <= MAX_LOGGING_LEVEL )

	{

		m_iLoggingLevel = iLoggingLevel;

	}

	else

	{

		// New logging level value is invalid => set default logging level

		m_iLoggingLevel = DEFAULT_LOGGING_LEVEL;

	}

}

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

// CATDataSaver::GetLoggingLevel

// Gets logging level.

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

int CATDataSaver::GetLoggingLevel( void )

{

	LOG_LOW_FUNC_ENTRY("CATDataSaver::GetLoggingLevel");

	return m_iLoggingLevel;

}

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

// CATDataSaver::SetPrintFlag

// Sets print immediately flag.

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

void CATDataSaver::SetPrintFlag( bool bPrintImmediately )

{

	LOG_FUNC_ENTRY("CATDataSaver::SetPrintFlag");

	m_bPrintImmediately = bPrintImmediately;

}

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

// CATDataSaver::SaveCarbideDataHeader

// Sets data header for Carbide data.

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

void CATDataSaver::SaveCarbideDataHeader( void )

{

	LOG_FUNC_ENTRY("CATDataSaver::SaveCarbideDataHeader");

	SaveXML( m_sCarbideDataLine, LEAK );

	m_sCarbideDataLine.clear();

}

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

// CATDataSaver::InitXML

// Initializes xerces xml parser.

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

bool CATDataSaver::InitXML( void )

{

	LOG_FUNC_ENTRY("CATDataSaver::InitXML");

	try 

	{

		xercesc::XMLPlatformUtils::Initialize();

	}

	catch ( ... )//(const XMLException& toCatch) 

	{

		// Do your failure processing here

		printf("XML initialization failed.\n");

		return false;

	}

	// Error code.

	int errorCode = 0;

	// getDomIMplementation returns null if source has none.

	xercesc::DOMImplementation* impl = xercesc::DOMImplementationRegistry::getDOMImplementation(L"Core");

	if (impl != NULL)

    {

		// Create new DOMWriter.

		m_Serializer = ((xercesc::DOMImplementationLS*)impl)->createDOMWriter();

		// New document.

        try

        {

			m_pDomDoc = impl->createDocument(

                        0,                    // Root element namespace URI.

                        L"results",         // Root element name

                        0);                   // Document type object (DTD).

            m_pRootElem = m_pDomDoc->getDocumentElement();

        }

        catch (const xercesc::OutOfMemoryException&)

        {

            XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;

            errorCode = 5;

        }

        catch (const xercesc::DOMException& e)

        {

            XERCES_STD_QUALIFIER cerr << "DOMException code is:  " << e.code << XERCES_STD_QUALIFIER endl;

            errorCode = 2;

        }

        catch (...)

        {

            XERCES_STD_QUALIFIER cerr << "An error occurred creating the document" << XERCES_STD_QUALIFIER endl;

            errorCode = 3;

        }

    }  // (inpl != NULL)

    else

    {

        XERCES_STD_QUALIFIER cerr << "Requested implementation is not supported" << XERCES_STD_QUALIFIER endl;

        errorCode = 4;

    }

	if( !errorCode )

	{

		m_bXMLInitOk = true;

		return true;

	}

	else

	{

		return false;

	}

}

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

// CATDataSaver::WCharToChar

// Converts wchar_t* -> char*.

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

void CATDataSaver::WCharToChar( string& sInput, const WCHAR* Source )

{

	LOG_LOW_FUNC_ENTRY("CATDataSaver::WCharToChar");

	if( !Source )

		return;

    int i = 0;

    while( Source[i] != '\0' )

    {

		char c = (CHAR)Source[i];

		sInput.append( &c, 1 );

        ++i;

    }

}

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

// CATDataSaver::CharToWChar

// Converts char* -> wchar_t*.

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

LPWSTR CATDataSaver::CharToWChar( const char* str )

{

	LOG_LOW_FUNC_ENTRY("CATDataSaver::CharToWChar");

    LPWSTR out = NULL;

    if( str != NULL )

    {

        int in_len = (int)strlen( str );

        int out_len = MultiByteToWideChar(CP_ACP, 0, str, in_len, NULL, 0) + 2;

        out = new WCHAR[out_len];

        if (out)

        {

            memset(out, 0x00, sizeof(WCHAR)*out_len);

            MultiByteToWideChar(CP_ACP, 0, str, in_len, out, in_len);

        }

    }

    return out;

}

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

// CATDataSaver::SaveXML

// Writes data to xml tree.

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

void CATDataSaver::SaveXML( string sInput, int iElementType )

{

	LOG_FUNC_ENTRY("CATDataSaver::SaveXML");

	// Variables ok?

	if( sInput.empty() || m_pDomDoc == NULL )

	{

		return;

	}

	try

	{

		switch( iElementType )

		{

			case RESULT:

			{

				// Print number of runs

				string sTemp = GetStringUntilNextGivenChar( sInput, ';' );

				LPWSTR wTemp = CharToWChar( sTemp.c_str() );

				m_pRootElem->setAttribute( L"runs", (const LPWSTR)wTemp );

				// Print failed runs

				sTemp = GetStringUntilNextGivenChar( sInput, ';' );

				if( wTemp )

					delete[] wTemp;

				wTemp = CharToWChar( sTemp.c_str() );

				m_pRootElem->setAttribute( L"failed", (const LPWSTR)wTemp );

				if( wTemp )

					delete[] wTemp;

			}

			break;

			case RUN:

			{

				if( m_pRootElem == NULL )

					return;

				xercesc::DOMElement* runElem = m_pDomDoc->createElement( L"run" );

				m_pRootElem->appendChild( runElem );

				// Reset handle leaks.

				m_pHandleLeaks = NULL;

				// Print start time

				string sTemp = GetStringUntilNextGivenChar( sInput, ';' );

				LPWSTR wTemp = CharToWChar( sTemp.c_str() );

				runElem->setAttribute( L"start_time", (const LPWSTR)wTemp );

				runElem->setAttribute( L"end_time", NULL );

				if( wTemp )

					delete[] wTemp;

				// Print build target

				sTemp = GetStringUntilNextGivenChar( sInput, ';' );

				wTemp = CharToWChar( sTemp.c_str() );

				runElem->setAttribute( L"build_target", (const LPWSTR)wTemp );

				if( wTemp )

					delete[] wTemp;

				// Print process name

				wTemp = CharToWChar( sInput.c_str() );

				runElem->setAttribute( L"process_name", (const LPWSTR)wTemp );

				m_pRunElement = runElem;

				char cTemp[128];

				if( wTemp )

					delete[] wTemp;

				wTemp = CharToWChar( itoa( m_iRunNumber, cTemp, 10 ) );

				runElem->setAttribute( L"id", (const LPWSTR)wTemp );

				m_iRunNumber++;

				if( wTemp )

					delete[] wTemp;

			}

			break;

			case LEAK:

			{

				m_pCurrentLeakElem = m_pDomDoc->createElement( L"leak" );

				if( m_pCurrentLeakElem == NULL || m_pRunElement == NULL )

					return;

				// Sub test?

				if( m_pCurrentSubTestElem )

					m_pCurrentSubTestElem->appendChild( m_pCurrentLeakElem );

				else

					m_pRunElement->appendChild( m_pCurrentLeakElem );

				// Print leak ID

				string sTemp = GetStringUntilNextGivenChar( sInput, ';' );

				LPWSTR wTemp = CharToWChar( sTemp.c_str() );

				m_pCurrentLeakElem->setAttribute( L"id", (const LPWSTR)wTemp );

				// Print leak size

				sTemp = GetStringUntilNextGivenChar( sInput, ';' );

				if( wTemp )

					delete[] wTemp;

				wTemp = CharToWChar( sTemp.c_str() );

				m_pCurrentLeakElem->setAttribute( L"size", (const LPWSTR)wTemp );

				// Print leak address

				sTemp = GetStringUntilNextGivenChar( sInput, ';' );

				if( wTemp )

					delete[] wTemp;

				wTemp = CharToWChar( sTemp.c_str() );

				m_pCurrentLeakElem->setAttribute( L"memaddress", (const LPWSTR)wTemp );

				// Print leak time

				sTemp = GetStringUntilNextGivenChar( sInput, ';' );

				if( wTemp )

					delete[] wTemp;

				wTemp = CharToWChar( sTemp.c_str() );

				m_pCurrentLeakElem->setAttribute( L"time", (const LPWSTR)wTemp );

				// Print leak module

				sTemp = GetStringUntilNextGivenChar( sInput, ';' );

				if( wTemp )

					delete[] wTemp;

				wTemp = CharToWChar( sTemp.c_str() );

				m_pCurrentLeakElem->setAttribute( L"module", (const LPWSTR)wTemp );

				if( wTemp )

					delete[] wTemp;

			}

			break;

			case ITEM:

			{

				xercesc::DOMNode* callstackNode = NULL;

				xercesc::DOMElement* callstackElem = NULL;

				if( m_pCurrentLeakElem  == NULL )

					return;

				// Print module name

				if( !m_pCurrentLeakElem->hasChildNodes() )

				{

					callstackElem = m_pDomDoc->createElement( L"callstack" );

					m_pCurrentLeakElem->appendChild( callstackElem );

					callstackNode = callstackElem;

				}

				else

				{

					callstackNode = m_pCurrentLeakElem->getFirstChild();

				}

				// Add callstack item

				xercesc::DOMElement* itemElem = m_pDomDoc->createElement( L"item" );

				callstackNode->appendChild( itemElem );

				// Print memory address name

				string sTemp = GetStringUntilNextGivenChar( sInput, ';' );

				LPWSTR wTemp = CharToWChar( sTemp.c_str() );

				itemElem->setAttribute( L"memaddress", (const LPWSTR)wTemp );