// Copyright (c) 2004-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:

// DST TZ Database Compiler 

// 

//

#include "TzGlobals.h"

#include <string>

#include <sstream>

#include <iostream>

#include <algorithm>

#include <direct.h>

#include <iomanip>

#include <sys/stat.h>

#include "TZDocument.h"

#include "TZScanner.h"

#include "TzTables.h"

#include "TzHelpers.h"

using namespace std;

//============================================================================

// CTZDocument::CTZDocument

// Constructor.

//============================================================================

CTZDocument::CTZDocument(MScanner& aScanner)

:	iScanner(aScanner)

	{

	//Create the root element

	iRoot = new CTZElement();

	iRoot->iParent = NULL;

	iOpenedElement = iRoot;

	//Create the tables

	iRuleSetTable			= new CTzCpRuleSetsTable(*this);

	iRuleDefinitionTable	= new CTzCpRuleDefinitionsTable(*this);

	iStringTable			= new CTzCpStringTable(*this);

	iRegionsTable			= new CTzCpRegionsTable(*this);

	iRuleUseTable			= new CTzCpRuleUsesTable(*this);

	iZonesTable				= new CTzCpZonesTable(*this);

	iStdTimeAlignmentTable	= new CTzCpStdTimeAlignmentsTable(*this);

	iLinkTable				= new CTzCpLinksTable(*this);

	ReadConfigurationFile();

	}

//============================================================================

// CTZDocument::~CTZDocument

// Destructor

//============================================================================

CTZDocument::~CTZDocument()

	{

	WriteConfigurationFile();

	if (iRoot)

		delete iRoot;

	delete iRuleSetTable;

	delete iRuleUseTable;

	delete iRuleDefinitionTable;

	delete iStringTable;

	delete iRegionsTable;

	delete iZonesTable;

	delete iStdTimeAlignmentTable;

	delete iLinkTable;

	}

//============================================================================

// CTZDocument::Scan

// Delegates the actual file scanning to our CTzCpScanner object.

// returns KErrNone if succesful, or any TzErrorCode

//============================================================================

int CTZDocument::Scan(const char* aFileName)

	{

	return iScanner.Scan(aFileName);

	}

//============================================================================

// CTZDocument::AddRootChildElement

// Adds a new element as a child of the root node

//============================================================================

void CTZDocument::CreateRootChildElement()

	{

	iOpenedElement	= new CTZElement();

	iOpenedElement->iParent = iRoot;

	iRoot->NodeList().push_back(iOpenedElement);

	}

//============================================================================

// CTZDocument::AddChildElement

// Creates a new CTZElement as a child node of iOpenedElement.

// iOpenedElement is then assigned to the new child node

//============================================================================

void CTZDocument::CreateChildElement()

	{

	iOpenedElement = iOpenedElement->CreateChildElement();

	}

//============================================================================

// CTZDocument::AddAttribute

// Adds an attribute to the current node

//============================================================================

void CTZDocument::AddAttribute(const char* aValue)

	{

	iOpenedElement->AddAttribute(aValue);

	}

//============================================================================

// CTZDocument::CloseElement

// Back up to the parent node

//============================================================================

void CTZDocument::CloseElement()

	{

	if (iOpenedElement != iRoot)

		{

		iOpenedElement = iOpenedElement->iParent;

		}

	}

//============================================================================

// CTZDocument::Assemble

// Iterates through the nodes assembling each one into the relevant T-Classes

//============================================================================

void CTZDocument::AssembleL()

	{

	cout.width(30);

	CTzCpHelpers::PrintStep("Assembling nodes");

	CTZNode* tmpNode;	

	string currentRuleSetName;

	string currentZoneName;

	int size = iRoot->NodeList().size();

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

		{

		tmpNode		= iRoot->NodeList()[i];

		if (tmpNode->CheckNode())

			{

			if (strcmpi(KOlsonRuleTag,tmpNode->NodeList()[0]->iValue.c_str()) == 0)

				AssembleRuleL(*tmpNode);

			else if (strcmpi(KOlsonLinkTag,tmpNode->NodeList()[0]->iValue.c_str()) == 0)

				iLinkTable->AssembleL(*tmpNode); // Assemble Links

			else if (strcmpi(KOlsonZoneTag,tmpNode->NodeList()[0]->iValue.c_str()) == 0)

				AssembleZoneL(*tmpNode);

			}

		}

	}

void CTZDocument::AssembleRuleL(CTZNode& aNode)

	{

	//Conditions tested here:

	// 1: The 'To' year in a rule is >= the start year from the configuration file

	// 2: The 'To' year in a rule is 'max'.

	// 3: The 'To' year in a rule is 'only' but the from year is >= the start year from the configuration file

	//If none of these conditions are met, just dump this rule (do nothing)

	if ((atoi(aNode.NodeList()[ERuleFormatTo]->iValue.c_str()) >= TzGlobals::iStartYear) ||

		(aNode.NodeList()[ERuleFormatTo]->iValue == "max") ||

		(aNode.NodeList()[ERuleFormatTo]->iValue == "only" && atoi(aNode.NodeList()[ERuleFormatFrom]->iValue.c_str()) >= TzGlobals::iStartYear))

		{	

		//==========================Rule Set==========================

		//Get a RuleSet to add the RuleUse to

		CTzCpRuleSet& aRuleSet = iRuleSetTable->AssembleL(aNode);

		//=======================RuleDefinition=======================

		//Assemble a rule definition from the node

		CTzCpRuleDefinition& aRuleDefinition = iRuleDefinitionTable->AssembleL(aNode);

		//=========================RuleLetter=========================

		CTzCpString& aRuleLetter =iStringTable->AddString(aNode.NodeList()[ERuleFormatLetter]->iValue);

		//==========================RuleUse===========================

		CTzCpRuleUse& aRuleUse = iRuleUseTable->AssembleL(aNode);

		aRuleUse.iRuleDefinitionPtr = &aRuleDefinition;

		aRuleDefinition.IncrRefCount();

		aRuleUse.iRuleLetterPtr = &aRuleLetter; 

		aRuleLetter.IncrRefCount();

		//Add the RuleUse reference to the RuleSet				

		aRuleSet.AddRuleUse(aRuleUse);

		aRuleUse.IncrRefCount();

		}

	}

void CTZDocument::AssembleZoneL(CTZNode& aNode)

	{

	//Get indexes for the region and zone name strings in the string table

	string currentZoneName		= aNode.NodeList()[EZoneFormatName]->iValue;

	int slashChar		= currentZoneName.find('/',0);

	//'Region' is first part of a zone identity. eg 'Europe' in 'Europe/London'

	//'Zone'  is second part of a zone identity. eg 'London' in 'Europe/London'

	string regionName;

	if (slashChar > 0)

		{

		regionName = currentZoneName.substr(0,slashChar);

		}

	else

		{

		regionName = "";

		}

	CTzCpString& regionNameRef	= iStringTable->AddString(regionName);

	CTzCpString& zoneNameRef	= iStringTable->AddString(currentZoneName.substr(slashChar+1));

	//Start building the zone

	CTzCpZone* newZone	= iZonesTable->GetZone(zoneNameRef,regionNameRef,true);

	newZone->IncrRefCount();

	regionNameRef.IncrRefCount();

	zoneNameRef.IncrRefCount();

	//Get the region

	CTzCpRegion& aRegion = iRegionsTable->GetRegion(regionNameRef);

	//Add the zone to the regions zone index

	aRegion.iRegionalZonesIndex->AddZoneIndex(*newZone);

	newZone->IncrRefCount();

	//======================Time Alignments=======================

	//Process the zones time alignments

	//Check date range

	if ((EZoneFormatUntilYear >= aNode.NodeList().size()) ||

		(atoi(aNode.NodeList()[EZoneFormatUntilYear]->iValue.c_str()) >= TzGlobals::iStartYear))

		{

		CTzCpString& timeZoneFormatName = iStringTable->AddString(aNode.NodeList()[EZoneFormatFormat]->iValue);

		CTzCpStdTimeAlignment& aNewAlignment = iStdTimeAlignmentTable->AddTimeAlignment(timeZoneFormatName);

		timeZoneFormatName.IncrRefCount();

		aNewAlignment.AssembleL(aNode);

		aNewAlignment.iOffsetToTimeZoneFormatName = &timeZoneFormatName;

		//Offset to ruleset

		aNewAlignment.iRuleSet = iRuleSetTable->GetRuleSet(aNode.NodeList()[EZoneFormatRules]->iValue);

		aNewAlignment.iRuleSet->IncrRefCount();

		//Add the new time alignment to the zone

		newZone->iTimeAlignments.push_back(&aNewAlignment);

		aNewAlignment.IncrRefCount();

		}

	//Do the same for the zones other time alignments

	//A node value of "" indicates a child node

	int size = aNode.NodeList().size();

	for (int j = 0;j < size; j++)

		{

		CTZNode* tmpNode2 = aNode.NodeList()[j];

		if ( tmpNode2->CheckNode() && (tmpNode2->iValue == ""))

			{

			//Check date range

			if ((EZoneFormatUntilYear >= tmpNode2->NodeList().size()) ||

			   (atoi(tmpNode2->NodeList()[EZoneFormatUntilYear]->iValue.c_str()) >= TzGlobals::iStartYear))

				{

				CTzCpString& timeZoneFormatName = iStringTable->AddString(tmpNode2->NodeList()[EZoneFormatFormat]->iValue);

				CTzCpStdTimeAlignment& aNewAlignment = iStdTimeAlignmentTable->AddTimeAlignment(timeZoneFormatName);

				timeZoneFormatName.IncrRefCount();

				aNewAlignment.AssembleL(*tmpNode2);

				aNewAlignment.iOffsetToTimeZoneFormatName = &timeZoneFormatName;

				//Offset to ruleset

				string ruleSetName = aNode.NodeList()[EZoneFormatRules]->iValue;

				aNewAlignment.iRuleSet = iRuleSetTable->GetRuleSet(tmpNode2->NodeList()[EZoneFormatRules]->iValue);

				aNewAlignment.iRuleSet->IncrRefCount();

				//Add the new time alignment to the zone

				newZone->iTimeAlignments.push_back(&aNewAlignment);

				aNewAlignment.IncrRefCount();

				}

			}

		}

	}

//============================================================================

// CTZDocument::Link

// Combines the format string from the stdtimealignment with the ruleuse 

// letter.  The resulting string is added to the string table and the offset 

// to the string is stored back in the stdtimealignment.

// We can expect four different formatting cases eg

//	1: GMT/BST	: Seperate the two strings and add to string table

//	2: C%sT		: Replace %s with letter string from rule use

//	3: GMT		: Add to string table if not already added

//	4: -		: Ignore (remove %s)

//============================================================================

void CTZDocument::Link()

	{

	CTzCpHelpers::PrintStep("Linking");

	string formatString;

	//Iterate through all the STDTimeAlignments

	int size = iStdTimeAlignmentTable->TimeAlignments().size();

	for (int x = 0; x < size;x++)

		{

		CTzCpStdTimeAlignment* aTimeAlignment = iStdTimeAlignmentTable->TimeAlignments()[x];

		string alignmentString = aTimeAlignment->iOffsetToTimeZoneFormatName->iString;

		//Get the ruleset

		if (aTimeAlignment->iPersistedEntity.iOffsetToRuleSet != KMaxTUint16)

			{

			CTzCpRuleSet* aRuleSet = aTimeAlignment->iRuleSet;

			if (aRuleSet->RuleUses().size() == 0)

				{

				//Use the alignment string - there are no rule uses here

				CTzCpString& stringRef = iStringTable->AddString(alignmentString);

				aTimeAlignment->iOffsetsToTimeZonesShortNames.push_back(&stringRef);

				stringRef.IncrRefCount();

				}

			else

				{

				int size2 = aRuleSet->RuleUses().size();

				for (int z = 0; z < size2; z++)

					{

					CTzCpRuleUse* aRuleUse = iRuleUseTable->RuleUses()[z];

					//Test for the following condition:

					// Rule Use 'To' field is >= Time alignment 'From' field - AND

					// Rule Use 'From' field is <= Time Alignment 'To' field

					//We assume that the time alignment start field is the end year of the 

					//previous time alignment unless x == 0

					int timeAlignmentStartYear = (x == 0) ? 0 : iStdTimeAlignmentTable->TimeAlignments()[x-1]->iPersistedEntity.iUntilYear;

					if ((aRuleUse->iPersistedEntity.iUntilYear >= timeAlignmentStartYear) &&

						(aRuleUse->iPersistedEntity.iFromYear <= aTimeAlignment->iPersistedEntity.iUntilYear)) 

						{						

						string letterString = aRuleUse->iRuleLetterPtr->iString;

						int slashPos  = alignmentString.find_first_of('/');

						int insertPos = alignmentString.find_first_of('%');

						if (slashPos != -1)

							{

							formatString = alignmentString.substr(0,slashPos);

							CTzCpString& formatStringRef = iStringTable->AddString(formatString);

							aTimeAlignment->iOffsetsToTimeZonesShortNames.push_back(&formatStringRef);

							formatStringRef.IncrRefCount();

							formatString= alignmentString.substr(slashPos+1);

							CTzCpString& stringRef = iStringTable->AddString(formatString);

							aTimeAlignment->iOffsetsToTimeZonesShortNames.push_back(&stringRef);

							stringRef.IncrRefCount();

							}

						else if (insertPos != -1)

							{

							formatString = alignmentString.substr(0,insertPos);

							CTzCpString& formatStringRef = iStringTable->AddString(formatString);

							aTimeAlignment->iOffsetsToTimeZonesShortNames.push_back(&formatStringRef);

							formatStringRef.IncrRefCount();

							if (letterString[0] != '-')

								{

								formatString += letterString;

								}

							formatString += alignmentString.substr(insertPos+2);

							CTzCpString& stringRef = iStringTable->AddString(formatString);

							aTimeAlignment->iOffsetsToTimeZonesShortNames.push_back(&stringRef);

							stringRef.IncrRefCount();

							}

						}

					}

				}

			}

		}

	//Iterate through the links - discarding invalid ones

	std::vector<CTzCpLink*>::iterator iter = iLinkTable->Links().begin();

	while(iter != iLinkTable->Links().end())

		{

		CTzCpZone* zone = iLinkTable->FindZone((*iter)->iLinkString->iString);

		if (zone == NULL)

			{

			//Cannot find a valid zone for this link - discard

			iter = iLinkTable->Links().erase(iter);

			}

		else

			{

			(*iter)->iLinkedZoneOffset = zone;

			++iter;

			}

		}

	}

//============================================================================

// CTZDocument:Exclude

// Removes unwanted entities from the database. Unwanted regions are specified 

// in the compiler configuration file.  Removing a region may cause certain 

// database entities to become unreferenced.  Each entity has a reference 

// count, the entities will only be persisted if their reference count > 0.

//============================================================================

void CTZDocument::Exclude()

	{

	if (! TzGlobals::iIncludeAllRegions)

		{

		bool keep = false;

		int size = iRegionsTable->Regions().size();

		for (int x = 0; x < size; ++x)

			{

			CTzCpRegion& region = *iRegionsTable->Regions()[x];

			TzGlobals::iAvailableRegions.push_back(region.iRegionNameRef->iString);

			std::vector<string>::iterator it = 

				find(TzGlobals::iIncludedRegions.begin(),TzGlobals::iIncludedRegions.end(),region.iRegionNameRef->iString);

			if (it == TzGlobals::iIncludedRegions.end())

				{

				//Need to remove this region from the region table,

				//add it to the list of excluded regions and

				//decrement all its zones reference counts by 1

				TzGlobals::iExcludedRegions.push_back(region.iRegionNameRef->iString);

				//Don't decrement the regions reference count - it will be 0 by default

				region.iRegionNameRef->DecrRefCount();

				region.iRegionalZonesIndex->DecrRefCount();

				for (int y = 0; y < region.iRegionalZonesIndex->iZoneIndex.size();++y)

					{

					region.iRegionalZonesIndex->iZoneIndex[y]->DecrRefCount();

					}

				}

			else

				{

				//Nothing really references a region, but we give it a reference count because we want to keep it

				region.IncrRefCount();

				}

			}

		}

	else

		{

		//Using all the regions.  We should still remove unreferenced database entries though

		int size = iRegionsTable->Regions().size();

		for (int x = 0; x < size; ++x)

			{

			CTzCpRegion& region = *iRegionsTable->Regions()[x];

			TzGlobals::iAvailableRegions.push_back(region.iRegionNameRef->iString);

			region.IncrRefCount();

			}

		}

	iRegionsTable->RemoveUnreferencedEntities();

	iZonesTable->RemoveUnreferencedEntities();

	iStdTimeAlignmentTable->RemoveUnreferencedEntities();

	iRuleSetTable->RemoveUnreferencedEntities();

	iRuleUseTable->RemoveUnreferencedEntities();

	iRuleDefinitionTable->RemoveUnreferencedEntities();

	iStringTable->RemoveUnreferencedEntities();

	}

//============================================================================

// CTZDocument::HandleScanError

//============================================================================

void CTZDocument::HandleScanError(const char* aFileName,int aLine,int aCol,char aChar)

	{

	stringstream os;

	os << "Error in file " << aFileName << " line:\t" << aLine << "\tColumn:\t" << aCol << "\tUnexpected character:\t" << aChar;

	iErrors.push_back(os.str());

	}

//============================================================================

// CTZDocument::ExternaliseL

// Persist the data model to a file to be included in rom

//============================================================================

void CTZDocument::ExternaliseL()

	{

	ofstream aFile(TzGlobals::iOutputFilePath.c_str(),ios::out | ios::binary);

	if (aFile.bad())

		{

		//Can't open file for writing - Abort

		throw TzGlobals::ETzAbortCreateDatabaseFile;

		}

	//Write header space at start of file

	aFile.write((char*)&iDbHeader,sizeof(iDbHeader));

	//Strings

	iStringTable->ExternaliseL(aFile);

	// add extra characters to make the file size so far a multiple of 4 

	// and avoid potential byte alignment problems

	int filePos = aFile.tellp();

	if (filePos % 4) 

		{

		char padChar = 0;

		for (int i = 4; i > filePos % 4; i--)

			{

			aFile.write(&padChar,sizeof(char));

			}

		}

	//RuleDefinitions

	iRuleDefinitionTable->ExternaliseL(aFile);

	//RuleUses

	iRuleUseTable->ExternaliseL(aFile);

	//RuleSets

	iRuleSetTable->ExternaliseL(aFile);

	//StdTimeAlignments

	iStdTimeAlignmentTable->ExternaliseL(aFile);

	//Zones

	iZonesTable->ExternaliseL(aFile);

	//Regions

	iRegionsTable->ExternaliseL(aFile);

	//Links (must be externalised after zones)

	iLinkTable->ExternaliseL(aFile);

	//After externalising all the tables, the header should now be complete.

	//Reset to the beginning of the file and rewrite the header.

	iDbHeader.iReserved1		= 0;

	iDbHeader.iReserved2		= 0;

	iDbHeader.iReserved3		= 0;

	iDbHeader.iVersion			= KTzDbVersion;

	iDbHeader.iStartYear		= TzGlobals::iStartYear;

	iDbHeader.iReserved4		= 0;

	iDbHeader.iOffsetToDefaultZone = GetDefaultZoneOffset();

	aFile.seekp(0);

	aFile.write((char*)&iDbHeader,sizeof(iDbHeader));

	aFile.close();

	}

//============================================================================

// CTZDocument::GetDefaultZoneOffset

// Finds the default zone specified in the configuration file, and returns the

// offset to this zone in the zone table

//============================================================================