/*

* Copyright (c) 2009-2010 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:

* Definition file for the TimeZoneClient class.

*

*/

// System includes

#include <QList>

#include <QStandardItemModel>

#include <QDebug>

#include <QtAlgorithms>

#include <tzlocalizationdatatypes.h>

#include <tzlocalizer.h>

#include <tz.h>

#include <vtzrules.h>

// User includes

#include "timezoneclient.h"

#include "clockcommon.h"

#include "debug.h"

#include "clockserverclt.h"

const int KDaysInWeek(7);

const int KZerothRule(0);

const int KOneHour(1);

const int KNoDifference(0);

/*!

	\class TimezoneClient

	This class is the QObject based client interface for services offered by

	tzserver and timezonelocalization.

 */

/*!

	Default constructor.

	\param parent The parent.

 */

TimezoneClient::TimezoneClient(QObject* parent)

:QObject(parent),

 mTimeUpdateOn(false),

 mFetchCount(0)

{

	qDebug("clock: TimezoneClient::TimezoneClient() -->");

	TCallBack callback(environmentCallback, this);

	mNotifier = CEnvironmentChangeNotifier::NewL(

			CActive::EPriorityStandard, callback);

	mNotifier->Start();

	RClkSrvInterface clkSrvInterface1;

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

	TBool aUpdate;

	clkSrvInterface1.IsAutoTimeUpdateOn(aUpdate);

	if(aUpdate){

	mTimeUpdateOn = true;

	}

	else {

	mTimeUpdateOn = false;

	}

	clkSrvInterface1.Close();

	mTzLocalizer = CTzLocalizer::NewL();

	qDebug("clock: TimezoneClient::TimezoneClient() <--");

}

/*!

	Destructor.

 */

TimezoneClient::~TimezoneClient()

{

	if (mNotifier) {

		mNotifier->Cancel();

		delete mNotifier;

		mNotifier = 0;

	}

	if (mWorldClockModel) {

		mWorldClockModel->clear();

	}

	if (mTzLocalizer) {

		delete mTzLocalizer;

		mTzLocalizer = NULL;

	}

	if (mTimeZoneIds.count()) {

		mTimeZoneIds.clear();

	}

}

/*!

	This functions returns a QList of location info which represent all the

	cities preset in the device returned by the tz server.

	\return QList<LocationInfo> A list of location info objects which contain a

			valid cityName, countryName, tz id and city group id. None of the other

			data is filled.

 */

QList<LocationInfo> TimezoneClient::getLocations()

{

	qDebug("clock: TimezoneClient::getLocations() -->");

	// This list will contain the info of the cities fetched from tz server.

	QList<LocationInfo> infoList;

	// Construct the timezone localizer.

	CTzLocalizer* localizer = CTzLocalizer::NewL();

	CleanupStack::PushL(localizer);

	// Get the cities, in alphabetical-ascending sorted order.

	CTzLocalizedCityArray* cityArray =

			localizer->GetCitiesL(CTzLocalizer::ETzAlphaNameAscending);

	ASSERT(cityArray);

	CleanupStack::PushL(cityArray);

	int cityCount = cityArray->Count();

	CTzLocalizedCityGroup* country = 0;

	int prevGroupId = -1;

	TPtrC countryName;

	// Now get the country\city-group of each of the city.

	// Print the timezone id and city group id as well.

	for (int iter = 0; iter < cityCount; iter++) {

		CTzLocalizedCity* localizedCity = &(cityArray->At(iter));

		TPtrC cityName(localizedCity->Name());

		int tzId(localizedCity->TimeZoneId());

		if(-1==mTimeZoneIds.indexOf(tzId)) {

			mTimeZoneIds.append(tzId);

		}

		int cityGroupId(localizedCity->GroupId());

		if (cityGroupId != prevGroupId) {

			prevGroupId = cityGroupId;

			if (country) {

				delete country;

			}

			country = localizer->GetCityGroupL(cityGroupId);

			countryName.Set(country->Name());

		}

		// Now insert that data into the info list.

		LocationInfo cityInfo;

		cityInfo.cityGroupId = cityGroupId;

		cityInfo.timezoneId = tzId;

		cityInfo.cityName = QString::fromUtf16(

				cityName.Ptr(), cityName.Length());

		cityInfo.countryName = QString::fromUtf16(

				countryName.Ptr(), countryName.Length());

		infoList.append(cityInfo);

	}

	// Cleanup.

	CleanupStack::PopAndDestroy(cityArray);

	CleanupStack::PopAndDestroy(localizer);

	qDebug("clock: TimezoneClient::getLocations() <--");

	return infoList;

}

bool TimezoneClient::getUtcDstOffsetL(int& dstOffset, const CTzId& timezoneId)

{

	RTz tzHandle;

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

	CleanupClosePushL(tzHandle);

	// Local time.

	TTime homeTime;

	homeTime.HomeTime();

	TDateTime dateTime;

	dateTime = homeTime.DateTime();

	// Get the CTzRules for the current year and for the given time zone id.

	CTzRules* timezoneRules = tzHandle.GetTimeZoneRulesL(

			timezoneId, dateTime.Year(), dateTime.Year(), ETzWallTimeReference);

	CleanupStack::PushL(timezoneRules);

	// Get the Actualised rules for the same year.

	// These are the DST rules from which we get the iNewOffset.

	CVTzActualisedRules *actualizedRules =

			CVTzActualisedRules::NewL(

					homeTime.DateTime().Year(), homeTime.DateTime().Year());

	CleanupStack::PushL(actualizedRules);

	timezoneRules->GetActualisedRulesL(*actualizedRules);

	// This way of fetching initial offset is being used rather than

	// tzRules->InitialStdTimeOffset() because in some cases,

	// the offset returned is incorrect. (For ex: Argentina and Canada/Iqaluit)

	RArray<TInt> timeZones;

	RArray<TInt> zoneOffsets;

	// Append the current timezone ID and request for the standard offset

	timeZones.Append(timezoneId.TimeZoneNumericID());

	tzHandle.GetOffsetsForTimeZoneIdsL(timeZones, zoneOffsets);

	// The initial offset or the standard offset (w/o DST)

	int initialTimeZoneOffset = zoneOffsets[ 0 ];

	// Close the resource handles

	timeZones.Close();

	zoneOffsets.Close();

	// The number of actualised rules

	int ruleCount = actualizedRules->Count();

	for (int ruleIndex(0); ruleIndex < ruleCount; ruleIndex++) {

		const TVTzActualisedRule& tVTzactRule = (*actualizedRules)[ruleIndex];

		// If the standard offset and the new offset do not match then we have

		// a dst offset. Technically if a timezone has DST then it can have a

		// max of two offsets. One is the standard which doesn't show the DST

		// usage, and the other is the DST offset which is

		// standard offset + the amount of DST.

		if (initialTimeZoneOffset != tVTzactRule.iNewOffset) {

			dstOffset = tVTzactRule.iNewOffset;

			CleanupStack::PopAndDestroy(actualizedRules);

			CleanupStack::PopAndDestroy(timezoneRules);

			CleanupStack::PopAndDestroy(&tzHandle);

			return true;

		} else {

			dstOffset = initialTimeZoneOffset;

		}

	}

	CleanupStack::PopAndDestroy(actualizedRules);

	CleanupStack::PopAndDestroy(timezoneRules);

	CleanupStack::PopAndDestroy(&tzHandle);

	return false;

}

LocationInfo TimezoneClient::getCurrentZoneInfoL()

{

	qDebug() << "clock: TimezoneClient::getCurrentZoneInfoL -->";

	// Current zone info.

	LocationInfo currentLocation;

	int timezoneId(0);

	int utcOffset(0);

	// Connect to the timezone server.

	RTz tzHandle;

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

	CleanupClosePushL(tzHandle);

	// Get the current timezone ID.

	CTzId* tzId;

	tzId = tzHandle.GetTimeZoneIdL();

	CleanupStack::PushL(tzId);

	// TODO: Get the standard offset for current timezone.

	// This way of fetching initial offset is being used rather than

	// tzRules->InitialStdTimeOffset()because in some cases, the offset returned

	// is incorrect. (For ex: Argentina and Canada/Iqaluit)

	RArray<TInt> timeZones;

	RArray<TInt> zoneOffsets;

	// Append the current timezone ID and request for the standard offset

	timeZones.Append(tzId->TimeZoneNumericID());

	tzHandle.GetOffsetsForTimeZoneIdsL(timeZones, zoneOffsets);

	// The initial offset or the standard offset (w/o DST)

	int initialTimeZoneOffset = zoneOffsets[0];

	// Close the resource handles

	timeZones.Close();

	zoneOffsets.Close();

	// Construct CTzLocalizer object to get the timezone from the ID.

	CTzLocalizer* tzLocalizer = CTzLocalizer::NewL();

	// Get all the localized timezones for the current timezone ID.

	CTzLocalizedTimeZone* localizedTimeZone(NULL);

	if (tzLocalizer) {

		// Get the currently set localized timezone.

		CleanupStack::PushL(tzLocalizer);

		localizedTimeZone =

			tzLocalizer->GetLocalizedTimeZoneL(tzId->TimeZoneNumericID());

		if (localizedTimeZone) {

			CleanupStack::PushL(localizedTimeZone);

			// Get the frequently used localized city.

			CTzLocalizedCity* localizedCity(0);

			localizedCity = tzLocalizer->GetFrequentlyUsedZoneCityL(

					CTzLocalizedTimeZone::ECurrentZone);

			CleanupStack::PushL(localizedCity);

			// Get all the city groups.

			CTzLocalizedCityGroupArray* cityGroupArray =

					tzLocalizer->GetAllCityGroupsL(

							CTzLocalizer::ETzAlphaNameAscending);

			CleanupStack::PushL(cityGroupArray);

			// Get the index of the country corresponding to the city group ID.

			int countryIndex(1);

			for (int index = 0; index < cityGroupArray->Count(); index++) {

				if (localizedCity->GroupId() ==

						cityGroupArray->At(index).Id()) {

					countryIndex = index;

				}

			}

			// Get all the cities within the currently set country.

			CTzLocalizedCityArray* cityList = tzLocalizer->GetCitiesInGroupL(

					(cityGroupArray->At(countryIndex )).Id(),

					CTzLocalizer::ETzAlphaNameAscending);

			CleanupStack::PushL(cityList);

			// Check if automatic time update is enabled.

			bool timeUpdateOn( false );

			// Connect to the clock server.

			// TODO: connect to the clock server and get auto update status in

			// var:  timeUpdateOn

			// Check if the country contains only one city or if automatic

			// time update is on.

			if (1 == cityList->Count() || timeUpdateOn) {

				// If yes, then display only the country name.

				// TODO

			} else {

				// Display city name.

				// TODO:

			}

			// Get the country name.

			TPtrC countryName(cityGroupArray->At(countryIndex).Name());

			currentLocation.countryName = QString::fromUtf16(

					countryName.Ptr(), countryName.Length());

			// Get the city name.

			TPtrC cityName(localizedCity->Name());

			currentLocation.cityName = QString::fromUtf16(

					cityName.Ptr(), cityName.Length());

			// Get the UTC offset.

			timezoneId = localizedCity->TimeZoneId();

			if (timezoneId) {

				// Check if the DST is on for the current timezone.

				if (isDSTOnL(timezoneId)) {

					// Get the offset with DST enabled.

					getUtcDstOffsetL(utcOffset, *tzId);

					currentLocation.dstOn = true;

					currentLocation.timezoneId = timezoneId;

					currentLocation.zoneOffset = utcOffset;

				} else {

					// Use the standard offset.

					currentLocation.dstOn = false;

					currentLocation.timezoneId = timezoneId;

					currentLocation.zoneOffset = initialTimeZoneOffset;

				}

			}

			// Cleanup.

			CleanupStack::PopAndDestroy( cityList );

			CleanupStack::PopAndDestroy( cityGroupArray );

			CleanupStack::PopAndDestroy( localizedCity );

			CleanupStack::PopAndDestroy( localizedTimeZone );

		}

		// Cleanup.

		CleanupStack::PopAndDestroy( tzLocalizer );

	}

	// Cleanup.

	CleanupStack::PopAndDestroy( tzId );

	CleanupStack::PopAndDestroy( &tzHandle );

	qDebug() << "clock: TimezoneClient::getCurrentZoneInfoL <--";

	return currentLocation;

}

void TimezoneClient::setAsCurrentLocationL(LocationInfo &location)

{

	Debug::writeDebugMsg(

			"In time zone client setAsCurrentLocationL " + location.cityName +

			" " +

			location.countryName +

			" " +

			QString::number(location.zoneOffset));

	// Construct CTzLocalizer object.

	CTzLocalizer* tzLocalizer = CTzLocalizer::NewL();

	CleanupStack::PushL( tzLocalizer );

	tzLocalizer->SetTimeZoneL( location.timezoneId );

	TPtrC ptrCityName(

			reinterpret_cast<const TText*>(location.cityName.constData()));

	CTzLocalizedCity* localizedCity =

			tzLocalizer->FindCityByNameL(ptrCityName, location.timezoneId);

	CleanupStack::PushL( localizedCity );

	tzLocalizer->SetFrequentlyUsedZoneL(

			*localizedCity, CTzLocalizedTimeZone::ECurrentZone);

	// Cleanup.

	CleanupStack::PopAndDestroy( localizedCity );

	CleanupStack::PopAndDestroy( tzLocalizer );

}

bool TimezoneClient::isDSTOnL(int timezoneId)

{

	bool returnVal( false );

	CTzId* tzId = CTzId::NewL( timezoneId );

	CleanupStack::PushL( tzId );

	RTz tzHandle;

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

	CleanupClosePushL( tzHandle );

	returnVal = tzHandle.IsDaylightSavingOnL( *tzId );

	tzHandle.Close();

	CleanupStack::PopAndDestroy( &tzHandle );

	CleanupStack::PopAndDestroy( tzId );

	return returnVal;

}

int TimezoneClient::getStandardOffset(int timezoneId)

{

	RTz tzHandle;

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

	CleanupClosePushL(tzHandle);

	RArray<int> idArray;

	RArray<int> offsetArray;

	idArray.Append(timezoneId);

	tzHandle.GetOffsetsForTimeZoneIdsL(idArray, offsetArray);

	int stdOffset = offsetArray[0];

	offsetArray.Close();

	idArray.Close();

	// Cleanup.

	CleanupStack::PopAndDestroy(&tzHandle);

	return stdOffset;

}

void TimezoneClient::getDstRulesL(

		QDateTime &startTime, QDateTime &endTime, int timezoneId)

{

	RTz tzHandle;

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

	CleanupClosePushL(tzHandle);

	// Local time.

	TTime homeTime;

	homeTime.HomeTime();

	TDateTime dateTime;

	dateTime = homeTime.DateTime();

	CTzId *tzId = CTzId::NewL(timezoneId);

	CleanupStack::PushL(tzId);

	// Get the CTzRules for the current year and for the given time zone id.

	CTzRules* timezoneRules = tzHandle.GetTimeZoneRulesL(

			*tzId, dateTime.Year(), dateTime.Year(), ETzWallTimeReference);

	CleanupStack::PushL(timezoneRules);

	// Get the Actualised rules for the same year.

	// These are the DST rules from which we get the iNewOffset.

	CVTzActualisedRules *actualizedRules = CVTzActualisedRules::NewL(

			homeTime.DateTime().Year(), homeTime.DateTime().Year() );

	CleanupStack::PushL(actualizedRules);

	timezoneRules->GetActualisedRulesL(*actualizedRules);

	// This way of fetching initial offset is being used rather than

	// tzRules->InitialStdTimeOffset() because in some cases,

	// the offset returned is incorrect. (For ex: Argentina and Canada/Iqaluit)

	RArray<TInt> timeZones;

	RArray<TInt> zoneOffsets;

	// Append the current timezone ID and request for the standard offset

	timeZones.Append(timezoneId);

	tzHandle.GetOffsetsForTimeZoneIdsL(timeZones, zoneOffsets);

	// The initial offset or the standard offset (w/o DST)

	int initialTimeZoneOffset = zoneOffsets[ 0 ];

	// Close the resource handles

	timeZones.Close();

	zoneOffsets.Close();

	// The number of actualised rules

	int ruleCount = actualizedRules->Count();

	for(int ruleIndex(1); ruleIndex < ruleCount; ruleIndex++) {

		const TVTzActualisedRule& tVTzactRule = (*actualizedRules)[ruleIndex];

		TTime ruleTime(tVTzactRule.iTimeOfChange);

		if (initialTimeZoneOffset == tVTzactRule.iNewOffset) {

			TTime tempRuleTime(ruleTime);

			if (tVTzactRule.iTimeReference == ETzUtcTimeReference) {

				tempRuleTime += TTimeIntervalMinutes(tVTzactRule.iNewOffset);

			}

			QTime tempTime;

			QDate tempDate;

			tempTime.setHMS(tempRuleTime.DateTime().Hour(),

			                tempRuleTime.DateTime().Minute(),

			                tempRuleTime.DateTime().Second());

			tempDate.setYMD(tempRuleTime.DateTime().Year(),

			                tempRuleTime.DateTime().Month()+1,

			                tempRuleTime.DateTime().Day()+1);

			endTime.setDate(tempDate);