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

#include "timezoneserver.h"

#include "mtimezonedataaccess.h"

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

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <tzusernames.h>//new file added for CTzUserNames which is publishedPartner

#endif

#include <tzlocalizedcityrecord.h>

#include <tzlocalizedtimezonerecord.h>

// Database location and access policy

_LIT(KTzLocalizationDbName,"c:TzLocalization.db");

_LIT(KTzLocalizationDbSecurityPolicy,"secure[10206A8B]");

//Table and Column names for Cached Time Zone Table

//These text strings are never visible and do not need localizing

_LIT(KCZTableName, 			"FrequentlyUsedZones");

_LIT(KCZTableTzIdCol, 		"TzId");

_LIT(KCZTableStdCol, 		"StandardName");

_LIT(KCZTableDSTCol, 		"DSTName");

_LIT(KCZTableShortStdCol,	"ShortStandardName");

_LIT(KCZTableShortDSTCol, 	"ShortDSTName");

_LIT(KCZTableCityCol, 		"City");

_LIT(KCZTableCityGroupCol, 	"GroupId");

_LIT(KCZTableResourceIdCol,	"ResourceId");

_LIT(KCZTableCityIndexCol,	"CityIndex");

//Table and Column names for User Added Cities Table

//These text strings are never visible and do not need localizing

_LIT(KUCTableName, 			"UserCities");

_LIT(KUCTableTzId, 			"TzId");

_LIT(KUCTableCity, 			"City");

_LIT(KUCTableGroup, 		"GroupId");

_LIT(KUCTableResourceId,	"ResourceId");

enum TTzZoneColumn

	{

	// Enum will used as a DB column index, so it must start at 1

	ETzZoneId = 1,

	ETzZoneStdName,

	ETzZoneDSTName,

	ETzZoneShortStdName,

	ETzZoneShortDSTName,

	ETzZoneCity,

	ETzZoneGroupId,

	ETzZoneResourceId,

	ETzZoneCityIndex

	};

_LIT(KTzMutexName, 	"TZ_GlobalMutex");

void CTzLocalizationDb::CleanupTimeZonePointerArray(TAny* aArray)

	{

	RPointerArray<CTzLocalizedTimeZoneRecord>* array = static_cast<RPointerArray<CTzLocalizedTimeZoneRecord>* >(aArray);

	if (array)

		{

		array->ResetAndDestroy();

		array->Close();

		}

	}

void CTzLocalizationDb::CleanupCityPointerArray(TAny* aArray)

	{

	RPointerArray<CTzLocalizedCityRecord>* array = static_cast<RPointerArray<CTzLocalizedCityRecord>* >(aArray);

	if (array)

		{

		array->ResetAndDestroy();

		array->Close();

		}

	}

CTzLocalizationDb* CTzLocalizationDb::NewL(CTzServer& aServer)

	{

	CTzLocalizationDb* self = new(ELeave) CTzLocalizationDb(aServer);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CTzLocalizationDb::~CTzLocalizationDb()

	{

	iServer.UserTimeZoneDb().RemoveObserver(this);

	CloseDb();

	iDbsSession.Close();

	}

CTzLocalizationDb::CTzLocalizationDb(CTzServer& aServer)

	: iServer(aServer)

	{

	}

void CTzLocalizationDb::ConstructL()

	{

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

	OpenDbL();

	iServer.UserTimeZoneDb().AddObserverL(this);

	}

void CTzLocalizationDb::OpenDbL()

	{

	if (iZoneMutex.OpenGlobal(KTzMutexName) != KErrNone)

		{

		User::LeaveIfError(iZoneMutex.CreateGlobal(KTzMutexName)) ;

		}

	//Attempt to open the database

	TInt error = iLocalizedTimeZoneDb.Open(iDbsSession,KTzLocalizationDbName,KTzLocalizationDbSecurityPolicy);

	if (error == KErrNotFound)

		{

		// Database file doesn't exist.  Attempt to create a new one.

		CreateBlankDatabaseL();

		}

	else if ((error == KErrNone) && IsInvalidL())

		{

		RecreateBlankDatabaseL();

		}

	else if (error == KErrNone && iServer.TimeZoneManager().TzDbHasChanged())

		{	

		// We have to refresh the data in the frequently used zones table

		// and the city table because it may contain the time zone id that

		// is not existing in the Tz database. Or the the details of a tz rule

		// has been changed.

		RestoreDbL();

		}

	else if (error != KErrNone)

		{

		User::Leave(error);

		}

	}

void CTzLocalizationDb::CloseDb()

    {

	iLocalizedTimeZoneDb.Close();

	if (iZoneMutex.IsHeld())    // it is a leave, so release mutex

		{

		iZoneMutex.Signal();

		}       

	iZoneMutex.Close();

	}

void CTzLocalizationDb::CreateBlankDatabaseL()

	{

	User::LeaveIfError(iLocalizedTimeZoneDb.Create(iDbsSession,KTzLocalizationDbName,KTzLocalizationDbSecurityPolicy));

	CreateBlankFrequentlyUsedZoneTableL();

	CreateBlankUserCityTableL();

	}

/**

Creates the Cached Zone Table.

@return KErrNone if succesful, or one of the DBMS Leave codes

@internalTechnology

*/

void CTzLocalizationDb::CreateBlankFrequentlyUsedZoneTableL()

	{

	// Create the columns for the cached zones table

	RArray<TDbCol> cachedTableCols;

	CleanupClosePushL(cachedTableCols);

	cachedTableCols.AppendL(TDbCol(KCZTableTzIdCol,			EDbColUint16));

	cachedTableCols.AppendL(TDbCol(KCZTableStdCol, 			EDbColText));

	cachedTableCols.AppendL(TDbCol(KCZTableDSTCol, 			EDbColText));

	cachedTableCols.AppendL(TDbCol(KCZTableShortStdCol, 	EDbColText));

	cachedTableCols.AppendL(TDbCol(KCZTableShortDSTCol, 	EDbColText));

	cachedTableCols.AppendL(TDbCol(KCZTableCityCol, 		EDbColText));

	cachedTableCols.AppendL(TDbCol(KCZTableCityGroupCol, 	EDbColUint8));

	cachedTableCols.AppendL(TDbCol(KCZTableResourceIdCol, 	EDbColUint32));

    cachedTableCols.AppendL(TDbCol(KCZTableCityIndexCol,	EDbColInt32));

	// Create the columnset - add the columns

	// Columns MUST be added in the same order they appear in TTzZoneColumn

	CDbColSet* frequentlyUsedZoneColSet = CDbColSet::NewLC();

	TInt numCols = cachedTableCols.Count();

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

		{

		frequentlyUsedZoneColSet->AddL(cachedTableCols[i]);

		}

	// Create the Cached Time Zone table

	User::LeaveIfError(iLocalizedTimeZoneDb.CreateTable(KCZTableName,*frequentlyUsedZoneColSet));

	//Open the newly created table

	RDbView zoneView;

	CleanupClosePushL(zoneView);

	PrepareZoneViewL(zoneView);

	zoneView.Reset();

	//Populate with initial (blank) data.

	_LIT(KEmptyString," ");

	for (TInt x = 0; x < CTzLocalizedTimeZone::ECachedTimeZones; ++x)

		{

		iZoneMutex.Wait();

		CleanupStack::PushL(TCleanupItem(ReleaseMutex,&iZoneMutex));

		// Insert empty row

		zoneView.InsertL();

		// Fill the table with blank data

		zoneView.SetColL(ETzZoneId,			0);

		zoneView.SetColL(ETzZoneStdName,		KEmptyString);

		zoneView.SetColL(ETzZoneDSTName,		KEmptyString);

		zoneView.SetColL(ETzZoneShortStdName,	KEmptyString);

		zoneView.SetColL(ETzZoneShortDSTName,	KEmptyString);

		zoneView.SetColL(ETzZoneCity,			KEmptyString);

		zoneView.SetColL(ETzZoneGroupId,		0);

		zoneView.SetColL(ETzZoneResourceId,	0);

		zoneView.SetColL(ETzZoneCityIndex,		0);

		zoneView.PutL(); // Complete insertion

		CleanupStack::Pop() ;

		iZoneMutex.Signal() ;

		}

	CleanupStack::PopAndDestroy(&zoneView);

	CleanupStack::PopAndDestroy(frequentlyUsedZoneColSet);

	CleanupStack::PopAndDestroy(&cachedTableCols); //cachedTableCols

	}

/**

Creates the user added city database table.

@return KErrNone if succesful, or one of the DBMS Leave codes

@internalTechnology

*/

void CTzLocalizationDb::CreateBlankUserCityTableL()

	{

	//Create the columns for the user aded cities table

	RArray<TDbCol> cityTableCols;

	CleanupClosePushL(cityTableCols);

	cityTableCols.AppendL(TDbCol(KUCTableTzId,			EDbColUint16));

	cityTableCols.AppendL(TDbCol(KUCTableCity,			EDbColText));

	cityTableCols.AppendL(TDbCol(KUCTableGroup,			EDbColUint8));

	cityTableCols.AppendL(TDbCol(KUCTableResourceId,	EDbColUint32));

	// Create the columnset - add the columns

	// Columns MUST be added in the same order they appear in TTzCityColumn

	CDbColSet* userCityColSet = CDbColSet::NewLC();

	TInt numCols = cityTableCols.Count();

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

		{

		userCityColSet->AddL(cityTableCols[i]);

		}

	// Create the User City table

	User::LeaveIfError(iLocalizedTimeZoneDb.CreateTable(KUCTableName,*userCityColSet));

	CleanupStack::PopAndDestroy(userCityColSet);

	CleanupStack::PopAndDestroy(&cityTableCols);

	}

//Check if the database is corrupt or invalid.

TBool CTzLocalizationDb::IsInvalidL()

	{

	RDbView zoneView;

	CleanupClosePushL(zoneView);

	PrepareZoneViewL(zoneView);

	TBool isInvalid = EFalse;

	if (!zoneView.FirstL())

		{

		isInvalid = ETrue;

		}

	if (!isInvalid)

		{

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

			{

		    if (!zoneView.NextL())

			    {

			    isInvalid = ETrue;

			    break;

		        }

		    }

		}

	CleanupStack::PopAndDestroy(&zoneView);

	return isInvalid;

	}

void CTzLocalizationDb::RecreateBlankDatabaseL()

	{

	iLocalizedTimeZoneDb.Close();

	const TUid KTzLocalizationDbSecurityPolicyUid = {0x10206A8B};

    User::LeaveIfError(iDbsSession.DeleteDatabase(KTzLocalizationDbName(),KTzLocalizationDbSecurityPolicyUid));

    CreateBlankDatabaseL();

	}

TBool CTzLocalizationDb::NeedsUpdatingL()

	{

	// Check the version of the database

    // There are 9 columns as of Oct 2006

	TBool result = ETrue;

	RDbView zoneView;

	CleanupClosePushL(zoneView);

	PrepareZoneViewL(zoneView);

    if (zoneView.ColCount() == ETzZoneCityIndex)

        {

        result = EFalse;

        }

    CleanupStack::PopAndDestroy(&zoneView);

    return result;

	}

void CTzLocalizationDb::NotifyUserTzRulesChange(TTzUserDataChange /*aChange*/)

	{

	// Do nothing as we don't use any rules information

	}

void CTzLocalizationDb::NotifyUserTzNamesChange(TTzUserDataChange aChange)

	{

	if (iLocked)

		{

		return;

		}

	if (aChange.iOperation == ETzUserDataCreated)

		{

		// Creation of new zones has no impact on existing zones

		return;

		}

	// Iterate through the tables and refresh contents if needed

	TRAPD(err, NotifyUserTzNamesChangeL(aChange));

	if (err != KErrNone)

		{

		// If there has been an error we can't guarantee the contents of the

		// database. Safest option is to lock it. The only way to unlock it

		// is to reboot the server.

		iLocked = ETrue;

		}

	}

void CTzLocalizationDb::NotifyTZDataStatusChangeL(RTz::TTzChanges aChange)

	{

	if (iLocked)

		{

		return;

		}

	if(aChange == RTz::ETZLocalizationDataChanged)

		{

		CTzSystemDataDb* systemDataDb = CTzSystemDataDb::NewLC();

		RPointerArray<CTzLocalizedTimeZoneRecord> frequentlyUsedZones;

		CleanupStack::PushL(TCleanupItem(CleanupTimeZonePointerArray,&frequentlyUsedZones));

		RPointerArray<CTzLocalizedCityRecord> cachedCities;

		CleanupStack::PushL(TCleanupItem(CleanupTimeZonePointerArray,&cachedCities));

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

			{

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

			CTzLocalizedTimeZoneRecord* timeZoneRecord = ReadFrequentlyUsedZoneL(freqUsedZone);

			CleanupStack::PushL(timeZoneRecord);

			CTzLocalizedCityRecord* cityRecord = ReadCachedTimeZoneCityL(freqUsedZone);

			CleanupStack::PushL(cityRecord);

			// If a change occurred, check if the timezone exists in the resource file and refresh it

			// If not, delete it

			if(!ExistsInSystemDbL(timeZoneRecord->Id(), *systemDataDb) && !CTzId::IsUserTzId(timeZoneRecord->Id()))

				{	

				CleanupStack::PopAndDestroy(cityRecord);

				cityRecord = NULL;

				CleanupStack::PopAndDestroy(timeZoneRecord);

				timeZoneRecord = NULL;

				if(freqUsedZone != CTzLocalizedTimeZone::ECurrentZone)

					{

					// Put the default cached zone and its default city in the array instead

					timeZoneRecord = systemDataDb->ReadFrequentlyUsedZoneL(freqUsedZone);

					}

				else

					{

					// get the current zone from the time zone server

					TInt id = GetTimeZoneIdFromTzServerL(*systemDataDb);

					timeZoneRecord = systemDataDb->ReadTimeZoneL(id);

					}

				CleanupStack::PushL(timeZoneRecord);

				cityRecord = systemDataDb->ReadDefaultCityL(timeZoneRecord->Id());

				CleanupStack::PushL(cityRecord);

				cachedCities.AppendL(cityRecord);

				// ownership is transferred into the array

				CleanupStack::Pop(cityRecord);

				frequentlyUsedZones.AppendL(timeZoneRecord);

				// ownership is transferred into the array

				CleanupStack::Pop(timeZoneRecord);

				}	

			else

				{

				TUint tzid = timeZoneRecord->Id();

				CleanupStack::PopAndDestroy(cityRecord);

				cityRecord = NULL;

				CleanupStack::PopAndDestroy(timeZoneRecord);

				timeZoneRecord = NULL;

				UpdateTimeZoneAndCityRecordForSystemDataL(frequentlyUsedZones, cachedCities, tzid, *systemDataDb);	

				}

			}

		WriteAllFrequentlyUsedZonesL(frequentlyUsedZones, cachedCities);

		// Get the cities with the deleted time zone id

		RDbView cityView;

		CleanupClosePushL(cityView);

		_LIT(KSQLQueryLit,"SELECT * FROM UserCities");

		// Iterate through all the cities and delete them when

		// the corresponding tz id doesn't exist anymore

		PrepareCityViewL(cityView, KSQLQueryLit);

		// Loop through the rowset and delete the cities

		for (cityView.FirstL(); cityView.AtRow(); cityView.NextL())

			{

			cityView.GetL();

			if (!ExistsInSystemDbL(cityView.ColUint16(ETzCityId), *systemDataDb))

				{

				cityView.DeleteL();

				}

			}

		CleanupStack::PopAndDestroy(&cityView);

		CleanupStack::PopAndDestroy(&cachedCities); 

		CleanupStack::PopAndDestroy(&frequentlyUsedZones); 

		CleanupStack::PopAndDestroy(systemDataDb);

		}

	}

void CTzLocalizationDb::UpdateTimeZoneAndCityRecordForSystemDataL(RPointerArray<CTzLocalizedTimeZoneRecord>& aFrequentlyUsedZones, 

		RPointerArray<CTzLocalizedCityRecord>& aCachedCities, TInt aTzId, CTzSystemDataDb& aSystemDataDb)

	{

	CTzLocalizedTimeZoneRecord* timeZone = aSystemDataDb.ReadTimeZoneL(aTzId);

	CleanupStack::PushL(timeZone);

	CTzLocalizedCityRecord* city = aSystemDataDb.ReadDefaultCityL(aTzId);

	CleanupStack::PushL(city);

	aCachedCities.AppendL(city);

	// ownership is transferred into the array

	CleanupStack::Pop(city);

	aFrequentlyUsedZones.AppendL(timeZone);

	// ownership is transferred into the array

	CleanupStack::Pop(timeZone);

	}

TBool CTzLocalizationDb::ExistsInSystemDbL(TUint aTzId, CTzSystemDataDb& aSystemDataDb)

	{

	CTzLocalizedTimeZoneRecord* timeZoneRecord = NULL;

	TRAPD(err, timeZoneRecord = aSystemDataDb.ReadTimeZoneL(aTzId));

	delete timeZoneRecord;

	if(err == KErrNone)

		{

		return ETrue;

		}

	return EFalse;	

	}

/**

Reads all the user defined cities stored in the

database. If the database is empty the

returned array will contain no elements.

@param aCities Array of cities to add the user defined to.

@internalTechnology

*/

void CTzLocalizationDb::ReadCitiesL(RPointerArray<CTzLocalizedCityRecord>& aCities)

	{

	if (iLocked)

		{

		User::Leave(KErrLocked);

		}

	_LIT(KSQLQueryLit,"SELECT * FROM UserCities");

	DoReadCitiesL(aCities,KSQLQueryLit());

	}

void CTzLocalizationDb::ReadCitiesL(RPointerArray<CTzLocalizedCityRecord>& aCities, TInt aTimeZoneId)

	{

	if (iLocked)

		{

		User::Leave(KErrLocked);

		}

	// Assign basic SQL query literal

	_LIT(KSQLQueryLit,"SELECT * FROM UserCities WHERE TzId = ");

	// Assign a buffer with enough room to hold the query including the time zone id

	HBufC* sqlStr = HBufC::NewLC(KSQLQueryLit().Length() + EMaxTimeZoneIdStringLength);

	// Set the buffer to the start of the query

	*sqlStr = KSQLQueryLit;

	// Append the time zone ID

	sqlStr->Des().AppendNum(aTimeZoneId);

	DoReadCitiesL(aCities,*sqlStr);

	CleanupStack::PopAndDestroy(sqlStr);

	}

void CTzLocalizationDb::ReadCitiesInGroupL(RPointerArray<CTzLocalizedCityRecord>& aCities, TUint8 aGroupId)

	{

	if (iLocked)

		{

		User::Leave(KErrLocked);

		}

	// Assign basic SQL query literal

	_LIT(KSQLQueryLit,"SELECT * FROM UserCities WHERE GroupId = ");

	HBufC* sqlStr = HBufC::NewLC(KSQLQueryLit().Length() + EMaxGroupIdStringLength);

	// Set the buffer to the start of the query

	*sqlStr = KSQLQueryLit;

	// Append the time zone ID

	sqlStr->Des().AppendNum(aGroupId);

	DoReadCitiesL(aCities,*sqlStr);

	CleanupStack::PopAndDestroy(sqlStr);

	}

/**

Retrieves a cached zone from the database.

The calling function takes ownership of the returned zone

@param aFrequentlyUsedZone - The cached zone to return

@return a cached zone from the database

@internalTechnology

*/

CTzLocalizedTimeZoneRecord* CTzLocalizationDb::ReadFrequentlyUsedZoneL(TInt aFrequentlyUsedZone)

	{

	if (iLocked)

		{

		User::Leave(KErrLocked);

		}

	return DoReadFrequentlyUsedZoneL(aFrequentlyUsedZone);

	}