// Copyright (c) 2004-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:
//

#include "TzLocalizationDbAccessor.h"
#include "TzLocalizationDataTypes.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");

/**
Allocates and constructs a new CTzLocalizationDbAccessor
@return the newly constructed CTzLocalizationDbAccessor
@internalTechnology
*/
CTzLocalizationDbAccessor* CTzLocalizationDbAccessor::NewL()
	{
	CTzLocalizationDbAccessor* self = CTzLocalizationDbAccessor::NewLC();
	CleanupStack::Pop(self);
	return self;
	}

/**
Allocates and constructs a new CTzLocalizationDbAccessor
The pointer to the new object is left on the cleanup stack
@return the newly constructed CTzLocalizationDbAccessor
@internalTechnology
*/
CTzLocalizationDbAccessor* CTzLocalizationDbAccessor::NewLC()
	{
	CTzLocalizationDbAccessor* self = new (ELeave) CTzLocalizationDbAccessor();
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}

CTzLocalizationDbAccessor::CTzLocalizationDbAccessor()
	{
	}

/**
Second phase construction
Connects to a database session and opens the database.  If the database doesn't exist it is created
and populated with blank time zone data
@internalTechnology
*/
void CTzLocalizationDbAccessor::ConstructL()
	{
    OpenDbL();
    }

void CTzLocalizationDbAccessor::OpenDbL()
	{
	if (iZoneMutex.OpenGlobal(KTzMutexName) != KErrNone)
		{
		User::LeaveIfError(iZoneMutex.CreateGlobal(KTzMutexName)) ;
		}        
	//Connect to database server session
	User::LeaveIfError(iDbsSession.Connect());
	//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.
		error = iLocalizedTimeZoneDb.Create(iDbsSession,KTzLocalizationDbName,KTzLocalizationDbSecurityPolicy);
	 	User::LeaveIfError(error); 
 	 
 		//Check whether tables exist and create them if they do not	 
 		if (!IsTableCreatedL(KCZTableName)) 
 			{ 
			User::LeaveIfError(CreateFrequentlyUsedZoneTableL()); 
 			} 
  		if (!IsTableCreatedL(KUCTableName)) 
 			{ 
 			User::LeaveIfError(CreateUserCityTableL()); 
 			} 
  		}
	}

	
/**
Destructor
Closes the database tables, the database and the database session
@internalTechnology
*/
CTzLocalizationDbAccessor::~CTzLocalizationDbAccessor()
	{
    CloseDb();
    iDbsSession.Close();
    }

void CTzLocalizationDbAccessor::CloseDb()
    {
	iCityView.Close();
	iZoneView.Close();
	iLocalizedTimeZoneDb.Close();
	if (iZoneMutex.Handle() && iZoneMutex.IsHeld())    // it is a leave, so release mutex
		{
		iZoneMutex.Signal();
		}       
	iZoneMutex.Close();
	}

// Close and delete the DB and create a new one in the latest format
void CTzLocalizationDbAccessor::RecreateDbL(RTz& aTzSession)
    {
    CloseDb();
    aTzSession.LocalizationCloseDbL();
    const TUid KTzLocalizationDbSecurityPolicyUid = {0x10206A8B};
    User::LeaveIfError(iDbsSession.DeleteDatabase(KTzLocalizationDbName(),KTzLocalizationDbSecurityPolicyUid));
    aTzSession.LocalizationOpenDbL();
    OpenDbL();
    }

TBool CTzLocalizationDbAccessor::DbNeedsUpdatingL()
    {
    // Check the version of the database
    // There are 9 columns as of Oct 2006
    PrepareZoneViewL();
    if (iZoneView.ColCount() == ETzZoneCityIndex)
        {
        return EFalse;
        }
    return ETrue;
     }
/**
Releases the mutex if leave occurs between wait and signal.
@internalTechnology
*/
void CTzLocalizationDbAccessor::ReleaseMutex(TAny *target)
{
	RMutex *mutex = static_cast<RMutex*> (target) ;	
	mutex->Signal() ;	
}

/**
Creates the Cached Zone Table if it doesn't already exist.
@return KErrNone if succesful, or one of the DBMS Leave codes
@internalTechnology
*/
TInt CTzLocalizationDbAccessor::CreateFrequentlyUsedZoneTableL()
	{
	// 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
	TInt error = iLocalizedTimeZoneDb.CreateTable(KCZTableName,*FrequentlyUsedZoneColSet);
	User::LeaveIfError(error);

	//Open the newly created table
	PrepareZoneViewL();
	iZoneView.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
		iZoneView.InsertL();
		// Fill the table with blank data
		iZoneView.SetColL(ETzZoneId,			0);
		iZoneView.SetColL(ETzZoneStdName,		KEmptyString);
		iZoneView.SetColL(ETzZoneDSTName,		KEmptyString);
		iZoneView.SetColL(ETzZoneShortStdName,	KEmptyString);
		iZoneView.SetColL(ETzZoneShortDSTName,	KEmptyString);
		iZoneView.SetColL(ETzZoneCity,			KEmptyString);
		iZoneView.SetColL(ETzZoneGroupId,		0);
		iZoneView.SetColL(ETzZoneResourceId,	0);
        iZoneView.SetColL(ETzZoneCityIndex,		0);
		iZoneView.PutL(); // Complete insertion
		CleanupStack::Pop() ;
		iZoneMutex.Signal() ;
		}
	
	iZoneView.Close();

	CleanupStack::PopAndDestroy(FrequentlyUsedZoneColSet);
	CleanupStack::PopAndDestroy(&cachedTableCols); //cachedTableCols
	return error;
	}

/**
Creates the user added city database table if it doesn't exist
@return KErrNone if succesful, or one of the DBMS Leave codes
@internalTechnology
*/
TInt CTzLocalizationDbAccessor::CreateUserCityTableL()
	{
	//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
	TInt error = iLocalizedTimeZoneDb.CreateTable(KUCTableName,*userCityColSet);
	
	CleanupStack::PopAndDestroy(userCityColSet);
	CleanupStack::PopAndDestroy(); //cityTableCols

	return error;
	}


/**
Opens the a view on the city table and returns a reference to it.
The view should be released after use with a call to CloseCityView()
@param aSql A sql string to prepare the view with
@return reference to opened iCityTable
@internalTechnology
*/
void CTzLocalizationDbAccessor::PrepareCityViewL(const TDesC& aSqlQuery)
	{
	User::LeaveIfError(
		iCityView.Prepare(iLocalizedTimeZoneDb,
		TDbQuery(aSqlQuery),
		iCityView.EUpdatable)
		);
	User::LeaveIfError(iCityView.EvaluateAll());
	}


/**
Opens the zone table and returns a reference
@return reference to the opened iZoneTable
@internalTechnology
*/
void CTzLocalizationDbAccessor::PrepareZoneViewL()
	{
	_LIT(KReadZoneView,"SELECT * FROM FrequentlyUsedZones");
	User::LeaveIfError(
		iZoneView.Prepare(iLocalizedTimeZoneDb,
		TDbQuery(KReadZoneView),
		iZoneView.EUpdatable)
		);

	User::LeaveIfError(iZoneView.EvaluateAll());
	}
TBool CTzLocalizationDbAccessor::IsTableCreatedL(const TDesC& aTableName) const 
  	{ 
   	TBool result = EFalse; 
  	CDbTableNames* tableNames = iLocalizedTimeZoneDb.TableNamesL(); 
	CleanupStack::PushL(tableNames); 
	if(tableNames) 
		{ 
		const TInt count = tableNames->Count(); 
  		for(TInt i = 0; i < count; i++) 
			{ 		 
			if((*tableNames)[i] == aTableName) 
				{ 
				result = ETrue; 
				break; 
				} 
			} 
		} 
		CleanupStack::PopAndDestroy(tableNames); 
 	return result;	 
 	} 

