/*

* Copyright (c) 2006-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:  

*

*/

#include "CmdGlobals.h"

#ifdef __WIN__

#pragma warning(disable:4786)

#endif

#include <xercesc/dom/DOM.hpp>

#include <xercesc/framework/LocalFileFormatTarget.hpp>

#include <iostream>

#include <fstream>

#include <vector>

#include <algorithm>

#include <time.h>

#include "ReportGeneratorConstants.h"

#include "CmdGlobals.h"

#include "ReportIssue.h"

#include "XMLModuleErrorHandler.h"

#include "HAException.h"

#include "Utils.h"

#include "Issues.h"

#include "BBCFileUtils.h"

using namespace std;

extern vector<pair<string,pair<string,string> > > HeaderInfoList; // vector<pair< headerfile name, pair<API name, API category>>>

XERCES_CPP_NAMESPACE_USE

const char* KXMLStyleSheet = "xml-stylesheet";

// Style sheet filename

const char* KXMLXSL = "type=\"text/xsl\" href=\"BBCResults.xsl\"";

// Base64 coding characters

const char* KBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-";

#include "ReportGenerator.h"

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

// ReportGenerator::ReportGenerator

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

//

ReportGenerator::ReportGenerator(string aOutputFile) 

: 

iOutputFile(aOutputFile), 

iIssueId(0),

iDOMDocument(0),

iDOMRoot(0)

{

	// START -- Support for file checksum and comments

	unsigned long crc;

	iCrcTable = new unsigned long[256];

	for ( int i = 0; i <= 255 ; i++ )

	{

		crc = i;

		for ( int j = 8 ; j > 0; j-- )

		{

			if ( crc & 1 )

				crc = ( crc >> 1 ) ^ 0xEDB88320L;

			else

				crc >>= 1;

		}

		iCrcTable[i] = crc;

	}

	// END -- Support for file checksum and comments

}

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

// ReportGenerator::~ReportGenerator

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

//

ReportGenerator::~ReportGenerator()

{

	// START -- Support for file checksum and comments

	delete iCrcTable;

	iCrcTable = NULL;

	// END -- Support for file checksum and comments

	if( iDOMDocument )

	{

		iDOMDocument->release();

	}

	for( issueMap::iterator i = iIssueMap.begin(); i != iIssueMap.end(); ++i )

	{

		delete i->second;

		i->second = 0;

	}

}

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

// ReportGenerator::setXSL

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

//

void ReportGenerator::setXSL(string aXSLFilename, bool aIncludeInXML)

{

    iXSLFile = aXSLFilename;

    iEmbedXSL = aIncludeInXML;

}

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

// ReportGenerator::setDTD

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

//

void ReportGenerator::setDTD(string aDTDFilename, bool aIncludeInDTD)

{

    iDTDFile = aDTDFilename;

    iEmbedDTD = aIncludeInDTD;

}

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

// ReportGenerator::startReport

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

//

void ReportGenerator::startReport()

{

    initialiseDOM();

}

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

// ReportGenerator::finishReport

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

//

void ReportGenerator::finishReport()

{

    DOMElement* issuelist = createIssueListNode();

    iDOMRoot->appendChild(issuelist);

    dumpDOMToFile();

}

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

// ReportGenerator::loadStringTables

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

//

void ReportGenerator::loadStringTables(string aFilename)

{

}

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

// ReportGenerator::setCmdLineParms

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

//

void ReportGenerator::setCmdLineParms(map<string, string> aParms)

{

    map<string, string>::iterator begin = aParms.begin();

    map<string, string>::iterator end = aParms.end();

    while (begin != end)

    {

        iParams.insert(*begin);

        begin++;

    }

}

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

// ReportGenerator::getCmdLineParm

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

//

string ReportGenerator::getCmdLineParm(string aParm)

{

    map<string, string>::iterator begin = iParams.find(aParm);

    if (begin != iParams.end())

    {

        return (*begin).second;

    }

    else

    {

        return "Not specified";

    }

}

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

// ReportGenerator::setVersions

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

//

void ReportGenerator::setVersions(string aBaseline, string aCurrent)

{

    iBaselineVersion = aBaseline;

    iCurrentVersion = aCurrent;

}

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

// ReportGenerator::addIssue

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

//

int ReportGenerator::addIssue(ReportIssue* aIssue)

{

	aIssue->iId = iIssueId++;

    string key = "<";

    key += aIssue->HeaderFile();

    key += "><";

    key += aIssue->CompareFileName();

    key += ">";

    issueMapIterator it = iIssueMap.find(key);

    if (it != iIssueMap.end())

    {

		bool lineInfoNeed = true;

        // header entry is present in the report. append the issue to the header issue list

        issueVector* v = it->second;

		issueVector::iterator iv_it=v->begin();

		bool notAnalysed = false;

		 for (; iv_it != v->end(); ++iv_it)

		 {

			 ReportIssue* issue = iv_it->second;

			 TIssueIdentity id = issue->IdentityId();

			 TIssueType type = issue->TypeId();

		}

        if( v->insert(pair<const ReportIssue*, ReportIssue*>(aIssue,aIssue)).second == false )

        {

            return -1;

        }

    } else

    {

        // header entry is not present in the report. create an entry for the header with this issue

        issueVector* v = new issueVector();

        v->insert(pair<const ReportIssue*, ReportIssue*>(aIssue,aIssue));

        issueEntry entry(key,v);

        iIssueMap.insert(entry);

    }

	return iIssueId-1;

}

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

// ReportGenerator::addIssue

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

//

int ReportGenerator::addIssue(const string& aFile, 

                const string& aFQName, const TIssueIdentity& aIdentityId, 

                const TIssueType& aTypeId, const TBCSeverity& aBCSeverityId, 

                const TSCSeverity& aSCSeverityId, const string& aIgnoreInformation, 

{

	string fqName = aFQName;

	int loc = fqName.find(__FUN_MANGLED__);

	if(loc != -1)

	{

	}

}

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

// ReportGenerator::dumpXSLToFile

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

//

void ReportGenerator::dumpXSLToFile()

{

}

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

// ReportGenerator::dumpDTDToFile

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

//

void ReportGenerator::dumpDTDToFile()

{

}

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

// ReportGenerator::dumpDOMToFile

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

//

void ReportGenerator::dumpDOMToFile()

{

    XMLCh* features = _X("Core");

    DOMImplementation* imp =  DOMImplementationRegistry::getDOMImplementation(features);

    _XX(features);

    DOMWriter* writer = ((DOMImplementationLS*)imp)->createDOMWriter();

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

    DOMErrorHandler* errorHandler = new XMLModuleErrorHandler();

    // Set error handler

    writer->setErrorHandler(errorHandler);

    XMLCh* tempfilename = XMLString::transcode(iOutputFile.c_str());

    XMLFormatTarget* ft = new LocalFileFormatTarget(tempfilename);

    writer->writeNode(ft, *iDOMDocument);

    XMLString::release(&tempfilename);

    delete ft;

    writer->release();

    delete errorHandler;

}

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

// ReportGenerator::generateVersionIdNodes

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

//

void ReportGenerator::generateVersionIdNodes()

{

}

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

// ReportGenerator::initialiseDOM

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

//

void ReportGenerator::initialiseDOM()

{    

    XMLCh * features = _X("Core");

    DOMImplementation* imp =  DOMImplementationRegistry::getDOMImplementation(features);

    _XX(features);

    if (imp != NULL)

    {

        try

        {

            XMLCh * repRoot = _X(NODE_REPORTROOT);

            DOMDocument* doc = imp->createDocument(NULL, repRoot, NULL);

		        _XX(repRoot);

		        if( iDOMDocument )

		        {

		            iDOMDocument->release();				

		            iDOMDocument = 0;

		        }

            iDOMDocument = doc;

            XMLCh * stylesheet = XMLString::transcode(KXMLStyleSheet);

            XMLCh * xsl = XMLString::transcode(KXMLXSL);

            // Style sheet is inserted to DOM document

            iDOMDocument->insertBefore( 

                iDOMDocument->createProcessingInstruction(

                  stylesheet,

                    xsl

                ),

                iDOMDocument->getDocumentElement()

            ); 

            XMLString::release(&stylesheet);

            XMLString::release(&xsl);

            iDOMRoot = iDOMDocument->getDocumentElement();

            // Header node created

            DOMElement* header = createHeaderNode();

            iDOMRoot->appendChild(header);

        } catch (const XMLException& /*e*/)

        {

            throw HAException("Error initialising the DOM Document");

        }

    }

}

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

// ReportGenerator::uninitialiseDOM

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

//

void ReportGenerator::uninitialiseDOM()

{

}

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

// ReportGenerator::createOpenNode

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

//

DOMElement* ReportGenerator::createOpenNode(const char* aNodeName)

{

    DOMElement* ret = NULL;

    XMLCh* ch = XMLString::transcode(aNodeName);

    ret = iDOMDocument->createElement(ch);

	XMLString::release(&ch);

    return ret;

}

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

// ReportGenerator::createHeaderNode

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

//

DOMElement* ReportGenerator::createHeaderNode()

{

    DOMElement* ret = NULL;

    ret = createOpenNode(NODE_HEADER);

    vector<DOMElement*> childvec;

    childvec.push_back(createSimpleTextNode(NODE_HEADER_BASELINEVERSION, iBaselineVersion.c_str()));

    childvec.push_back(createSimpleTextNode(NODE_HEADER_CURRENTVERSION, iCurrentVersion.c_str()));

    childvec.push_back(createTimestampNode());

    childvec.push_back(createSimpleTextNode(NODE_HEADER_HAVERSION, HEADER_ANALYSER_VERSION));

    childvec.push_back(createSimpleTextNode(NODE_HEADER_FORMATVERSION, HEADER_ANALYSER_REPORT_VERSION));

    childvec.push_back(createCmdLineNode());

    appendChildrenToNode(ret, childvec);

    return ret;

}

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

// ReportGenerator::removeRemovedSubClasses

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

//

void ReportGenerator::removeRemovedSubClasses()

{

    issueMapIterator it = iIssueMap.begin(); 

    for (; it != iIssueMap.end();++it)

    {

        issueVector* iv = it->second;

		issueVector::iterator iv_it=iv->begin();

        for (; iv_it != iv->end(); ++iv_it)

        {

            ReportIssue* issue = iv_it->second;

			TIssueIdentity id = issue->IdentityId();

			TIssueType type = issue->TypeId();

			//Do not process macros or other than issues type "removed"

			if ( EIssueTypeRemoval == type && EIssueIdentityMacro != id )

			{

				string fqname = issue->FQName();

				fqname += "::";

				issueVector::iterator iv_it2=iv_it;

				++iv_it2;

				for (; iv_it2 != iv->end(); ++iv_it2)

				{

					ReportIssue* issue2 = iv_it2->second;

					string fqname2 = issue2->FQName();

					//If the issue is inside removed class it can be removed from list

					if ( 0 == fqname2.compare(0, fqname.length(), fqname) )

					{

						issueVector::iterator iv_it3 = iv_it2;

						--iv_it2;

						iv->erase(iv_it3);

					} else //No more issues inside removed class so break

					{

						break;

					}

				}

			}

		}

	}

}

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

// ReportGenerator::functionMapping

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

//

TIssueIdentity ReportGenerator::functionMapping(const vector<TIssueIdentity> & ids)

{

	TIssueIdentity ret = EIssueIdentityExportedFunction;

	if (ids.size() == 1)

	{

		ret = ids[0];

	}

	else if (ids.size() == 3)

	{

		ret = EIssueIdentityExportedVirtualInlineFunction;

	}

	else

	{

		if (  (EIssueIdentityExportedFunction == ids[0] && EIssueIdentityVirtualFunction == ids[1]) ||

				(EIssueIdentityExportedFunction == ids[1] && EIssueIdentityVirtualFunction == ids[0]) )

		{

			ret = EIssueIdentityExportedVirtualFunction;

		} else	if (  (EIssueIdentityExportedFunction == ids[0] && EIssueIdentityInlineFunction == ids[1]) ||

				(EIssueIdentityExportedFunction == ids[1] && EIssueIdentityInlineFunction == ids[0]) )

		{

			ret = EIssueIdentityExportedInlineFunction;

		} else if (  (EIssueIdentityInlineFunction == ids[0] && EIssueIdentityVirtualFunction == ids[1]) ||

				(EIssueIdentityInlineFunction == ids[1] && EIssueIdentityVirtualFunction == ids[0]) )

		{

			ret = EIssueIdentityVirtualInlineFunction;

		}

	}

	return ret;

}

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

// ReportGenerator::mergeFunctionIssues

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

//

void ReportGenerator::mergeFunctionIssues()

{

    issueMapIterator it = iIssueMap.begin(); 

    for (; it != iIssueMap.end();++it)

    {

        issueVector* iv = it->second;

		issueVector::iterator iv_it=iv->begin();

        for (; iv_it != iv->end(); ++iv_it)

        {

            ReportIssue* issue = iv_it->second;

			TIssueIdentity id = issue->IdentityId();