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

//

#include "tzdbentities.h"

#include "ReadOnlyTzDb.h"

#include <vtzrules.h>

/**

This const must match the last TTzRuleDay enumeration in tzdefines.h.

@internalComponent

*/

const TInt KValidatedLastDayRule = ETzDayInLastWeekOfMonth;

/**

This const must match the last TTzTimeReference enumeration in tzdefines.h.

@internalComponent

*/

const TInt KValidatedLastTimeReference = ETzWallTimeReference;

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

CTzDbStringsTable* CTzDbStringsTable::NewL(const TTzStringsTable& aRegionsTable)

	{

	CTzDbStringsTable* self = new(ELeave) CTzDbStringsTable(aRegionsTable);

	return self;

	}

CTzDbStringsTable::CTzDbStringsTable(const TTzStringsTable& aRegionsTable)

	: iPersistedEntity(aRegionsTable)

	{

	}

TPtrC8 CTzDbStringsTable::GetStringL(TUint aReferenceToString)

	{

	const TInt KStringsBaseAddress = (TInt)&iPersistedEntity;

	const TInt KLengthAddress = KStringsBaseAddress + aReferenceToString;

	const TInt KStringAddress = KLengthAddress + 1; // length occupies 1 byte

	TUint8 length = *(reinterpret_cast<TUint8*>(KLengthAddress));

	TPtrC8 theString(reinterpret_cast<TUint8*>(KStringAddress),length);

	return theString;

	}

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

CTzDbRegionsTable* CTzDbRegionsTable::NewL(CReadOnlyTzDb& aReadOnlyTzDb, const TTzRegionsTable& aRegionsTable)

	{

	CTzDbRegionsTable* self = new(ELeave) CTzDbRegionsTable(aReadOnlyTzDb, aRegionsTable);

	return self;

	}

CTzDbRegionsTable::CTzDbRegionsTable(CReadOnlyTzDb& aReadOnlyTzDb, const TTzRegionsTable& aRegionsTable)

:	iReadOnlyTzDb(aReadOnlyTzDb), 

	iPersistedEntity(aRegionsTable)

	{

	}

//

// Looks for a region given its name.

// Returns the region wrapped in a CTzDbRegion object.

// Returns NULL if region is not found

//

CTzDbRegion* CTzDbRegionsTable::FindRegionL(const TDesC8& aRegionName)

	{

	const TInt KRegionCount = iPersistedEntity.iNumberOfRegions;

	TTzRegion* region(NULL);

	TPtrC8 name;

	TInt regionAddress = reinterpret_cast<TInt>(&iPersistedEntity) + sizeof(iPersistedEntity.iNumberOfRegions);

	for (TInt i = 0; i < KRegionCount; i++, regionAddress += sizeof(TTzRegion))

		{

		region = reinterpret_cast<TTzRegion*>(regionAddress);

		name.Set(iReadOnlyTzDb.GetStringL(region->iOffsetToRegionName));

		// compare both strings

		if (aRegionName.Compare(name) == 0) // found our region

			{

			return CTzDbRegion::NewL(iReadOnlyTzDb,*region);

			}

		}

	// if it gets here, it means that the region has not been found

	return NULL;

	}

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

CTzDbRegionalZonesTable* CTzDbRegionalZonesTable::NewL(CReadOnlyTzDb& aReadOnlyTzDb, const TTzRegionalZonesTable& aRegionalZonesTable)

	{

	CTzDbRegionalZonesTable* self = new(ELeave) CTzDbRegionalZonesTable(aReadOnlyTzDb, aRegionalZonesTable);

	return self;

	}

CTzDbRegionalZonesTable::CTzDbRegionalZonesTable(CReadOnlyTzDb& aReadOnlyTzDb, const TTzRegionalZonesTable& aRegionalZonesTable)

:	iReadOnlyTzDb(aReadOnlyTzDb), 

	iPersistedEntity(aRegionalZonesTable)

	{

	}

const TTzRegionalZoneIndex& CTzDbRegionalZonesTable::GetTRegionalZoneIndex(TUint aReference)

	{

	return * reinterpret_cast<TTzRegionalZoneIndex*> (aReference + reinterpret_cast<TInt>(&iPersistedEntity));

	}

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

CTzDbZonesTable* CTzDbZonesTable::NewL(CReadOnlyTzDb& aReadOnlyTzDb, const TTzZonesTable& aZonesTable, TInt aZonesDataBaseAddress)

	{

	CTzDbZonesTable* self = new(ELeave) CTzDbZonesTable(aReadOnlyTzDb, aZonesTable, aZonesDataBaseAddress);

	return self;

	}

CTzDbZonesTable::CTzDbZonesTable(CReadOnlyTzDb& aReadOnlyTzDb, const TTzZonesTable& aZonesTable, TInt aZonesDataBaseAddress)

:	iReadOnlyTzDb(aReadOnlyTzDb), 

	iPersistedEntity(aZonesTable),

	iZonesDataBaseAddress(aZonesDataBaseAddress)

	{

	}

CTzDbZone* CTzDbZonesTable::GetZoneL(TUint aReference)

	{

	return CTzDbZone::NewL(iReadOnlyTzDb, GetTZone(aReference));

	}

TTzZone& CTzDbZonesTable::GetTZone(TUint aReference)

	{

	return *reinterpret_cast<TTzZone*>(aReference + iZonesDataBaseAddress);

	}

//

// Performs a binary search in the zones table, looking for the zone with the

// supplied numeric ID.

//

// IMPORTANT: Assumes zones are sorted by LocationId in zones table.

//

CTzDbZone* CTzDbZonesTable::GetZoneByIdL(TUint aNumericId)

	{

	TTzZone* tzone(NULL);

	const TInt KZoneCount = iPersistedEntity.iNumberOfZones;

	TInt start = 0;

	TInt end = KZoneCount - 1;

	TInt mid;

	TBool found = EFalse;

	while(start <= end)

		{

		mid = (end + start) / 2;

		tzone = &GetTZone(iPersistedEntity.iOffsetsToZones[mid]);

		if (aNumericId < tzone->iLocationId)

			{

			end = mid - 1;

			}

		else if (aNumericId == tzone->iLocationId)

			{ 

			// found our zone

			found = ETrue;

			break;

			}

		else

			{

			start = mid + 1;

			}

		}

	if (found)

		{

		return CTzDbZone::NewL(iReadOnlyTzDb, *tzone);

		}

	else

		{

		return NULL;	

		}

	}

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

CTzDbLinksTable* CTzDbLinksTable::NewL(CReadOnlyTzDb& aReadOnlyTzDb, const TTzLinksTable& aLinksTable)

	{

	CTzDbLinksTable* self = new(ELeave) CTzDbLinksTable(aReadOnlyTzDb, aLinksTable);

	return self;

	}

CTzDbLinksTable::CTzDbLinksTable(CReadOnlyTzDb& aReadOnlyTzDb, const TTzLinksTable& aLinksTable)

:	iReadOnlyTzDb(aReadOnlyTzDb), 

	iPersistedEntity(aLinksTable)

	{

	}

CTzDbZone* CTzDbLinksTable::FindZoneL(const TDesC8& aLinkName)

	{

	const TInt KLinkCount = iPersistedEntity.iNumberOfLinks;

	TPtrC8 name;

	TTzLink* link(NULL);

	TInt linkAddress = reinterpret_cast<TInt>(&iPersistedEntity) + sizeof(iPersistedEntity.iNumberOfLinks);

	for (TInt i = 0; i < KLinkCount; i++, linkAddress += sizeof(TTzLink))

		{

		link = reinterpret_cast<TTzLink*>(linkAddress);

		name.Set(iReadOnlyTzDb.GetStringL(link->iOffsetToLinkName));

		if (!name.CompareC(aLinkName))

			{ // we found our link

			return iReadOnlyTzDb.GetZoneL(link->iOffsetToZone);

			}

		}

	// if it gets here, it means that the zone has not been found

	return NULL;

	}

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

CTzDbStdTimeAlignmentsTable* CTzDbStdTimeAlignmentsTable::NewL(const TTzStdTimeAlignmentsTable& aStdTimeAlignmentsTable)

	{

	CTzDbStdTimeAlignmentsTable* self = new(ELeave) CTzDbStdTimeAlignmentsTable(aStdTimeAlignmentsTable);

	return self;

	}

CTzDbStdTimeAlignmentsTable::CTzDbStdTimeAlignmentsTable(const TTzStdTimeAlignmentsTable& aStdTimeAlignmentsTable)

	: iPersistedEntity(aStdTimeAlignmentsTable)

	{

	}

TTzStdTimeAlignment& CTzDbStdTimeAlignmentsTable::GetTStdTimeAlignment(TUint aReference)

	{

	return *reinterpret_cast<TTzStdTimeAlignment*>(aReference + (TInt)&iPersistedEntity);

	}

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

CTzDbRuleSetsTable* CTzDbRuleSetsTable::NewL(CReadOnlyTzDb& aReadOnlyTzDb, const TTzRuleSetsTable& aRuleSetsTable)

	{

	CTzDbRuleSetsTable* self = new(ELeave) CTzDbRuleSetsTable(aReadOnlyTzDb, aRuleSetsTable);

	return self;

	}

CTzDbRuleSetsTable::CTzDbRuleSetsTable(CReadOnlyTzDb& aReadOnlyTzDb, const TTzRuleSetsTable& aRuleSetsTable)

	: iReadOnlyTzDb(aReadOnlyTzDb), iPersistedEntity(aRuleSetsTable)

	{

	}

CTzDbRuleSet* CTzDbRuleSetsTable::GetRuleSetL(TUint aReference)

	{

	return CTzDbRuleSet::NewL(iReadOnlyTzDb, GetTRuleSet(aReference));

	}

TTzRuleSet& CTzDbRuleSetsTable::GetTRuleSet(TUint aReference)

	{

	return * reinterpret_cast<TTzRuleSet*>(aReference + (TInt)&iPersistedEntity);

	}

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

CTzDbRuleUsesTable* CTzDbRuleUsesTable::NewL(const TTzRuleUsesTable& aRuleUsesTable)

	{

	CTzDbRuleUsesTable* self = new(ELeave) CTzDbRuleUsesTable(aRuleUsesTable);

	return self;

	}

CTzDbRuleUsesTable::CTzDbRuleUsesTable(const TTzRuleUsesTable& aRuleUsesTable)

	: iPersistedEntity(aRuleUsesTable)

	{

	}

TTzRuleUse& CTzDbRuleUsesTable::GetTRuleUse(TUint aReference)

	{

	return * reinterpret_cast<TTzRuleUse*> (aReference + (TInt)&iPersistedEntity);

	}

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

CTzDbRuleDefinitionsTable* CTzDbRuleDefinitionsTable::NewL(const TTzRuleDefinitionsTable& aRuleDefinitionsTable)

	{

	CTzDbRuleDefinitionsTable* self = new(ELeave) CTzDbRuleDefinitionsTable(aRuleDefinitionsTable);

	return self;

	}

CTzDbRuleDefinitionsTable::CTzDbRuleDefinitionsTable(const TTzRuleDefinitionsTable& aRuleDefinitionsTable)

	: iPersistedEntity(aRuleDefinitionsTable)

	{

	}

const TTzRuleDefinition& CTzDbRuleDefinitionsTable::GetRuleDefinition(TUint aReference)

	{

	return * reinterpret_cast<TTzRuleDefinition*>(aReference + (TInt)&iPersistedEntity);

	}

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

CTzDbRegion* CTzDbRegion::NewL(CReadOnlyTzDb& aReadOnlyTzDb, const TTzRegion& aRegion)

	{

	CTzDbRegion* self = new(ELeave) CTzDbRegion(aReadOnlyTzDb,aRegion);

	return self;

	}

CTzDbRegion::CTzDbRegion(CReadOnlyTzDb& aReadOnlyTzDb, const TTzRegion& aRegion)

:	iReadOnlyTzDb(aReadOnlyTzDb),

	iPersistedEntity(aRegion)

	{

	}

CTzDbZone* CTzDbRegion::FindZoneL(TUint aCityNameReference)

	{

	TTzRegionalZoneIndex* zoneIndex = const_cast<TTzRegionalZoneIndex*>(&iReadOnlyTzDb.GetTRegionalZoneIndex(iPersistedEntity.iOffsetToRegionalZoneIndex));

	const TInt KZoneCount = zoneIndex->iNumberOfZones;

	TTzZone* tzone(NULL);

	for (TInt i = 0; i < KZoneCount; i++)

		{

		tzone = const_cast<TTzZone*>(&iReadOnlyTzDb.GetTZone(zoneIndex->iOffsetsToZones[i]));

		if (tzone->iOffsetToZoneName == aCityNameReference)

			{ // found our zone

			return CTzDbZone::NewL(iReadOnlyTzDb,*tzone);

			}

		}

	// if it gets here, it means that the zone has not been found

	return NULL;

	}

CTzDbZone* CTzDbRegion::FindZoneL(const TDesC8& aCityName)

	{

	TTzZone* tzone(NULL);

	TTzRegionalZoneIndex* zoneIndex = const_cast<TTzRegionalZoneIndex*>(&iReadOnlyTzDb.GetTRegionalZoneIndex(iPersistedEntity.iOffsetToRegionalZoneIndex));

	const TInt KZoneCount = zoneIndex->iNumberOfZones;

	TPtrC8 name;

	TBool found = EFalse;

	TInt start = 0;

	TInt end = KZoneCount - 1;

	TInt mid;

	// perform a binary search for aCityName among the zones listed in the zone index. This assumes

	// that zones are sorted alphabetically in the zone index.

	while (start <= end)

		{

		mid = (end + start) / 2;

		tzone = const_cast<TTzZone*>(&iReadOnlyTzDb.GetTZone(zoneIndex->iOffsetsToZones[mid]));

		// compare this zone's name with the name we've been given as a parameter

		// use strict comparison method Compare, as CompareC may cause the search to fail:

		// for example, Stanley will come BEFORE St_Helens using the standard collation method in Symbian OS,

		// but it will have been placed AFTER St_Helens by std::sort in he TZ Compiler. This would result

		// in this binary search to fail.

		name.Set(iReadOnlyTzDb.GetStringL(tzone->iOffsetToZoneName));

		if (aCityName.Compare(name) < 0)

			{

			end = mid - 1;

			}

		else if (aCityName.Compare(name) == 0) 

			{ // found our zone

			found = ETrue;

			break;

			}

		else if (aCityName.Compare(name) > 0)

			{

			start = mid + 1;

			}

		}

	if (found)

		{

		return CTzDbZone::NewL(iReadOnlyTzDb,*tzone);

		}

	else

		{

		return NULL;

		}

	}

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

CTzDbZone* CTzDbZone::NewL(CReadOnlyTzDb& aReadOnlyTzDb, const TTzZone& aZone)

	{

	CTzDbZone* self = new(ELeave) CTzDbZone(aReadOnlyTzDb,aZone);

	return self;

	}

CTzDbZone::CTzDbZone(CReadOnlyTzDb& aReadOnlyTzDb, const TTzZone& aZone)

:	iReadOnlyTzDb(aReadOnlyTzDb),

	iPersistedEntity(aZone)

	{

	}

void CTzDbZone::GetRulesL(CTzRules& aRules)

	{	

	// start and end years of interest

	TInt firstYearOfInterest = aRules.StartYear();

	TInt lastYearOfInterest = aRules.EndYear();

	// record last instant of end year, in order to see if we need to get another time alignment

	TDateTime endDateTimeOfInterest(lastYearOfInterest,EDecember,30,23,59,59,0);

	TTime endTimeOfInterest(endDateTimeOfInterest);

	// initialise start time to beginning of startYear (UTC)

	TDateTime startDateTime(firstYearOfInterest,EJanuary,0,0,0,0,0);

	TTime startTime(startDateTime);

	TTime staEndTime;

	TDateTime staEndDateTime;

	TTzTimeReference staTimeReference(ETzUtcTimeReference);

	// the following variables are used to iterate through the list of standard time alignments for this location

	TInt taCount = iPersistedEntity.iNumberOfStdTimeAlignments;

	TInt tmpOffset;

	TTzStdTimeAlignment* ta(NULL);

	TTzStdTimeAlignment* prevTa(NULL);

	CTzDbStdTimeAlignment* sta = NULL;

	// the standard time offset at the beginning of the period of interest has to be set in aTzRules

	TBool initialOffsetHasBeenSet = EFalse;

	// Iterate through std time alignments until we find the one that contains our date of interest.

	// Get the rules for this time alignment, up to the end of the time alignment or the end of our 

	// period of interest (whichever comes first).

	// If the period of interest is covered by only one time alignment, finish and return.

	// If the period of interest is covered by more than one time alignment, repeat procedure with 

	// next time alignment(s) until we reach the end of the period of interest

	for (TInt i = 0; (i < taCount) && (startTime < endTimeOfInterest ); i++)

		{

		// get a standard time alignment

		prevTa = ta; // this will be needed to eventually wrap the time alignment in a CTzDbStdTimeAlignment object

		tmpOffset = iPersistedEntity.iOffsetsToTimeAlignments[i];

		ta = const_cast<TTzStdTimeAlignment*>(&iReadOnlyTzDb.GetTStdTimeAlignment(tmpOffset));

		// check if our time of interest is within this time alignment

		if (IsTimeInStdTimeAlignment(*ta,	startDateTime.Year(),

											startDateTime.Month(),

											startDateTime.Day(),

											startDateTime.Hour(),

											startDateTime.Minute(),

											staTimeReference) )

			{

			// wrap the time alignment in a CTzDbStdTimeAlignment object

			sta = CTzDbStdTimeAlignment::NewL(iReadOnlyTzDb,*ta,prevTa);

			if (sta)

				{

				CleanupStack::PushL(sta); // push #1 - sta

				if (initialOffsetHasBeenSet == EFalse)

					{

					aRules.SetInitialStdTimeOffset(ta->iUtcOffset);

					initialOffsetHasBeenSet = ETrue;

					}

				// staStartDateTime, staEndTime are passed by reference and their values

				// are updated in GetRulesL

				sta->GetRulesL(aRules,startDateTime,staEndDateTime);

				// The time reference to calculate the start of the next time alignment is the time reference

				// in which the end time of this time alignment is expressed 

				staTimeReference = static_cast<TTzTimeReference>(sta->UntilTimeReference());

				CleanupStack::PopAndDestroy(sta); // pop #1 - sta

				staEndTime = staEndDateTime;

				if (staEndTime == Time::MaxTTime())

					{

					startTime = staEndTime; // this will cause loop to finish

					}

				else

					{

					// move just after end of time alignment

					startTime = staEndTime + static_cast<TTimeIntervalSeconds>(1);

					startDateTime = startTime.DateTime();

					}

				}

			} // if IsTimeInStdTimeAlignment(...)

		} // for

	}

TBool CTzDbZone::IsTimeInStdTimeAlignment(const TTzStdTimeAlignment& aStdTa, TInt aYear, TInt aMonth, TInt aDay, TInt aHour, TInt aMinute, TTzTimeReference aTimeRef)

	{

	TInt found = EFalse;

	if (aYear > (TInt)KMaxTUint16)

		{

		aYear = KMaxTUint16; // KMaxTUint16 (0xFFFF) is the value given to year when the end of a time alignment is unknown

		}

	if (aStdTa.iUntilYear > aYear)

		{

		found = ETrue;

		}

	else if (aStdTa.iUntilYear == aYear)

		{

		if ( (aStdTa.iUntilMonth > aMonth) || (aStdTa.iUntilMonth == KMaxTUint8) )

			{

			found = ETrue;

			}

		else if (aStdTa.iUntilMonth == aMonth)

			{

			// evaluate the day and time the time alignment ends 

			// and see if the received time falls in or out of the t.a.

			TTime ourTime;

			if (aYear >= (TInt)KMaxTUint16)

				{

				ourTime = Time::MaxTTime();

				}

			else

				{

				TDateTime ourDateTime(aYear,

									(TMonth)aMonth,

									aDay,

									aHour,

									aMinute,

									0,

									0);

				ourTime = ourDateTime;

				// convert ourTime to UTC

				if (aTimeRef == ETzStdTimeReference)

					{

					ourTime -= static_cast<TTimeIntervalMinutes>(aStdTa.iUtcOffset);

					}

				}

			TTime endTime;

			if (aStdTa.iUntilYear == KMaxTUint16)

				{