// Copyright (c) 1998-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 "agmtlsproxy.h"

#include "agmcalendartime.h"

#include <vtzrules.h>

#include <tzconverter.h>

const TInt KMinYear = 0;

const TInt KMaxYear = 9999;

CAgnTlsProxy* CAgnTlsProxy::NewL(TAgnTlsTzRulesType aTzRulesType)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aTzRulesType);

	CleanupStack::Pop(self);

	return self;

	}

CAgnTlsProxy::~CAgnTlsProxy()

	{

	delete iCurrentTzChangeObserver;

	delete iTzRulesChangeObserver;

	delete iTimeConverter;

	delete iFixedTimeMode;

	delete iFloatingTimeMode;

	delete iTlsTzRules;

	iTzServer.Close();

	iObservers.Reset();

	}

EXPORT_C CAgnTlsProxy* CAgnTlsProxy::CreateL(TAgnTlsTzRulesType aTzRulesType)

	{

	CAgnTlsProxy* self = static_cast<CAgnTlsProxy*>(Dll::Tls());

	if (!self)

		{

		self = CAgnTlsProxy::NewL(aTzRulesType);

		Dll::SetTls(self);

		}

	++self->iRefCount;

	return self;

	}

EXPORT_C void CAgnTlsProxy::Release(TAny* /*aRef*/)

	{

	CAgnTlsProxy* self = static_cast<CAgnTlsProxy*>(Dll::Tls());

	if(self)

	    {

	    if (--self->iRefCount <= 0)

	        {

	        __ASSERT_DEBUG(self->iRefCount == 0, User::Invariant());

	        delete self;

	        Dll::FreeTls();

	        }

	    }	

	}

CAgnTlsProxy::CAgnTlsProxy()

	:iRefCount(0)

	{

	}

void CAgnTlsProxy::ConstructL(TAgnTlsTzRulesType aTzRulesType)

	{

	User::LeaveIfError(iTzServer.Connect());

	iTimeConverter = CTzConverter::NewL(iTzServer);

	iFixedTimeMode = new (ELeave) TAgnCalendarFixedTimeMode(*iTimeConverter);

	iFloatingTimeMode = new (ELeave) TAgnCalendarFloatingTimeMode(*iTimeConverter);

	switch(aTzRulesType)

		{

		case TAgnTlsTzRulesType_Client:

			iTlsTzRules = new (ELeave) CAgnClientTlsTzRules();

			break;

		case TAgnTlsTzRulesType_Server:

			iTlsTzRules = new (ELeave) CAgnServerTlsTzRules();

			break;

		default:

			iTlsTzRules = NULL;

			break;

		}

	iCurrentTzChangeObserver = CAgnTzChangeObserver::NewL(*this, NTzUpdate::ECurrentTimeZoneId);

	iTzRulesChangeObserver = CAgnTzChangeObserver::NewL(*this, NTzUpdate::ETzRulesChange);;

	}

const TAgnCalendarFixedTimeMode& CAgnTlsProxy::FixedTimeMode() const

	{

	return *iFixedTimeMode;

	}

const TAgnCalendarFloatingTimeMode& CAgnTlsProxy::FloatingTimeMode() const

	{

	return *iFloatingTimeMode;

	}

EXPORT_C RTz& CAgnTlsProxy::TzServer()

	{

	return iTzServer;

	}

TUint16 CAgnTlsProxy::CurrentTzId() const

	{

	return iTimeConverter->CurrentTzId();

	}

CTzRules* CAgnTlsProxy::GetZoneForRulesL(const CTzRules& aRules)

	{

	CTzRules* foundTzRules = NULL;

	if(iTlsTzRules)

		{

		foundTzRules = iTlsTzRules->GetSharedTzRulesL(aRules);

		}

	return foundTzRules;

	}

void CAgnTlsProxy::ReferenceRemoved(const CTzRules* aReference)

	{

	if(iTlsTzRules)

		{

		iTlsTzRules->ReferenceRemoved(aReference);

		}

	}

EXPORT_C CTzRules* CAgnTlsProxy::GetCurrentSystemTzRulesL()

	{

	if(iTlsTzRules)

		{

		return iTlsTzRules->GetCurrentSystemTzRulesL(iTzServer);

		}

	return NULL;

	}

void CAgnTlsProxy::HandleTzPropertyChangeL(NTzUpdate::TPropertyKeys aTzChangePropertyKey)

	{

	if(iTlsTzRules)

		{

		iTlsTzRules->SystemTzZoneChangedL(iTzServer, aTzChangePropertyKey);

		}

	// Notify observers

	__ASSERT_DEBUG(aTzChangePropertyKey==NTzUpdate::ECurrentTimeZoneId || aTzChangePropertyKey==NTzUpdate::ETzRulesChange, User::Invariant());

	const TInt KObserverCount(iObservers.Count());

	if(aTzChangePropertyKey == NTzUpdate::ECurrentTimeZoneId)

		{

		CTzId* sysTime = iTzServer.GetTimeZoneIdL();

		CleanupStack::PushL(sysTime);

		for (TInt i(0) ; i < KObserverCount ; ++i)

			{

			iObservers[i]->HandleCurrentTimeZoneChangeL(*sysTime);

			}

		CleanupStack::PopAndDestroy(sysTime);

		}

	else 

		{

		TPckgBuf<NTzUpdate::TTzRulesChange> pubSubBuf;

		if(KErrNone == RProperty::Get(NTzUpdate::KPropertyCategory, NTzUpdate::ETzRulesChange, pubSubBuf))

			{

			for (TInt i(0) ; i < KObserverCount ; ++i)

				{

				iObservers[i]->HandleTzRulesChangeL(pubSubBuf().iUTCTimeOfRulesChange);

				}

			}

		}

	}

EXPORT_C void CAgnTlsProxy::AddSystemTimeObserverL(MAgnTzChangeObserver* aObserver)

	{

	TRAPD(err, iObservers.InsertInAddressOrderL(aObserver));

	if(err != KErrNone && err != KErrAlreadyExists)

		{

		User::Leave(err);

		}

	//Get the time stamp of time zone database changed last time and force the observer to respond 

	TPckgBuf<NTzUpdate::TTzRulesChange> pubSubBuf;

	if(KErrNone == RProperty::Get(NTzUpdate::KPropertyCategory, NTzUpdate::ETzRulesChange, pubSubBuf))

		{

		TTime tzChange = pubSubBuf().iUTCTimeOfRulesChange;

		aObserver->HandleTzRulesChangeL(tzChange);

		}

	}

EXPORT_C void CAgnTlsProxy::RemoveSystemTimeObserver(MAgnTzChangeObserver* aObserver)

	{

	TInt index(iObservers.FindInAddressOrder(aObserver));

	if (index != KErrNotFound)

		{

		iObservers.Remove(index);

		}

	}

#if defined(_DEBUG)

EXPORT_C void CAgnTlsProxy::__dbgClearTzClientCacheL(TBool aRestartCaching)

	{

	// This will clear the actualised rules cache

	CTzRules* rules = iTlsTzRules->GetCurrentSystemTzRulesL(iTzServer);

	rules->SetInitialStdTimeOffset(rules->InitialStdTimeOffset());

	iTlsTzRules->ReferenceRemoved(rules);

	iTzServer.__dbgClearCacheL(aRestartCaching);

	}

#else

EXPORT_C void CAgnTlsProxy::__dbgClearTzClientCacheL(TBool /*aRestartCaching*/)	{}

#endif

//

// Tls Shared Time Zone Rules classes

//

CAgnTlsTzRules::CAgnTlsTzRules() : iCurrentSystemTzRules(NULL) 

	{

	}

CAgnTlsTzRules::~CAgnTlsTzRules()

	{

	}

CTzRules* CAgnTlsTzRules::GetSystemTzFromTzServerL(RTz& aTzServer)

	{

	TTime startTime(0);

	TTime endTime(0);

	return aTzServer.GetTimeZoneRulesL(startTime, endTime, ETzUtcTimeReference);

	}

CAgnServerTlsTzRules::~CAgnServerTlsTzRules()

	{

	delete iCurrentSystemTzRules;

	}

CTzRules* CAgnServerTlsTzRules::GetSharedTzRulesL(const CTzRules& aTzRules)

	{

	return aTzRules.CloneL();

	}

void CAgnServerTlsTzRules::ReferenceRemoved(const CTzRules* aReference)

	{

	__ASSERT_DEBUG(aReference != iCurrentSystemTzRules, _L("deleting iCurrentSystemTzZone in CAgnServerTlsTzRules"));

	delete aReference;

	}

CTzRules* CAgnServerTlsTzRules::GetCurrentSystemTzRulesL(RTz& aTzServer)

	{

	if(!iCurrentSystemTzRules)

		{

		iCurrentSystemTzRules = GetSystemTzFromTzServerL(aTzServer);

		}

	return iCurrentSystemTzRules->CloneL(); 

	}

void CAgnServerTlsTzRules::SystemTzZoneChangedL(RTz& aTzServer, NTzUpdate::TPropertyKeys /*aTzChangePropertyKey*/)

	{

	CTzRules* oldTzRules = iCurrentSystemTzRules; 

	iCurrentSystemTzRules = GetSystemTzFromTzServerL(aTzServer);

	delete oldTzRules;

	}

CAgnClientTlsTzRules::~CAgnClientTlsTzRules()

	{

	iTzRules.ResetAndDestroy();

	iTzRulesReferences.Reset();

	iTzIds.Reset();

	}

CTzRules* CAgnClientTlsTzRules::GetSharedTzRulesL(const CTzRules& aTzRules)

	{

	CTzRules* foundTzRules = NULL;

	const TInt KRuleCount(iTzRules.Count());

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

		{

		if (iTzRules[i]->IsEqualTo(aTzRules))

			{

			foundTzRules = iTzRules[i];

			iTzRulesReferences[i] = iTzRulesReferences[i] + 1;

			break;

			}

		}

	if (foundTzRules == NULL)

		{

		foundTzRules = aTzRules.CloneL();

		CleanupStack::PushL(foundTzRules);

		User::LeaveIfError(iTzRulesReferences.Append(1));

		iTzRules.AppendL(foundTzRules);

		iTzIds.AppendL(KInvalidTzId);//KInvalidTzId represents a rule which is not obtained from the tz server

		CleanupStack::Pop(foundTzRules);

		}

	return foundTzRules;

	}

void CAgnClientTlsTzRules::ReferenceRemoved(const CTzRules* aReference)

	{

	if (aReference == NULL)

		{

		return;

		}

	const TInt KRuleCount(iTzRules.Count());

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

		{

		if (iTzRules[i] == aReference)

			{

			if (--iTzRulesReferences[i] <= 0)

				{

				delete iTzRules[i];

				iTzRules.Remove(i);

				iTzRulesReferences.Remove(i);

				iTzIds.Remove(i);

				}

			break;

			}

		}

	}

void CAgnClientTlsTzRules::SetCurrentSystemTzRulesL(CTzRules* aTzRules, TUint aTzId)

	{

	if(iCurrentSystemTzRules)

		{

		if (iCurrentSystemTzRules->IsEqualTo(*aTzRules))

			{

			delete aTzRules;

			return; //We don't need to do anything as the system zone has been set.

			}

		else

			{

			ReferenceRemoved(iCurrentSystemTzRules);

			iCurrentSystemTzRules = NULL;

			}

		}

	CleanupStack::PushL(aTzRules);

	User::LeaveIfError(iTzRulesReferences.Append(1));

	iTzRules.AppendL(aTzRules);

	iTzIds.AppendL(aTzId);

	CleanupStack::Pop(aTzRules);

	iCurrentSystemTzRules = aTzRules;

	}

void CAgnClientTlsTzRules::UpdateCurrentSystemTzRulesL(RTz& aTzServer)

	{

	CTzId* tzid = aTzServer.GetTimeZoneIdL();

	CleanupStack::PushL(tzid);

	CTzRules* rules = GetSystemTzFromTzServerL(aTzServer);

	SetCurrentSystemTzRulesL(rules, tzid->TimeZoneNumericID());

	CleanupStack::PopAndDestroy(tzid);

	}

CTzRules* CAgnClientTlsTzRules::GetCurrentSystemTzRulesL(RTz& aTzServer)

	{

	if(iCurrentSystemTzRules == NULL)

		{

		UpdateCurrentSystemTzRulesL(aTzServer);

		}

	AddReference(iCurrentSystemTzRules);

	return iCurrentSystemTzRules;  

	}

void CAgnClientTlsTzRules::UpdateCacheL(RTz& aTzServer)

	{

	const TInt count = iTzIds.Count();

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

		{

		if(iTzIds[ii]>0)

			{

			CTzId* id = CTzId::NewL(iTzIds[ii]);

			CTzRules* rules = NULL;

			TRAPD(err, rules = aTzServer.GetTimeZoneRulesL(*id, KMinYear, KMaxYear, ETzUtcTimeReference));

			delete id;

			CleanupStack::PushL(rules);

			if(err != KErrNone && err != KErrNotFound)

				{

				User::Leave(err);

				}

			if(rules && !iTzRules[ii]->IsEqualTo(*rules))

				{//If a tz rule chached is different from the one in tz server for the same TZ ID, it needs to be updated with the new one.

				iTzRules[ii]->CopyL(*rules);

				}

			CleanupStack::PopAndDestroy(rules);

			}

		}

	}

void CAgnClientTlsTzRules::SystemTzZoneChangedL(RTz& aTzServer, NTzUpdate::TPropertyKeys aTzChangePropertyKey)

	{

	UpdateCurrentSystemTzRulesL(aTzServer);

	if(aTzChangePropertyKey == NTzUpdate::ETzRulesChange)

		{

		UpdateCacheL(aTzServer);

		}

	}

void CAgnClientTlsTzRules::AddReference(const CTzRules* aTzRules)

	{

	const TInt KRuleCount(iTzRules.Count());

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

		{

		if (iTzRules[i] == aTzRules)

			{

			iTzRulesReferences[i] = iTzRulesReferences[i] + 1;

			break;

			}

		}

	}

/***************************** Implementation of class CAgnTzChangeObserver ***************/

CAgnTzChangeObserver::CAgnTzChangeObserver(CAgnTlsProxy& aTlsProxy, NTzUpdate::TPropertyKeys aTzChangePropertyKey)

	:CActive(CActive::EPriorityStandard), iAgnTlsProxy(aTlsProxy), iTzChangePropertyKey(aTzChangePropertyKey)

	{

	CActiveScheduler::Add(this);

	}

void CAgnTzChangeObserver::ConstructL()

	{

	User::LeaveIfError(iTzChangeProperty.Attach(NTzUpdate::KPropertyCategory, iTzChangePropertyKey));

	iTzChangeProperty.Subscribe(iStatus);

	SetActive();

	}

CAgnTzChangeObserver* CAgnTzChangeObserver::NewL(CAgnTlsProxy& aTlsProxy, NTzUpdate::TPropertyKeys aTzChangePropertyKey)

	{

	CAgnTzChangeObserver* self = new (ELeave) CAgnTzChangeObserver(aTlsProxy, aTzChangePropertyKey);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CAgnTzChangeObserver::~CAgnTzChangeObserver()

	{

	Cancel();

	iTzChangeProperty.Close();

	}

void CAgnTzChangeObserver::RunL()

	{

	if (iStatus.Int() == KErrNone)

		{

		iAgnTlsProxy.HandleTzPropertyChangeL(iTzChangePropertyKey);

		iTzChangeProperty.Subscribe(iStatus);

		SetActive();

		}

	}

void CAgnTzChangeObserver::DoCancel()

	{

	iTzChangeProperty.Cancel();

	}