// Copyright (c) 2008-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 <vtzrules.h>

#include <tz.h>

#include "agmentry.h"

#include "agmtlsproxy.h"

#include "agmtzrules.h"

#include "agstzruleindex.h"

#include "agmpanic.h"

#include "agmrptdef.h"

#include "agsfilemanager.h"

const TUid KUidAgnSystemTzIndex = {0x10285b96};

const TUid KUidAgnImportedTzIndex = {0x10285b97};

const TUid KUidAgnTimeStamp = {0x102863fb};

const TInt KMinYear = 0;

const TInt KMaxYear = 9999;

/* ------------------- CAgnTzRuleIndexItem -------------------*/

CAgnTzRuleIndexItem::CAgnTzRuleIndexItem(TStreamId aStreamId, CTzRules* aRule) :

	iRefCount(1), iTzRules(aRule)

	{

	iStreamId = aStreamId;

	}

CAgnTzRuleIndexItem::CAgnTzRuleIndexItem() :

	iRefCount(1), iTzRules(NULL)

	{

	}

CAgnTzRuleIndexItem* CAgnTzRuleIndexItem::NewL(RReadStream& aStream)

	{

	CAgnTzRuleIndexItem* self = new (ELeave) CAgnTzRuleIndexItem();

	CleanupStack::PushL(self);

	self->InternalizeL(aStream);

	CleanupStack::Pop(self);

	return self;

	}

CAgnTzRuleIndexItem* CAgnTzRuleIndexItem::NewL(TStreamId aStreamId, CTzRules* aTzRule)

	{

	CAgnTzRuleIndexItem* self = new (ELeave) CAgnTzRuleIndexItem(aStreamId, aTzRule);

	return self;

	}

CAgnTzRuleIndexItem::~CAgnTzRuleIndexItem()

	{

	delete iTzRules;

	}

void CAgnTzRuleIndexItem::IncrementRef()

	{

	++iRefCount;

	}

TInt CAgnTzRuleIndexItem::DecrementRef()

	{

	__ASSERT_DEBUG(iRefCount>0, User::Invariant());

	return --iRefCount;

	}

void CAgnTzRuleIndexItem::ExternalizeL(RWriteStream& aStream) const

	{

	aStream.WriteInt16L(iRefCount);

	aStream << iStreamId;

	}

void CAgnTzRuleIndexItem::InternalizeL(RReadStream& aStream)

	{

	iRefCount = aStream.ReadInt16L();

	aStream >> iStreamId;

	}

void CAgnTzRuleIndexItem::SetRule(CTzRules* aTzRules)

	{

	if (iTzRules)

		{

		delete iTzRules;

		}

	iTzRules = aTzRules;

	}

CTzRules* CAgnTzRuleIndexItem::TzRule() const

	{

	return iTzRules;

	}

const TStreamId& CAgnTzRuleIndexItem::StreamId() const

	{

	return iStreamId;

	}

TBool CAgnTzRuleIndexItem::IsSystemTzRule() const

	{

	return EFalse;

	}

/* ------------------- CAgnSystemTzRuleIndexItem -------------------*/

void CAgnSystemTzRuleIndexItem::ConstructL(const TDesC8& aTzId)

	{

	iTzId = aTzId.AllocL();

	}

CAgnSystemTzRuleIndexItem* CAgnSystemTzRuleIndexItem::NewL(TStreamId aStreamId,	const TDesC8& aTzId, CTzRules* aRule)

	{

	CAgnSystemTzRuleIndexItem* self = new (ELeave) CAgnSystemTzRuleIndexItem(aStreamId, aRule);

	CleanupStack::PushL(self);

	self->ConstructL(aTzId);

	CleanupStack::Pop(self);

	return self;

	}

CAgnSystemTzRuleIndexItem::CAgnSystemTzRuleIndexItem() :

	CAgnTzRuleIndexItem(), iTzId(NULL)

	{

	}

CAgnSystemTzRuleIndexItem::CAgnSystemTzRuleIndexItem(TStreamId aStreamId,

		CTzRules* aRules) :

	CAgnTzRuleIndexItem(aStreamId, aRules), iTzId(NULL)

	{

	}

CAgnSystemTzRuleIndexItem::~CAgnSystemTzRuleIndexItem()

	{

	delete iTzId;

	}

CAgnSystemTzRuleIndexItem* CAgnSystemTzRuleIndexItem::NewL(RReadStream& aStream)

	{

	CAgnSystemTzRuleIndexItem* self = new (ELeave) CAgnSystemTzRuleIndexItem();

	CleanupStack::PushL(self);

	self->InternalizeL(aStream);

	CleanupStack::Pop(self);

	return self;

	}

const TDesC8& CAgnSystemTzRuleIndexItem::TzId() const

	{

	return *iTzId;

	}

void CAgnSystemTzRuleIndexItem::ExternalizeL(RWriteStream& aStream) const

	{

	CAgnTzRuleIndexItem::ExternalizeL(aStream);

	aStream << *iTzId;

	}

void CAgnSystemTzRuleIndexItem::InternalizeL(RReadStream& aStream)

	{

	CAgnTzRuleIndexItem::InternalizeL(aStream);

	iTzId = HBufC8::NewL(aStream, KMaxTInt);

	}

TBool CAgnSystemTzRuleIndexItem::IsSystemTzRule() const

	{

	return ETrue;

	}

/* ------------------- CAgnTzRuleIndex -------------------*/

CAgnTzRuleIndex::CAgnTzRuleIndex(CStreamDictionary& aDictionary, CFileStore& aStore) :

	iDictionary(&aDictionary),

	iStore(&aStore),

	iPosCurSystemTzRule(KErrNotFound),

	iPosFetchedLastTime(0),

	iTzDbChangeTimeStamp(Time::NullTTime()),

	iTzRulesLastModifiedTime(Time::NullTTime())

	{

	}

CAgnTzRuleIndex* CAgnTzRuleIndex::NewL(CStreamDictionary& aDictionary, CFileStore& aStore)

	{

	CAgnTzRuleIndex* self = new(ELeave) CAgnTzRuleIndex(aDictionary, aStore);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return (self);

	}

void CAgnTzRuleIndex::ConstructL()

	{

	iTimeZoneAccessor = CAgnTlsProxy::CreateL(CAgnTlsProxy::TAgnTlsTzRulesType_Server);

	iSystemRuleStreamId = ReadItemsFromStoreL(KUidAgnSystemTzIndex);

	iUserDefinedRuleStreamId = ReadItemsFromStoreL(KUidAgnImportedTzIndex);

	RTz& tzServer = iTimeZoneAccessor->TzServer();

	CTzId* tzid = tzServer.GetTimeZoneIdL();

	CleanupStack::PushL(tzid);

	HandleCurrentTimeZoneChangeL(*tzid);

	CleanupStack::PopAndDestroy(tzid);

	}

/* Read the time stamp of time zone database has been modified last time.

- If the file is newly created, the time stamp will be set to current time

- If the file is re-opened, read the time stamp from the file.

- If the file is re-opened, but there isn't a time stamp, the time stamp will be set to current time

 */

void CAgnTzRuleIndex::ReadTimeStampL()

	{

	TStreamId streamId = iDictionary->At(KUidAgnTimeStamp);

	if (streamId == KNullStreamId)

		{//There is not a time stamp in the file either it is newly created or an existing one.

		TTime currentTime;

		currentTime.UniversalTime();

		iTzDbChangeTimeStamp = currentTime;

		if (RefreshTzRulesL())

			{

			iTzRulesLastModifiedTime = currentTime;

			}

		PersistToStoreL(KUidAgnTimeStamp);

		}

	else

		{//iTzChangTimeStamp is read from file

		ReadFromStoreL(KUidAgnTimeStamp, EFalse);

		}

	}

/** Check if the time zone server has been modified since last time the

 * Calendar server shut down. If so, the time zones of entries cached in the Calendar

 * will be updated. Calendar clients will be also notified with the change if

 * any of time zones associated with Calendar entries have been modified.

 *

 * This function is called when a Calendar file is opened.

 *

 */

void CAgnTzRuleIndex::CheckTzDbModificationL(CAgnServFile& aAgnServFile)

	{

	iAgnFile = &aAgnServFile;

	ReadTimeStampL();

	//This will result in HandleTzRulesChangeL to be called immediatly if a tz change has been published.

	iTimeZoneAccessor->AddSystemTimeObserverL(this);

	}

/*

 Called when the file is closed. It will write the current time to the Calendar file.

 */

void CAgnTzRuleIndex::WriteTimeStampL()

	{

	TStreamId streamId = iDictionary->At(KUidAgnTimeStamp);

	RStoreWriteStream writeStream;

	writeStream.ReplaceLC(*iStore, streamId);

	ExternalizeTimesL(writeStream);

	writeStream.CommitL();

	CleanupStack::PopAndDestroy(&writeStream);

	iStore->CommitL();

	}

void CAgnTzRuleIndex::ExternalizeTimesL(RStoreWriteStream& aWriteStream) const

	{

	aWriteStream << I64LOW(iTzDbChangeTimeStamp.Int64());

	aWriteStream << I64HIGH(iTzDbChangeTimeStamp.Int64());

	aWriteStream << I64LOW(iTzRulesLastModifiedTime.Int64());

	aWriteStream << I64HIGH(iTzRulesLastModifiedTime.Int64());

	}

void CAgnTzRuleIndex::InternalizeTimesL(RReadStream& aReadStream)

	{

	TUint32 low = aReadStream.ReadUint32L();

	TUint32 high = aReadStream.ReadUint32L();

	iTzDbChangeTimeStamp = TTime(MAKE_TINT64(high, low));

	low = aReadStream.ReadUint32L();

	high = aReadStream.ReadUint32L();

	iTzRulesLastModifiedTime = TTime(MAKE_TINT64(high, low));

	}

/* Externalise an array of tz rules or a time stamp to first time Calendar file.

 @param aUid refer to uid of object to write to the file.

 @return Stream Id refer to the object being written to the file

 */

TStreamId CAgnTzRuleIndex::PersistToStoreL(const TUid& aUid)

	{

	RStoreWriteStream writeStream;

	TStreamId streamId = writeStream.CreateLC(*iStore);

	if (aUid == KUidAgnSystemTzIndex)

		{

		ExternalizeRulesL(writeStream, iSystemTzRules);

		}

	else

		if (aUid == KUidAgnImportedTzIndex)

			{

			ExternalizeRulesL(writeStream, iUserDefinedTzRules);

			}

		else

			{

			__ASSERT_ALWAYS(aUid == KUidAgnTimeStamp,User::Invariant());

			ExternalizeTimesL(writeStream);

			}

	writeStream.CommitL();

	CleanupStack::PopAndDestroy(&writeStream);

	iDictionary->AssignL(aUid, streamId);

	// Re-write the dictionary stream

	RStoreWriteStream stream;

	TStreamId rootStreamId = iStore->Root();

	stream.ReplaceLC(*iStore, rootStreamId);

	stream<< *iDictionary;

	stream.CommitL();

	CleanupStack::PopAndDestroy(); // dictionary stream

	iStore->CommitL();

	return streamId;

	}

void CAgnTzRuleIndex::ReadFromStoreL(const TUid& aUid, TBool aRollback)

	{

	TStreamId streamId = iDictionary->At(aUid);

	__ASSERT_ALWAYS(streamId != KNullStreamId, User::Leave(KErrNotFound));

	RStoreReadStream readStream;

	readStream.OpenLC(*iStore, streamId);

	if (aUid == KUidAgnSystemTzIndex)

		{

		InternalizeRulesL(readStream, ETrue, aRollback);

		}

	else

		if (aUid == KUidAgnImportedTzIndex)

			{

			InternalizeRulesL(readStream, EFalse, aRollback);

			}

		else

			{

			__ASSERT_ALWAYS(aUid==KUidAgnTimeStamp,User::Invariant());

			InternalizeTimesL(readStream);

			}

	CleanupStack::PopAndDestroy(&readStream);

	}

TStreamId CAgnTzRuleIndex::ReadItemsFromStoreL(const TUid& aUid, TBool aRollback)

	{

	TStreamId streamId = iDictionary->At(aUid);

	if (streamId == KNullStreamId)

		{

		streamId = PersistToStoreL(aUid);

		}

	else

		{

		ReadFromStoreL(aUid, aRollback);

		}

	return streamId;

	}

void CAgnTzRuleIndex::InternalizeRulesL(RReadStream& aStream,

		TBool aIsSystemRule, TBool aRollback)

	{

	TInt count = aStream.ReadInt16L();

	CAgnTzRuleIndexItem* item= NULL;

	for (TInt ii=0; ii<count; ++ii)

		{

		if (aIsSystemRule)

			{

			item = CAgnSystemTzRuleIndexItem::NewL(aStream);

			}

		else

			{

			item = CAgnTzRuleIndexItem::NewL(aStream);

			}

		CleanupStack::PushL(item);

		RStoreReadStream readStream;

		readStream.OpenLC(*iStore, item->StreamId());

		CTzRules* tzRules = CTzRules::NewL(readStream);

		item->SetRule(tzRules);

		CleanupStack::PopAndDestroy(&readStream);

		if (aIsSystemRule)

			{

			if (aRollback)

				{

				CleanupStack::Pop(item);

				RollbackItemL(iSystemTzRules, item);

				}

			else

				{

				iSystemTzRules.AppendL(item);

				CleanupStack::Pop(item);

				}

			}

		else

			{

			if (aRollback)

				{

				CleanupStack::Pop(item);

				RollbackItemL(iUserDefinedTzRules, item);

				}

			else

				{

				iUserDefinedTzRules.AppendL(item);

				CleanupStack::Pop(item);

				}

			}

		}

	}

void CAgnTzRuleIndex::ExternalizeRulesL(RWriteStream& aStream, const RPointerArray<CAgnTzRuleIndexItem>& aArray) const

	{

	TInt count = aArray.Count();

	aStream.WriteInt16L(count);

	for (TInt ii=0; ii<count; ++ii)

		{

		aArray[ii]->ExternalizeL(aStream);

		}

	}

CAgnTzRuleIndex::~CAgnTzRuleIndex()

	{

	iSystemTzRules.ResetAndDestroy();

	iUserDefinedTzRules.ResetAndDestroy();

	iTimeZoneAccessor->RemoveSystemTimeObserver(this);

	CAgnTlsProxy::Release(iTimeZoneAccessor);

	}

/**

 It is called when:

 Creating a light entry during index building.

 Fetch an entry

 @param reference to the entry fetching tz rules

 */

void CAgnTzRuleIndex::FetchTzRuleL(CAgnSimpleEntry& aEntry)

	{

	CAgnTzRules* tzZone = GetTzRulesFromEntry(aEntry);

	if (tzZone == NULL)

		{

		return;

		}

	TInt pos = KErrNotFound;

	if (tzZone->SystemTzRule())

		{

		pos = FindTzRuleByStreamIdL(tzZone->TzZoneStreamId(), iSystemTzRules,

				ETrue);

		if (pos>=0)

			{

			tzZone->SetTzRules(iSystemTzRules[pos]->TzRule());

			tzZone->SetUseCurrentSystemTzRules((pos == iPosCurSystemTzRule));

			}

		}

	else

		{

		__ASSERT_DEBUG(!tzZone->UseCurrentSystemTzRules(), User::Invariant());

		pos = FindTzRuleByStreamIdL(tzZone->TzZoneStreamId(),

				iUserDefinedTzRules, ETrue);

		if (pos>=0)

			{

			tzZone->SetTzRules(iUserDefinedTzRules[pos]->TzRule());

			}

		}

	if (pos == KErrNotFound)

		{

		AddCurrentSystemTzRuleL(*tzZone);

		}

	}

/**

 Remove a tz rule from one of tz rule arraies

 It should be called when an entry is removed or an entry is updated

 @param reference to the entry to be deleted

 */

void CAgnTzRuleIndex::RemoveTzRuleL(CAgnSimpleEntry& aEntry)

	{

	CAgnTzRules* tzZone = GetTzRulesFromEntry(aEntry);

	if (tzZone == NULL || !tzZone->HasValidTzZoneStreamId())

		{

		return;

		}

	TInt pos = KErrNotFound;

	if (tzZone->SystemTzRule())

		{

		pos = FindTzRuleByStreamIdL(tzZone->TzZoneStreamId(), iSystemTzRules,

				EFalse);

		if (pos >=0)

			{

			DeleteARuleL(pos, iSystemTzRules, iSystemRuleStreamId);

			}

		}

	else

		{

		pos = FindTzRuleByStreamIdL(tzZone->TzZoneStreamId(),

				iUserDefinedTzRules, EFalse);

		if (pos >=0)

			{

			DeleteARuleL(pos, iUserDefinedTzRules, iUserDefinedRuleStreamId);

			}

		}

	__ASSERT_DEBUG(pos != KErrNotFound, Panic(EAgmErrTzRuleIsNotFound));

	User::LeaveIfError(pos);

	}

/**

 Add a tz rule to the array if it is not existing in the array otherwise

 increase the refference count for that rule.

 It is called when:

 An entry is added with a user defined tz rule

 An old format file (9.4 prior) is converted to a new format