/*

* 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 <QtAlgorithms>

#include <tzlocalizationdatatypes.h>

#include <tzlocalizer.h>

#include <tz.h>

#include <vtzrules.h>

#include <xqsettingsmanager.h>

#include <xqsettingskey.h>

// User includes

#include "timezoneclient.h"

#include "clockcommon.h"

#include "clockserverclt.h"

#include "clockprivatecrkeys.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.

 */

TimezoneClient* TimezoneClient::mTimezoneClient = 0;

bool TimezoneClient::mReferenceCount = false;

/*!

	Call this funtion to instantiate the TimezoneClient class.

 */

TimezoneClient* TimezoneClient::getInstance()

{

	if (!mTimezoneClient) {

		mTimezoneClient = new TimezoneClient();

		mReferenceCount = true;

	}

	return mTimezoneClient;

}

/*!

	Call this function to clean up the instance of TimezoneClient class.

 */

void TimezoneClient::deleteInstance()

{

	if (mReferenceCount) {

		delete mTimezoneClient;

		mTimezoneClient = 0;

		mReferenceCount = false;

	}

}

/*!

	Call this function to check if the object is NULL.

 */

bool TimezoneClient::isNull()

{

	return !mReferenceCount;

}

/*!

	The constructor.

 */

TimezoneClient::TimezoneClient()

	mTzLocalizer = CTzLocalizer::NewL();

	// Create the settings manager.

	mSettingsManager = new XQSettingsManager(this);

	// Create the key for auto time update.

	mAutoTimeUpdateKey = new XQSettingsKey(

			XQSettingsKey::TargetCentralRepository,

			KCRUidNitz,

			KActiveProtocol);

	// Start the monitoring for the auto time update key.

	mSettingsManager->startMonitoring(*mAutoTimeUpdateKey);

	// Get the value of auto time update from cenrep.

	mAutoTimeUpdateValue = timeUpdateOn();

	// Listen to the key value changes.

	connect(

			mSettingsManager, SIGNAL(valueChanged(XQSettingsKey, QVariant)),

			this, SLOT(eventMonitor(XQSettingsKey, QVariant)));

}

/*!

	Destructor.

 */

TimezoneClient::~TimezoneClient()

{

	if (mNotifier) {

		delete mNotifier;

	}

	if (mWorldClockModel) {

		mWorldClockModel->clear();

	}

	if (mTzLocalizer) {

		delete mTzLocalizer;

		mTzLocalizer = NULL;

	}

	if (mTimeZoneIds.count()) {

		mTimeZoneIds.clear();

	}

	// Clear the locations if exist.

	if (mAllLocations.count()) {

		mAllLocations.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()

{

	if (mAllLocations.count()) {

		mAllLocations.clear();

	}

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

	CTzLocalizedCityArray* cityArray =

			mTzLocalizer->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 = mTzLocalizer->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());

		mAllLocations.append(cityInfo);

	}

	// Cleanup.

	CleanupStack::PopAndDestroy(cityArray);

	return mAllLocations;

}

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()

{

	// 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();

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

	CTzLocalizedTimeZone* localizedTimeZone(NULL);

	localizedTimeZone =

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

	if (localizedTimeZone) {

		CleanupStack::PushL(localizedTimeZone);

		// Get the frequently used localized city.

		CTzLocalizedCity* localizedCity(0);

		localizedCity = mTzLocalizer->GetFrequentlyUsedZoneCityL(

				CTzLocalizedTimeZone::ECurrentZone);

		CleanupStack::PushL(localizedCity);

		// Get all the city groups.

		CTzLocalizedCityGroupArray* cityGroupArray =

				mTzLocalizer->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 = mTzLocalizer->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( tzId );

	CleanupStack::PopAndDestroy( &tzHandle );

	return currentLocation;

}

void TimezoneClient::setAsCurrentLocationL(LocationInfo &location)

{

	LocationInfo prevLocationInfo ;

	prevLocationInfo = getCurrentZoneInfoL();

	mTzLocalizer->SetTimeZoneL( location.timezoneId );

	TPtrC ptrCityName(

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

	CTzLocalizedCity* localizedCity =

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

	CleanupStack::PushL( localizedCity );

	mTzLocalizer->SetFrequentlyUsedZoneL(

			*localizedCity, CTzLocalizedTimeZone::ECurrentZone);

	// Cleanup.

	CleanupStack::PopAndDestroy( localizedCity );

	if(prevLocationInfo.timezoneId == location.timezoneId) {

		emit cityUpdated();	

	}

}

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];

	if (isDSTOnL(timezoneId)) {

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

		CleanupStack::PushL( tzId );

		// Get the offset with DST enabled.

		getUtcDstOffsetL(stdOffset, *tzId);

		CleanupStack::PopAndDestroy(tzId);

    }

	offsetArray.Close();

	idArray.Close();

	// Cleanup.

	CleanupStack::PopAndDestroy(&tzHandle);