// 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 "TzLocalizer.h"

#include <tzconverter.h>					// For CTzConverter.

#include <centralrepository.h>				// For CRepository.

#include "TzLocalizationSortFunctions.h"

#include "TzLocalizationDbAccessor.h"

#include "TzLocalizationResourceReader.h"

#include "tzlocalizationuserdatareader.h"

#include <tzlocalizedtimezonerecord.h>

#include <tzlocalizedcityrecord.h>

/**

Allocates and constructs a new CTzLocalizer object.

@return The newly created CTzLocalizer object.

*/

EXPORT_C CTzLocalizer* CTzLocalizer::NewL()

	{

	CTzLocalizer* self = CTzLocalizer::NewLC();

	CleanupStack::Pop(self);

	return self;

	}

/**

Allocates and constructs a new CTzLocalizer object.

The pointer to the new object is left on the cleanup stack.

@return The newly created CTzLocalizer object.

*/

EXPORT_C CTzLocalizer* CTzLocalizer::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

EXPORT_C CTzLocalizer::~CTzLocalizer()

	{

	delete iStaticDataReader;

	delete iUserDataReader;

	iTzSession.Close();

	}

CTzLocalizer::CTzLocalizer()

	: iLanguage(User::Language())

	{

	iDataSource = ETzDataSourceSystem;

	}

void CTzLocalizer::ConstructL()

	{

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

	iStaticDataReader = CTzLocalizationResourceReader::NewL();

   	iUserDataReader	= CTzLocalizationUserDataReader::NewL(iTzSession);

	if (DbNeedsUpdatingL())

		{

        TRAP_IGNORE(UpgradeDbVersionL());

		}

	SetDataSource(ETzDataSourceSystem | ETzDataSourceUser);

	if(!PrepareFrequentlyUsedZonesL())

		{

		// The cached zones DB was not updated using the defaults, so update it

		// using the time zone IDs that are already in the DB.  This ensures

		// that the language of the strings in the cached zone DB is correct on

		// construction.

		UpdateFrequentlyUsedZonesL();

		}

	SetDataSource(ETzDataSourceSystem);

	}

// Check if the DB needs upgrading

TBool CTzLocalizer::DbNeedsUpdatingL() const

    {

    CTzLocalizationDbAccessor* dbAccessor = CTzLocalizationDbAccessor::NewLC();

    TBool dbNeedsUpdating = dbAccessor->DbNeedsUpdatingL();

    CleanupStack::PopAndDestroy(dbAccessor);

    return dbNeedsUpdating;

    }

/**

Allows the client to specify the data source which should be used for

CTzLocalizer methods which can return a combination of system time zone

localization information and user-defined time zone names.

The following CTzLocalizer methods are affected by the use of this method:

- GetAllTimeZonesL()

- GetCitiesL()

- GetCitiesInGroupL()

- GetAllCityGroupsL()

@param aDataSource The data source to use.  The permissible values for this

argument are defined by the TTzLocalizerDataSource type.

@released

*/

EXPORT_C  void CTzLocalizer::SetDataSource(TUint aDataSource)

	{

	iDataSource = aDataSource;

	}

void CTzLocalizer::UpgradeDbVersionL()

    {

    // Fetch the cached zones from the old database

    CTzLocalizedTimeZoneArray* timeZones = CTzLocalizedTimeZoneArray::NewLC();

    CTzLocalizedCityArray* cities = CTzLocalizedCityArray::NewLC();

    FetchCityToUpgradeL(*timeZones, *cities, CTzLocalizedTimeZone::ECurrentZone);

    FetchCityToUpgradeL(*timeZones, *cities, CTzLocalizedTimeZone::EHomeZone);

    FetchCityToUpgradeL(*timeZones, *cities, CTzLocalizedTimeZone::EInterestZone);

    // delete the database and re-create it in the latest format

    RecreateDbL();

    // rewrite the cached zones

    for (TInt i = CTzLocalizedTimeZone::ECurrentZone; i <= CTzLocalizedTimeZone::EInterestZone; ++i)

        {

        SetFrequentlyUsedZoneL(timeZones->At(i), cities->At(i), CTzLocalizedTimeZone::TTzFrequentlyUsedZone(i));

        }

    CleanupStack::PopAndDestroy(cities);

    CleanupStack::PopAndDestroy(timeZones);

    }

// This function fetches a cached city and time zone as part of the DB upgrade

void CTzLocalizer::FetchCityToUpgradeL(CTzLocalizedTimeZoneArray& aTimeZoneArray, CTzLocalizedCityArray& aCityArray, CTzLocalizedTimeZone::TTzFrequentlyUsedZone aCachedZone)

    {

    CTzLocalizedTimeZone* zone = GetFrequentlyUsedZoneL(aCachedZone);

    CleanupStack::PushL(zone);

    aTimeZoneArray.AppendL(zone);

    CleanupStack::Pop(zone);

    CTzLocalizedCity* city = GetFrequentlyUsedZoneCityL(aCachedZone);

    CleanupStack::PushL(city);

    aCityArray.AppendL(city);

    CleanupStack::Pop(city);

    //  Find the city from resource file with matched name defined in given "city" and set its city index to "city"

    TBool hasFound = FindCityAndSetCityIndexL(*city, ETzDataSourceSystem);

    //  If not found and user defined data source is considered, find the city from user defined database with matched name defined in given "city" and set its city index to "city"

    if (!hasFound && iDataSource&ETzDataSourceUser)

	   {

	   FindCityAndSetCityIndexL(*city, ETzDataSourceUser);

	   }

   }

// Close and delete old DB, and create a new one (in latest version)

void CTzLocalizer::RecreateDbL()

    {

    CTzLocalizationDbAccessor* dbAccessor = CTzLocalizationDbAccessor::NewLC();

    dbAccessor->RecreateDbL(iTzSession);

    CleanupStack::PopAndDestroy(dbAccessor);

    }

/**

Populates the cached zones data in the persisted data writer with the default

values from the time zone server (for the current zone) or the static data

reader for the other zones.

@return ETrue if the cached Zone DB table had to be prepared using the defaults,

		EFalse if not.

*/

TBool CTzLocalizer::PrepareFrequentlyUsedZonesL()

	{

	CTzLocalizedTimeZoneArray* frequentlyUsedZones = CTzLocalizedTimeZoneArray::NewLC();

	CTzLocalizedCityArray* cachedCities = CTzLocalizedCityArray::NewLC();

	TBool frequentlyUsedZonesNeedUpdating = EFalse;

	// Loop to fill up the frequentlyUsedZones and cachedCities arrays to send to

	// WriteAllZonesL().  It also keeps track of whether the update is actually necessary

	for(TInt i = CTzLocalizedTimeZone::ECurrentZone; i < CTzLocalizedTimeZone::ECachedTimeZones; ++i)

		{

		CTzLocalizedTimeZone::TTzFrequentlyUsedZone freqUsedZone = (CTzLocalizedTimeZone::TTzFrequentlyUsedZone)i;

		CTzLocalizedTimeZoneRecord* timeZoneRecord = iTzSession.LocalizationReadFrequentlyUsedZoneL(freqUsedZone);

		CleanupStack::PushL(timeZoneRecord);

		CTzLocalizedTimeZone* timeZone = CreateTimeZoneL(*timeZoneRecord);

		CleanupStack::PopAndDestroy(timeZoneRecord);

		CleanupStack::PushL(timeZone);

		CTzLocalizedCityRecord* cityRecord = iTzSession.LocalizationReadCachedTimeZoneCityL(freqUsedZone);

		CleanupStack::PushL(cityRecord);

		CTzLocalizedCity* city = CreateCityL(*cityRecord);

		CleanupStack::PopAndDestroy(cityRecord);

		CleanupStack::PushL(city);

		// Check if the persisted cached zone is not set yet.

		if (timeZone->TimeZoneId() == 0 || city->TimeZoneId() == 0)

			{

			CleanupStack::PopAndDestroy(city);

			city = NULL;

			CleanupStack::PopAndDestroy(timeZone);

			timeZone = NULL;

			if(freqUsedZone == CTzLocalizedTimeZone::ECurrentZone)

				{

				TInt id = GetTimeZoneIdFromTzServerL();

				timeZone = GetLocalizedTimeZoneL(id, EFalse);

				}

			else

				{

				timeZone = GetFrequentlyUsedDefaultZoneL(freqUsedZone);

				}

			CleanupStack::PushL(timeZone);

			city = ReadDefaultCityL(timeZone->TimeZoneId(), EFalse);

			CleanupStack::PushL(city);

			frequentlyUsedZonesNeedUpdating = ETrue;

			}

		cachedCities->AppendL(city);

		// ownership is transferred into the array

		CleanupStack::Pop(city);

		frequentlyUsedZones->AppendL(timeZone);

		// ownership is transferred into the array

		CleanupStack::Pop(timeZone);

		}

	if (frequentlyUsedZonesNeedUpdating)

		{

		WriteAllFrequentlyUsedZonesL(*frequentlyUsedZones, *cachedCities);

		}

	CleanupStack::PopAndDestroy(cachedCities);

	CleanupStack::PopAndDestroy(frequentlyUsedZones);

	return frequentlyUsedZonesNeedUpdating;

	}

/**

Updates the cached zone information in the persisted data writer with the

strings that are currently in static data.

*/

void CTzLocalizer::UpdateFrequentlyUsedZonesL()

	{

	CTzLocalizedTimeZoneArray* frequentlyUsedZones = CTzLocalizedTimeZoneArray::NewLC();

	CTzLocalizedCityArray* cachedCities = CTzLocalizedCityArray::NewLC();

	for(TInt i = CTzLocalizedTimeZone::ECurrentZone; i < CTzLocalizedTimeZone::ECachedTimeZones; ++i)

		{

		CTzLocalizedTimeZone::TTzFrequentlyUsedZone freqUsedZone = (CTzLocalizedTimeZone::TTzFrequentlyUsedZone)i;

		// Find out what the time zone Id of the cached zone is

		CTzLocalizedTimeZoneRecord* timeZoneRecord = iTzSession.LocalizationReadFrequentlyUsedZoneL(freqUsedZone);

		TInt timeZoneId = timeZoneRecord->Id();

		delete timeZoneRecord;

		// Update the time zone

		CTzLocalizedTimeZone* timeZone = GetLocalizedTimeZoneL(timeZoneId, EFalse);

		CleanupStack::PushL(timeZone);

		// Does the cached city still exist in this time zone?

		// Get all the cities in this cached zone

		CTzLocalizedCityArray* citiesInTimeZone = GetCitiesL(*timeZone);

		CleanupStack::PushL(citiesInTimeZone);

		TIdentityRelation<CTzLocalizedCity> identity(NTzLocalSortAndFind::FindCityByName);

		// search for the city that was used to set this cached zone

		// in the previous language (it might be a user defined city or

		// it might have the same name in the new language)

		CTzLocalizedCityRecord* cityRecord = iTzSession.LocalizationReadCachedTimeZoneCityL(freqUsedZone);

		CleanupStack::PushL(cityRecord);

		CTzLocalizedCity* city = CreateCityL(*cityRecord);

		CleanupStack::PopAndDestroy(cityRecord);

		CleanupStack::PushL(city);

		TInt index = citiesInTimeZone->Find(city,identity);

        if (index == KErrNotFound)

            {

            // if city with this name can't be found, use the city with the same index in this time zone group

            if (city->CityIndex() >= 0 && city->CityIndex() < citiesInTimeZone->Count())

                {

                index = city->CityIndex();

                }

            }

		CleanupStack::PopAndDestroy(city);

		city = NULL;

		if(index != KErrNotFound)

		// city still exists in the new language

			{

			// Point city to array member.

			// This ensures all city info is valid

			city = &(citiesInTimeZone->At(index));

			// we're taking ownership of this element, so remove it

			// from the array

			citiesInTimeZone->Remove(index);

			}

		else

		// city not found - use the default city for the zone instead

			{

			city = ReadDefaultCityL(timeZone->TimeZoneId(), EFalse);

			}

		CleanupStack::PopAndDestroy(citiesInTimeZone);

		CleanupStack::PushL(city);

		cachedCities->AppendL(city);

		CleanupStack::Pop(city);

		frequentlyUsedZones->AppendL(timeZone);

		CleanupStack::Pop(timeZone);

		}

	WriteAllFrequentlyUsedZonesL(*frequentlyUsedZones,*cachedCities);

	CleanupStack::PopAndDestroy(cachedCities);

	CleanupStack::PopAndDestroy(frequentlyUsedZones);

	}

/**

Get the localized default time zone for the given frequently used time zone.

The default time zone for each of the possible frequently used time zones may be

specified in the TZ Server repository or in the TZ Localization resource file.

Check the possible sources in this order.

@param aFreqUsedZone The frequently used time zone for which the localized

default time zone is required.

@return The localized default time zone for the given frequently used time zone.

*/

CTzLocalizedTimeZone* CTzLocalizer::GetFrequentlyUsedDefaultZoneL(CTzLocalizedTimeZone::TTzFrequentlyUsedZone aFreqUsedZone)

	{

	// Assume that we will not find the key in the repository or that we do find

	// the key but it has no value.  If either of these scenarios is true then

	// we will use the time zone identifier recorded in the resource file for

	// the default time zone.

	TBool readFreqUsedZoneFromRscFile = ETrue;

	TUint32 defaultTimeZoneKey = GetFrequentlyUsedDefaultZoneCenRepKeyL(aFreqUsedZone);

	TInt defaultTimeZoneId = 0;

	CRepository* tzRepository = CRepository::NewL(NTzUpdate::KPropertyCategory);

	CleanupStack::PushL(tzRepository);

	TInt err = tzRepository->Get(defaultTimeZoneKey, defaultTimeZoneId);

	CleanupStack::PopAndDestroy(tzRepository);

	CTzLocalizedTimeZone* defaultTimeZone = 0;

	// The key may not exist in the repository so this is not an error

	// condition.

	if(err != KErrNotFound)

		{

		User::LeaveIfError(err);

		// The key exists - check that it has a value.

		if(defaultTimeZoneId != 0)

			{

			readFreqUsedZoneFromRscFile = EFalse;

			defaultTimeZone = iStaticDataReader->ReadTimeZoneL(defaultTimeZoneId);

			}

		}

	if(readFreqUsedZoneFromRscFile)

		{

		defaultTimeZone = iStaticDataReader->ReadFrequentlyUsedZoneL(aFreqUsedZone);

		}

	return defaultTimeZone;

	}

/**

Get the TZ Server's CenRep repository key for the given frequently used zone.

@param aFreqUsedZone The frequently used time zone for which the TZ Server's

CenRep repository key is required.

@return The TZ Server's CenRep repository key for the given frequently used

zone.

*/

TUint32 CTzLocalizer::GetFrequentlyUsedDefaultZoneCenRepKeyL(CTzLocalizedTimeZone::TTzFrequentlyUsedZone aFreqUsedZone)

	{

	// These key values are copied from those defined in tzconfigagent.h.  We

	// want to keep the key values private - this is one way to do it.

	const TUint32 KDefaultHomeTimeZoneKey = 0x3UL;

	const TUint32 KDefaultInterestTimeZoneKey = 0x4UL;

	const TUint32 KDefaultRecent1TimeZoneKey = 0x5UL;

	const TUint32 KDefaultRecent2TimeZoneKey = 0x6UL;

	TUint32 key = 0;

	switch(aFreqUsedZone)

	    {

	    case CTzLocalizedTimeZone::EHomeZone:

	    	{

	    	key = KDefaultHomeTimeZoneKey;

	        }

	    break;

	    case CTzLocalizedTimeZone::EInterestZone:

	    	{

	    	key = KDefaultInterestTimeZoneKey;

	        }

	    break;

	    case CTzLocalizedTimeZone::ERecentZone1:

	    	{

	    	key = KDefaultRecent1TimeZoneKey;

	        }

	    break;

	    case CTzLocalizedTimeZone::ERecentZone2:

	    	{

	    	key = KDefaultRecent2TimeZoneKey;

	        }

	    break;

	    default:

	    	{

	    	User::Leave(KErrArgument);

	    	}

	    }

	return key;

    }

/**

Gets the localized time zone that matches the time zone ID specified.

The calling function takes ownership of the returned localized time zone.

@param aTimeZoneId A positive time zone ID of the localized time zone to return.

@return The localized time zone.

*/

EXPORT_C CTzLocalizedTimeZone* CTzLocalizer::GetLocalizedTimeZoneL(TInt aTimeZoneId) const

	{

	return GetLocalizedTimeZoneL(aTimeZoneId, ETrue);

	}

/**

Gets the localized time zone that aCity is a member of.

The calling function takes ownership of the returned localized time zone.

@param aCity Any city in the time zone to return.

@return The localized time zone.

*/

EXPORT_C CTzLocalizedTimeZone* CTzLocalizer::GetLocalizedTimeZoneL(const CTzLocalizedCity& aCity) const

	{

	if(IsOperateOnUserDbL(aCity.TzLocalizedId().TimeZoneId(), ETrue))

		{

		return iUserDataReader->ReadTimeZoneL(aCity.TzLocalizedId());

		}

	else

		{

		return iStaticDataReader->ReadTimeZoneL(aCity.TzLocalizedId());

		}

	}

/**

Gets an array of all available localizable time zones, sorted according to aSortOrder.

The calling function takes ownership of the returned array.

@param aSortOrder Specifies the sort order of the returned array.

@return Array of all available localizable time zones.

*/

EXPORT_C CTzLocalizedTimeZoneArray* CTzLocalizer::GetAllTimeZonesL(const TTzSortOrder aSortOrder)

	{

	CTzLocalizedTimeZoneArray* allTimeZones = CTzLocalizedTimeZoneArray::NewLC();

	if(iDataSource&ETzDataSourceSystem)

		{

		iStaticDataReader->ReadAllTimeZonesL(*allTimeZones);

		}

	//User time zones will be appended

	if (iDataSource&ETzDataSourceUser)

		{

		iUserDataReader->ReadAllTimeZonesL(*allTimeZones);

		}

	if ((aSortOrder == ETzUTCAscending) || (aSortOrder == ETzUTCDescending))

		{

		PrepareForUTCSortL(*allTimeZones);

		}

	if (aSortOrder != ETzUnsorted)

		{

		TLinearOrder<CTzLocalizedTimeZone> sortOrder(TimeZoneSortOrderL(aSortOrder));

		allTimeZones->Sort(sortOrder);

		}

	CleanupStack::Pop(allTimeZones);

	return allTimeZones;

	}

/**

Sets the time zone in the time zone server to be that of the

supplied time zone id.  The current cached zone is also updated.

@param aTimeZoneId A positive time zone ID of the new time zone.

*/

EXPORT_C void CTzLocalizer::SetTimeZoneL(TInt aTimeZoneId)

	{

	SetFrequentlyUsedZoneL(aTimeZoneId, CTzLocalizedTimeZone::ECurrentZone);

	}

/**

Gets the default city for the specified time zone.

The calling function takes ownership of the returned city.

@param aTimeZoneId A positive time zone ID of the default city to return.

@return The default city for the specified time zone.

*/

EXPORT_C CTzLocalizedCity* CTzLocalizer::GetDefaultCityL(TInt aTimeZoneId) const

	{

	return ReadDefaultCityL(aTimeZoneId, ETrue);

	}

/**

Gets the default city for the time zone the specified city is a member of.

The calling function takes ownership of the returned city.

@param aCity Any city in the required time zone.

@return The default city.

*/

EXPORT_C CTzLocalizedCity* CTzLocalizer::GetDefaultCityL(const CTzLocalizedCity& aCity) const

	{

	return ReadDefaultCityL(aCity.TzLocalizedId().TimeZoneId(), ETrue);

	}

/**

Gets the default city for the specified time zone.