// 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 "TzEntities.h"

#include "TzTables.h"

#include "TZNode.h"

#include "TZDocument.h"

#include "TzHelpers.h"

#include <iostream>

#include <fstream>

#include <cstdio>

#include <algorithm>

using namespace std;

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

// CTzCpString::CTzCpString

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

CTzCpString::CTzCpString(CTZDocument& aDocument)

	:	CPersistedEntityWrapper(aDocument)

	{

	}

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

// CTzCpString::ExternaliseL

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

void CTzCpString::ExternaliseL(ofstream& aFilestream)

	{

	iOffset = (int)aFilestream.tellp() - iDocument.DbHeader()->iOffsetToStringTable;

	TUint8 stringLength = iString.length();

	aFilestream.write((char*)&stringLength,sizeof(stringLength));

	aFilestream << iString.c_str();

	}

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

// CTzCpRegion::CTzCpRegion

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

CTzCpRegion::CTzCpRegion(CTZDocument& aDocument)

	:	CPersistedEntityWrapper(aDocument)

	{

	iRegionalZonesIndex = new CTzCpRegionalZonesIndex(aDocument);

	}

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

// CTzCpRegion::~CTzCpRegion

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

CTzCpRegion::~CTzCpRegion()

	{

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

		{

		iRegionalZonesIndex->iZoneIndex[x]->DecrRefCount();

		}

	delete iRegionalZonesIndex;

	}

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

// CTzCpRegion::ExternaliseL

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

void CTzCpRegion::ExternaliseL(ofstream& aFilestream)

	{

	iPersistedEntity.iOffsetToRegionName = iRegionNameRef->iOffset;

	iPersistedEntity.iOffsetToRegionalZoneIndex = iRegionalZonesIndex->iOffset;

	aFilestream.write((char*)&iPersistedEntity,sizeof(iPersistedEntity));

	}

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

// CTzCpRuleUse::CTzCpRuleUse

// RuleUse constructor.

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

CTzCpRuleUse::CTzCpRuleUse(CTZDocument& aDocument)

	:	CPersistedEntityWrapper(aDocument)

	{

	}

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

// CTzCpRuleUse::~CTzCpRuleUse 

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

CTzCpRuleUse::~CTzCpRuleUse()

	{

	iRuleLetterPtr->DecrRefCount();

	iRuleDefinitionPtr->DecrRefCount();

	}

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

// CTzCpRuleUse::AssembleL

// Populates the CTzCpRuleUse from the current node.

// RuleUse 'To' field may contain 'only' in the olsen files

// This is to show the rule was in use for that year only.  In this case

// we change the to field to match the from field.

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

void CTzCpRuleUse::AssembleL(CTZNode& aNode)

	{

	iPersistedEntity.iFromYear	= atoi(aNode.NodeList()[2]->iValue.c_str());

	if (aNode.NodeList()[3]->iValue.c_str()[0] == 'o')

		{

		iPersistedEntity.iUntilYear = iPersistedEntity.iFromYear;

		}

	else if (aNode.NodeList()[3]->iValue.c_str()[0] == 'm')

		{

		iPersistedEntity.iUntilYear = KMaxTUint16;

		}

	else 

		{

		iPersistedEntity.iUntilYear = atoi(aNode.NodeList()[3]->iValue.c_str());				

		}

	}

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

// CTzCpLink::CTzCpLink

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

CTzCpLink::CTzCpLink(CTZDocument& aDocument)

	:	CPersistedEntityWrapper(aDocument)

	{

	}

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

// CTzCpLink::AssembleL

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

int CTzCpLink::AssembleL(CTZNode& aNode)

	{

	//Add the from value into the string table as is

	//aNode.iNodeList[ELinkFormatFromZone]->iValue;

	//Split the 'To' value into its region/zone parts

	//'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 linkString	= aNode.NodeList()[ELinkFormatToZone]->iValue;

	string fromString	= aNode.NodeList()[ELinkFormatFromZone]->iValue;

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

	iLinkString			= &iDocument.StringTable()->AddString(fromString);

	iLinkString->IncrRefCount();

	if (slashChar > 0)

		{

		iRegionString = &iDocument.StringTable()->AddString(linkString.substr(0,slashChar));

		}

	else

		{

		iRegionString = &iDocument.StringTable()->AddString("");

		}

	iRegionString->IncrRefCount();

	iZoneString			= &iDocument.StringTable()->AddString(linkString.substr(slashChar+1));

	iZoneString->IncrRefCount();

	return 0;

	}

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

// CTzCpLink::ExternaliseL

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

void CTzCpLink::ExternaliseL(ofstream& aFilestream)

	{

	iPersistedEntity.iOffsetToLinkName	= iLinkString->iOffset;

	iPersistedEntity.iOffsetToZone		= iLinkedZoneOffset->iOffset;

	aFilestream.write((char*)&iPersistedEntity,sizeof(iPersistedEntity));

	}

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

// CTzCpRuleUse::ExternaliseL

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

void CTzCpRuleUse::ExternaliseL(ofstream& aFilestream)

	{

	iOffset = (int)aFilestream.tellp() - iDocument.DbHeader()->iOffsetToRuleUsesTable;

	iPersistedEntity.iOffsetToRuleDefinition	= iRuleDefinitionPtr->iOffset;

	iPersistedEntity.iOffsetToRuleLetterString	= iRuleLetterPtr->iOffset;

	aFilestream.write((char*)&iPersistedEntity,sizeof(iPersistedEntity));

	}

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

// CTzCpRuleDefinition::CTzCpRuleDefinition

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

CTzCpRuleDefinition::CTzCpRuleDefinition(CTZDocument& aDocument)

	:	CPersistedEntityWrapper(aDocument)

	{

	}

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

// CTzCpRuleDefinition::AssembleL

// Populates the CTzCpRuleDefinition from the current node

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

int CTzCpRuleDefinition::AssembleL(CTZNode& aNode)

	{

	//Set the time offset

	//Assuming that the 'SAVE' field in a rule is of the format H:MM

	string tmpString	= aNode.NodeList()[ERuleFormatSave]->iValue;

	int breakAt			= tmpString.find_first_of(':');

	int hours			= atoi(tmpString.c_str());

	int minutes			= 0;

	if (tmpString.length() > 1)

		{

		minutes			= atoi(tmpString.substr(2).c_str());

		}

	iPersistedEntity.iStdTimeOffset		= (hours*60) + minutes;

	//Set the month ( 0 - 11)

	iPersistedEntity.iMonth = CTzCpHelpers::GetMonth(aNode.NodeList()[ERuleFormatIn]->iValue);

	//Set the day rule

	tmpString = aNode.NodeList()[ERuleFormatOn]->iValue;

	string searchDayAfterString  = ">=";

	string searchDayBeforeString = "<=";

	if (tmpString.c_str()[0] == 'l')

		{

		iPersistedEntity.iDayRule = ETzDayInLastWeekOfMonth;

		}

	else if (strstr(tmpString.c_str(),searchDayAfterString.c_str()) != NULL)

		{

		iPersistedEntity.iDayRule = ETzDayAfterDate;

		}

	else if (strstr(tmpString.c_str(),searchDayBeforeString.c_str()) != NULL)

		{

		iPersistedEntity.iDayRule = ETzDayBeforeDate;

		}

	else

		{

		iPersistedEntity.iDayRule = ETzFixedDate;

		}

	//Set the day of month.  This is only required if the day rule is 

	//ETzFixedDate, EDayBeforeDate or EDayAfterDate.  Defaults to 0.

	TInt tmpDay;

	switch (iPersistedEntity.iDayRule)

		{

		case ETzFixedDate:

			tmpDay = atoi(tmpString.c_str());

			tmpDay = tmpDay ? tmpDay-1 : 0; // OG: zero-based Day (as used in TDateTime in Symbian OS)

			iPersistedEntity.iDayOfMonth = tmpDay;

		break;

		case ETzDayBeforeDate:

		case ETzDayAfterDate:

			tmpDay = atoi(tmpString.substr(5).c_str());

			tmpDay = tmpDay ? tmpDay-1 : 0; // OG: zero-based Day (as used in TDateTime in Symbian OS)

			iPersistedEntity.iDayOfMonth = tmpDay;

		break;

		default:

			iPersistedEntity.iDayOfMonth = 0;

		break;

		}

	//Set the day of the week.  This only applies if day rule != ETzFixedDate

	iPersistedEntity.iDayOfWeek = CTzCpHelpers::GetDay(tmpString);

	//Set the time of change (in minutes)

	tmpString	= aNode.NodeList()[ERuleFormatAt]->iValue;

	iPersistedEntity.iTimeOfChange = CTzCpHelpers::GetTimeOfDayInMinutes(tmpString);

	//set the time reference

	iPersistedEntity.iTimeReference = CTzCpHelpers::GetTimeReference(tmpString);

	//Spare flags - these will probably be used for implementing write access 

	//if required

	//iPersistedEntity.iReferenceCount	= 0;	//Unused for now

	//iPersistedEntity.iStatus			= 0;	//Unused for now

	return 0;

	}

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

// CTzCpRuleDefinition::ExternaliseL

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

void CTzCpRuleDefinition::ExternaliseL(ofstream& aFilestream)

	{

	iOffset = (int)aFilestream.tellp() - iDocument.DbHeader()->iOffsetToRuleDefinitionsTable;

	aFilestream.write((char*)&iPersistedEntity,sizeof(iPersistedEntity));

	}

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

// CTzCpRuleSet::CTzCpRuleSet

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

CTzCpRuleSet::CTzCpRuleSet(CTZDocument& aDocument,std::string aRuleSetName)

	:	CPersistedEntityWrapper(aDocument) , iName(aRuleSetName)

	{

	}

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

// CTzCpRuleSet::~CTzCpRuleSet

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

CTzCpRuleSet::~CTzCpRuleSet()

	{

	int size = RuleUses().size();

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

		{

		iVector[x]->DecrRefCount();

		}

	}

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

// CTzCpRuleSet::ExternaliseL

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

void CTzCpRuleSet::ExternaliseL(ofstream& aFilestream)

	{

	iOffset = (int)aFilestream.tellp() - iDocument.DbHeader()->iOffsetToRuleSetsTable;

	iPersistedEntity.iNumberOfRuleUses = iVector.size();

	aFilestream.write((char*)&iPersistedEntity,sizeof(iPersistedEntity)-sizeof(iPersistedEntity.iOffsetsToRuleUses));

	TUint16 ruleUseOffset;

	for (int x = 0; x < iPersistedEntity.iNumberOfRuleUses;x++)

		{

		ruleUseOffset = iVector[x]->iOffset;

		aFilestream.write((char*)&ruleUseOffset,sizeof(ruleUseOffset));

		}

	}

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

// CTzCpRuleSet::AddRuleUse

// Adds the index of the CTzCpRuleUse in the rule use table

// to the collection of rule uses

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

void CTzCpRuleSet::AddRuleUse(CTzCpRuleUse& aRuleUse)

	{

	iVector.push_back(&aRuleUse); //The address of the ruleuse

	}

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

// CTzCpRegionalZonesIndex::CTzCpRegionalZoneIndex

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

CTzCpRegionalZonesIndex::CTzCpRegionalZonesIndex(CTZDocument& aDocument)

	:	CPersistedEntityWrapper(aDocument)

	{

	}

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

// CTzCpRegionalZonesIndex::ExternaliseL

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

void CTzCpRegionalZonesIndex::ExternaliseL(ofstream& aFilestream)

	{

	iOffset = (int)aFilestream.tellp() - iDocument.DbHeader()->iOffsetToRegionalZonesTable;

	// sort zone index alphabetically before externalising it

	sort(iZoneIndex.begin(),iZoneIndex.end(),CTzCpZone::SZoneNameSort());

	iPersistedEntity.iNumberOfZones = iZoneIndex.size();

	aFilestream.write((char*)&iPersistedEntity,sizeof(iPersistedEntity) - sizeof(iPersistedEntity.iOffsetsToZones));

	//Write out the zone offsets

	for (int x = 0; x < iPersistedEntity.iNumberOfZones;x++)

		{

		TUint16 zoneOffset = iZoneIndex[x]->iOffset;

		aFilestream.write((char*)&zoneOffset,sizeof(zoneOffset));

		}

	}

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

// CTzCpRegionalZonesIndex::AddZoneIndex

// We add the address of the reference to avoid a double deletion - 

// this zone will already 

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

void CTzCpRegionalZonesIndex::AddZoneIndex(CTzCpZone& aZoneRef)

	{

	iZoneIndex.push_back(&aZoneRef);

	}

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

// CTzCpZone::CTzCpZone

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

CTzCpZone::CTzCpZone(CTZDocument& aDocument)

	:	CPersistedEntityWrapper(aDocument)

	{

	}

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

// CTzCpZone::~CTzCpZone

// When we destroy a zone, we need to decrement all its referenced entity 

// reference counts by 1.

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

CTzCpZone::~CTzCpZone()

	{

	iRegionNameRef->DecrRefCount();

	iZoneNameRef->DecrRefCount();

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

		{

		iTimeAlignments[x]->DecrRefCount();

		}

	}

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

// CTzCpZone::ExternaliseL

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

void CTzCpZone::ExternaliseL(ofstream& aFilestream)

	{

	iOffset = (int)aFilestream.tellp() - iDocument.DbHeader()->iOffsetToZones;

	iPersistedEntity.iLocationId				= iLocationId;

	iPersistedEntity.iOffsetToZoneName			= iZoneNameRef->iOffset;

	iPersistedEntity.iOffsetToRegionName		= iRegionNameRef->iOffset;

	iPersistedEntity.iNumberOfStdTimeAlignments	= iTimeAlignments.size();

	aFilestream.write((char*)&iPersistedEntity,sizeof(iPersistedEntity)-sizeof(iPersistedEntity.iOffsetsToTimeAlignments));

	//Externalise the time alignment offsets

	for (int x = 0; x < iPersistedEntity.iNumberOfStdTimeAlignments; x++)

		{

		TUint16 stdoffset = iTimeAlignments[x]->iOffset;

		aFilestream.write((char*)&stdoffset,sizeof(stdoffset));

		}

	}

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

// CTzCpStdTimeAlignment::CTzCpStdTimeAlignment

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

CTzCpStdTimeAlignment::CTzCpStdTimeAlignment(CTZDocument& aDocument)

	:	CPersistedEntityWrapper(aDocument)

	{

	}

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

// CTzCpStdTimeAlignment::~CTzCpStdTimeAlignment

// When we destroy a CTzCpStdTimeAlignment we need to decrement all its 

// referenced entity reference counts by 1.

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

CTzCpStdTimeAlignment::~CTzCpStdTimeAlignment()

	{

	iOffsetToTimeZoneFormatName->DecrRefCount();

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

		{

		iOffsetsToTimeZonesShortNames[x]->DecrRefCount();

		}

		iRuleSet->DecrRefCount();

	}

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

// CTzCpStdTimeAlignment::AssembleL

// Populates the CTzCpStdTimeAlignment from the current node

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

int CTzCpStdTimeAlignment::AssembleL(CTZNode& aNode)

	{

	string tmpString;

	//Until Year

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

		{

		iPersistedEntity.iUntilYear	= KMaxYear;

		}

	else

		{

		iPersistedEntity.iUntilYear	= atoi(aNode.NodeList()[EZoneFormatUntilYear]->iValue.c_str());

		}

	//Until Month

	if (EZoneFormatUntilMonth >= aNode.NodeList().size())

		{

		iPersistedEntity.iUntilMonth	= 0;

		}

	else

		{

		tmpString = aNode.NodeList()[EZoneFormatUntilMonth]->iValue;

		if (tmpString.empty())

			iPersistedEntity.iUntilMonth = 0;

		else

			iPersistedEntity.iUntilMonth = CTzCpHelpers::GetMonth(tmpString);

		}

	//Until DayOfMonth

	if (EZoneFormatUntilDay >= aNode.NodeList().size())

		{

		iPersistedEntity.iUntilDayOfMonth	= 0;

		}

	else

		{

		tmpString = aNode.NodeList()[EZoneFormatUntilDay]->iValue;

		TInt tmpDay = atoi(aNode.NodeList()[EZoneFormatUntilDay]->iValue.c_str());

		tmpDay = tmpDay ? tmpDay-1 : 0; // zero-based Day (as used in TDateTime in Symbian OS)

		iPersistedEntity.iUntilDayOfMonth	= tmpDay;

		}

	//Until minutes

	//Until Time Reference

	if (EZoneFormatUntilMinutes >= aNode.NodeList().size())

		{

		iPersistedEntity.iUntilTimeInMinutes = 0;

		iPersistedEntity.iUntilTimeReference = 0;

		}

	else

		{

		tmpString = aNode.NodeList()[EZoneFormatUntilMinutes]->iValue;

		iPersistedEntity.iUntilTimeInMinutes = CTzCpHelpers::GetTimeOfDayInMinutes(tmpString);

		iPersistedEntity.iUntilTimeReference = CTzCpHelpers::GetTimeReference(tmpString);

		}

	//GMTOffset in minutes

	tmpString = aNode.NodeList()[EZoneFormatGMTOffset]->iValue;

	iPersistedEntity.iUtcOffset = CTzCpHelpers::GetTimeOfDayInMinutes(tmpString);

	//Set these in the document after completion.

	//Offset to ruleset

	iPersistedEntity.iOffsetToRuleSet = 0;

	//offset to timezoneformat	

	iPersistedEntity.iOffsetToTimeZoneFormatName = 0;

	return 0;

	}

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

// CTzCpStdTimeAlignment::ExternaliseL

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

void CTzCpStdTimeAlignment::ExternaliseL(ofstream& aFilestream)

	{

	iOffset = (int)aFilestream.tellp() - iDocument.DbHeader()->iOffsetToStdTimeAlignmentsTable;

	//Retrieve the ruleset offset

	iPersistedEntity.iOffsetToRuleSet = iRuleSet->iOffset;

	 //Retrieve the time zone format name offset

	iPersistedEntity.iOffsetToTimeZoneFormatName = iDocument.StringTable()->Strings()[iPersistedEntity.iOffsetToTimeZoneFormatName]->iOffset;

	//Set the number of time zones

	iPersistedEntity.iNumberOfTimeZones = iOffsetsToTimeZonesShortNames.size();

	aFilestream.write((char*)&iPersistedEntity,sizeof(iPersistedEntity)-sizeof(iPersistedEntity.iOffsetsToTimeZones));

	//Write the time zone offsets

	int size = iOffsetsToTimeZonesShortNames.size();

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

		{

		TUint16 offsetToTimeZone = iOffsetsToTimeZonesShortNames[x]->iOffset;

		aFilestream.write((char*)&offsetToTimeZone,sizeof(offsetToTimeZone));

		}

	}

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

// End of file

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