/*

* Copyright (c) 2005 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:  source file for dm tree db handler

*

*/

#include <utf.h>

#include <s32file.h>

#include <sysutil.h>

#include <bautils.h>

#include <utf.h>

#include <data_caging_path_literals.hrh>

#include <nsmlconstants.h>

#include <nsmldebug.h>

#include <nsmldmdbhandler.h>

#include <nsmldmuri.h>

//For P&S keys

#include <e32property.h>

#include "nsmldminternalpskeys.h"

#include "nsmldmaclparser.h"

// ===========================================================================

// CNSmlDmDbHandler

// ===========================================================================

// ---------------------------------------------------------------------------

// CNSmlDmDbHandler::~CNSmlDmDbHandler()

// ---------------------------------------------------------------------------

EXPORT_C CNSmlDmDbHandler::~CNSmlDmDbHandler()

	{

	iAdapters.ResetAndDestroy();

	iView.Close();

	iDatabase.Close();

	if ( iFileStore )

		{

		delete iFileStore;

		}

	iFsSession.Close();

	delete iServer;

	iAclURIs.ResetAndDestroy();

	iAcls.ResetAndDestroy();

	}

// ---------------------------------------------------------------------------

// CNSmlDmDbHandler* CNSmlDmDbHandler::NewLC()

// ---------------------------------------------------------------------------

EXPORT_C CNSmlDmDbHandler* CNSmlDmDbHandler::NewLC()

	{

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

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

// ---------------------------------------------------------------------------

// CNSmlDmDbHandler* CNSmlDmDbHandler::NewL()

// ---------------------------------------------------------------------------

EXPORT_C CNSmlDmDbHandler* CNSmlDmDbHandler::NewL()

	{

	CNSmlDmDbHandler* self = CNSmlDmDbHandler::NewLC();

	CleanupStack::Pop();

	return self;

	}

// ---------------------------------------------------------------------------

// void CNSmlDmDbHandler::ConstructL()

// ---------------------------------------------------------------------------

void CNSmlDmDbHandler::ConstructL()

	{

	_DBG_FILE("CNSmlDmDbHandler::ConstructL() : begin");

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

	HBufC* treeDbPath = HBufC::NewLC( KMaxFileName );

	TPtr treeDbPtr = treeDbPath->Des();

	User::LeaveIfError(iFsSession.PrivatePath( treeDbPtr ) );

	treeDbPtr.Append(KSmlDmModuleDbName);

	if ( !BaflUtils::FileExists ( iFsSession, *treeDbPath ) )

		{

		CreateDatabaseL( *treeDbPath );		

		}

	else

		{

 	   	iFileStore = CPermanentFileStore::OpenL ( iFsSession,

	   		*treeDbPath, EFileRead|EFileWrite );

    	iFileStore->SetTypeL ( iFileStore->Layout() );

		}

	CleanupStack::PopAndDestroy(); //treeDbPath	

	_DBG_FILE("CNSmlDmDbHandler::ConstructL() : end");

	}

// ---------------------------------------------------------------------------

// void CNSmlDmDbHandler::CreateDatabaseL( const TDesC& aFullName )

// Creates database and tables

// ---------------------------------------------------------------------------

void CNSmlDmDbHandler::CreateDatabaseL( const TDesC& aFullName )

	{

	_DBG_FILE("CNSmlDmDbHandler::CreateDatabaseL() : begin");

    // Create empty database file.

  	iFsSession.CreatePrivatePath( EDriveC );

    iFileStore = CPermanentFileStore::ReplaceL ( iFsSession,

    	aFullName, EFileRead|EFileWrite );

    iFileStore->SetTypeL ( iFileStore->Layout() );

    TStreamId id = iDatabase.CreateL ( iFileStore );

    iFileStore->SetRootL ( id );

    iFileStore->CommitL();

	iDatabase.Begin();

	CDbColSet* luidMappingColumns = CDbColSet::NewLC();

	luidMappingColumns->AddL(TDbCol ( KNSmlDmAdapterId, EDbColUint32 ) ); 		//adapter impluid

	luidMappingColumns->AddL(TDbCol ( KNSmlDmMappingURI, EDbColLongText8 ) ); 	//mapping uries in string separated with '&'

	luidMappingColumns->AddL(TDbCol ( KNSmlDmMappingLuid, EDbColLongText8 ) ); 	//table of mapping luids

	//Create LuidMapping table

	User::LeaveIfError ( iDatabase.CreateTable ( KNSmlDmLuidMappingTable,

		*luidMappingColumns ) );

	CDbColSet* aclColumns = CDbColSet::NewLC();

	//adapter impluid

	aclColumns->AddL ( TDbCol ( KNSmlDmAdapterId, EDbColUint32 ) ); 

	//uries in string separated with '&'

	aclColumns->AddL ( TDbCol ( KNSmlDmAclURI, EDbColLongText8 ) );

	//table of acls

	aclColumns->AddL ( TDbCol ( KNSmlDmAcl, EDbColLongText8 ) );

	//Create AclTable table

	User::LeaveIfError ( iDatabase.CreateTable ( KNSmlDmAclTable,

		*aclColumns ) );

	iDatabase.Commit();

	iDatabase.Close();

	CleanupStack::PopAndDestroy( 2 ); // luidMappingColumns, aclColumns

	_DBG_FILE("CNSmlDmDbHandler::CreateDatabaseL() : end");

	}

// ---------------------------------------------------------------------------

// void CNSmlDmDbHandler::SetServerL(const TDesC& aServer)

// Set the iServer member variable, which is used for ACL handling

// ---------------------------------------------------------------------------

EXPORT_C void CNSmlDmDbHandler::SetServerL(const TDesC8& aServer)

	{

	_DBG_FILE("CNSmlDmDbHandler::SetServerL() : begin");

	if(iServer)

		{

		delete iServer;

		iServer = 0;

		}

	iServer = aServer.AllocL();

	_DBG_FILE("CNSmlDmDbHandler::SetServerL() : end");

	}

// ---------------------------------------------------------------------------

// void CNSmlDmDbHandler::ReadAllURIMappingsFromDbL()

// Get the URI mapping info from database to member variables.

// ---------------------------------------------------------------------------

void CNSmlDmDbHandler::ReadAllURIMappingsFromDbL()

	{

	iAdapters.ResetAndDestroy();

	iDatabase.OpenL ( iFileStore, iFileStore->Root() );

	_LIT ( KNSmlDmSQLStatement, "SELECT * FROM LuidMappingTable");

	TPtrC sql ( KNSmlDmSQLStatement() );

	User::LeaveIfError ( iView.Prepare ( iDatabase, sql,

		TDbWindow( TDbWindow::EUnlimited ) ) );

	User::LeaveIfError ( iView.EvaluateAll() );

	if ( iView.FirstL() )

		{

		do 

			{

			iView.GetL();

			ReadOneLineFromDbL();

			} while ( iView.NextL() );	

		}

	iView.Close();

	iDatabase.Close();

	}

// ---------------------------------------------------------------------------

// void CNSmlDmDbHandler::ReadOneLineFromDbL()

// Reads one line at the time from db.

// Cursor is kept at valid line outside of this function.

// ---------------------------------------------------------------------------

void CNSmlDmDbHandler::ReadOneLineFromDbL()

	{

	TUint32 adapterId(0);			

	CDbColSet* colSet = iView.ColSetL();

	CleanupStack::PushL ( colSet );

	RDbColReadStream colReadStream;

	adapterId = iView.ColUint32 ( colSet->ColNo ( KNSmlDmAdapterId ) );

	TDbColNo uri = colSet->ColNo ( KNSmlDmMappingURI );

	TDbColNo luid = colSet->ColNo ( KNSmlDmMappingLuid );

	colReadStream.OpenLC ( iView, uri );

	HBufC8* uri8 = HBufC8::NewLC ( iView.ColLength( uri ) );

	TPtr8 uriPtr = uri8->Des();

	colReadStream.ReadL ( uriPtr, iView.ColLength ( uri ) );

	CleanupStack::Pop();  // uriPtr

	CleanupStack::PopAndDestroy();  // colReadStream

	CleanupStack::PushL( uri8 ); 

	colReadStream.OpenLC ( iView, luid );

	HBufC8* luid8 = HBufC8::NewLC ( iView.ColLength( luid ) );

	TPtr8 luidPtr = luid8->Des();

	colReadStream.ReadL ( luidPtr, iView.ColLength ( luid ) );

	CleanupStack::Pop();  // luidPtr

	CleanupStack::PopAndDestroy();  // colReadStream

	CleanupStack::PushL ( luid8 ); 

	UpdateInternalArrayL (

		adapterId, uriPtr, luidPtr, EMapNoAction, ENormalSearch );

	CleanupStack::PopAndDestroy(3); // luidPtr, uriPtr, colSet				

	}

// ---------------------------------------------------------------------------

// void CNSmlDmDbHandler::UpdateInternalArrayL()

// Adds (or marks) entries to member variable array.

// Given values are either read from db or function call parameters.

// ---------------------------------------------------------------------------

void CNSmlDmDbHandler::UpdateInternalArrayL(TUint32 aAdapterId,

	const TDesC8& aURI,

	const TDesC8& aLUID,

	TNSmlDmMapOperation aOperation,

	TNSmlDmSearchMethod aMethod,

	const TDesC8& aNewUri )

	{

	CNSmlDmURIMapping* mapElement =

		CNSmlDmURIMapping::NewLC( aURI, aLUID, aOperation );

	TBool newAdapter(ETrue);

	for ( TInt i=0; i<iAdapters.Count(); i++ )

		{

		if ( iAdapters[i]->iAdapterId == aAdapterId )

			{

			newAdapter = EFalse;

			if ( aOperation == EMapNoAction || aMethod == ENoSearch )

				{

				iAdapters[i]->iMapArray.AppendL ( mapElement );

				CleanupStack::Pop();  // mapElement			

				}

			else

				{

				TInt adIndex(0);

				RArray<TInt> uriIndex;

				SearchUriL( aAdapterId, aURI, aMethod, adIndex, uriIndex );

				if ( aOperation == EMapDelete )

					{

					for ( TInt u=0; u<uriIndex.Count(); u++ )

						{

						TInt mapIndex ( uriIndex[u] );

						iAdapters[adIndex]->iMapArray[mapIndex]->iOperation

							= aOperation;

						}

					CleanupStack::PopAndDestroy();  // mapElement

					}

				else if ( aOperation == EMapInsert )

					{

					if ( uriIndex.Count() > 0 )

						{

						CleanupStack::PopAndDestroy();  // mapElement

						for ( TInt u=0; u<uriIndex.Count(); u++ )

							{

							if ( aLUID.Compare (*iAdapters[adIndex]->

								iMapArray[uriIndex[u]]->iLUID ) != 0 ||

							    iAdapters[adIndex]->iMapArray[uriIndex[u]]->

							    iOperation == EMapDelete ) 

								{

								iAdapters[adIndex]->iMapArray[uriIndex[u]]->

									iOperation = EMapUpdate;

								delete iAdapters[adIndex]->

									iMapArray[uriIndex[u]]->iLUID;

								iAdapters[adIndex]->iMapArray[uriIndex[u]]->

									iLUID = NULL;							

								iAdapters[adIndex]->iMapArray[uriIndex[u]]->

									iLUID = aLUID.AllocL();

								}

							}

						}

					else

						{

						iAdapters[i]->iMapArray.AppendL ( mapElement );

						CleanupStack::Pop();  // mapElement

						}

					}

				else if ( aOperation == EMapRename )

					{

					for ( TInt u=0; u<uriIndex.Count(); u++ )

						{

						iAdapters[adIndex]->iMapArray[uriIndex[u]]->

							iOperation = EMapDelete;

						HBufC8* oldLUIDSaved = iAdapters[adIndex]->

							iMapArray[uriIndex[u]]->iLUID;

						TPtr8 newURI = HBufC8::NewLC( aNewUri.Length() + ( iAdapters[adIndex]->iMapArray[uriIndex[u]]->iURI->Length() - aURI.Length() ) )->Des();

						newURI.Copy ( aNewUri );

						if (  iAdapters[adIndex]->iMapArray[uriIndex[u]]->

							iURI->Length() - aURI.Length() > 0 )

							{

							newURI.Append ( iAdapters[adIndex]->

								iMapArray[uriIndex[u]]->iURI->

								Mid( aURI.Length() ) );

							}

						UpdateInternalArrayL ( aAdapterId,

							newURI,

							*oldLUIDSaved,

							EMapInsert,

							ENoSearch );

						CleanupStack::PopAndDestroy();  // newURI

						}

					CleanupStack::PopAndDestroy();  // mapElement

					}

				else 

					{

					CleanupStack::PopAndDestroy(); // mapElement

					}

				uriIndex.Reset();

				}

			break;

			}

		}

	if ( newAdapter && aOperation != EMapDelete )

		{

		CNSmlDmAdapterElement* adapterElement =

			CNSmlDmAdapterElement::NewLC ( aAdapterId );

		iAdapters.AppendL ( adapterElement );

		iAdapters[iAdapters.Count()-1]->iMapArray.AppendL ( mapElement );

		CleanupStack::Pop(2);  // adapterElement, mapElement

		}	

//ADD-S for DMS00652653

	else if ( newAdapter)

		{

		CleanupStack::PopAndDestroy(); // mapElement

		}

//ADD-E for DMS00652653

	}

// ---------------------------------------------------------------------------

// void CNSmlDmDbHandler::UpdateRowInDbL(

//	TUint32 aAdapterId,

// 	const TDesC8& aURI, 

//	const TDesC8& aLUID,

//	TNSmlDmMapOperation aOperation,

//	TBool aPrepareView )

// ---------------------------------------------------------------------------

void CNSmlDmDbHandler::UpdateRowInDbL(TUint32 aAdapterId,

	const TDesC8& aURI,

	const TDesC8& aLUID,

	TNSmlDmMapOperation aOperation )

	{

	iDatabase.Begin();

	TBool insertNewEntry(EFalse);

	if ( aOperation == EMapDelete )

		{

		if ( SearchRowInDbL ( aAdapterId, aURI ) == KErrNone )

			{

			iView.GetL();

			iView.DeleteL();

			iPrepareView = ETrue;

			}

		}

	else if ( aOperation == EMapUpdate )

		{

		if ( SearchRowInDbL ( aAdapterId, aURI ) == KErrNone )

			{

			CDbColSet* colSet = iView.ColSetL();

			CleanupStack::PushL ( colSet );

			iView.GetL();

			iView.UpdateL();

			RDbColWriteStream writeStream;

			writeStream.OpenLC ( iView, colSet->ColNo( KNSmlDmMappingLuid ));

			writeStream.WriteL ( aLUID );

			writeStream.CommitL();

			CleanupStack::PopAndDestroy(); //writeStream

			iView.PutL();

			CleanupStack::PopAndDestroy(); //colSet

			iPrepareView = EFalse;

			}

		else

			{

			insertNewEntry = ETrue;

			}

		}		

	if ( aOperation == EMapInsert  || insertNewEntry )

		{

		RDbTable uriTable;

		User::LeaveIfError ( uriTable.Open ( iDatabase,

			KNSmlDmLuidMappingTable ) );

		CDbColSet* columns = uriTable.ColSetL();

		CleanupStack::PushL ( columns );

		uriTable.Reset();

		uriTable.InsertL();

		uriTable.SetColL ( columns->ColNo ( KNSmlDmAdapterId ), aAdapterId );

		RDbColWriteStream writeStream;

		writeStream.OpenLC ( uriTable, columns->ColNo( KNSmlDmMappingLuid ) );

		writeStream.WriteL ( aLUID );

		writeStream.CommitL();

		CleanupStack::PopAndDestroy();  // writestream for Luid

		writeStream.OpenLC ( uriTable, columns->ColNo( KNSmlDmMappingURI ) );

		writeStream.WriteL ( aURI );

		writeStream.CommitL();

		CleanupStack::PopAndDestroy();  // writestream for Uri		

		uriTable.PutL();

		CleanupStack::PopAndDestroy(); // columns

		uriTable.Close();

		iPrepareView = EFalse;

		}

	iView.Close();	

	iDatabase.Commit();

	}

// ---------------------------------------------------------------------------

// TInt CNSmlDmDbHandler::SearchRowInDbL()

// ---------------------------------------------------------------------------

TInt CNSmlDmDbHandler::SearchRowInDbL(TUint32 aAdapterId,

	const TDesC8& aURI )

	{

	TInt ret(KErrNotFound);

	if ( iPrepareView )

		{

		_LIT( KNSmlDmUpdateRow,

			"SELECT * FROM LuidMappingTable WHERE AdapterId=%u" );

		TPtr sqlPtr = HBufC::NewLC( KNSmlDmUpdateRow().Length() +

			KNSmlDmIdLength )->Des(); 

		sqlPtr.Format ( KNSmlDmUpdateRow(), aAdapterId );

		User::LeaveIfError ( iView.Prepare ( iDatabase, sqlPtr,

			TDbWindow( TDbWindow::EUnlimited ) ) );

		User::LeaveIfError ( iView.EvaluateAll() );

		CleanupStack::PopAndDestroy();  // sqlPtr

		}

	if ( iView.FirstL() )

		{

		do 

			{

			CDbColSet* colSet = iView.ColSetL();

			CleanupStack::PushL ( colSet );

			TDbColNo uri = colSet->ColNo ( KNSmlDmMappingURI );

			iView.GetL();

			RDbColReadStream colReadStream;

			colReadStream.OpenLC ( iView, uri );

			HBufC8* uri8 = HBufC8::NewLC ( iView.ColLength( uri ) );

			TPtr8 uriPtr = uri8->Des();

			colReadStream.ReadL ( uriPtr, iView.ColLength ( uri ) );

			if ( aURI.Compare ( uriPtr ) == 0 )

				{

				CleanupStack::PopAndDestroy(3);//uri8, colReadStream, colSet

				ret = KErrNone;

				break;

				}

			CleanupStack::PopAndDestroy(3);//uri8, colReadStream, colSet			

			} while ( iView.NextL() );	

		}

	return ret;

	}

// ---------------------------------------------------------------------------

// TInt CNSmlDmDbHandler::SearchUriL()

// Searches the given URI from the internal array.

// There are four different search methods:

// - ENormalSearch: lengths and contents must match

// - EUsingParents: e.g. given Email/NN/XXX finds and stops to Email/NN

// - EAmongChidren: e.g. given Email/NN finds: Email/NN/AA,

//		Email/NN/3 and Email/NN

// - EAmongParents: e.g. given Email/NN finds: Email/NN/AA and Email/NN/3

//		but NOT Email/NN

// ---------------------------------------------------------------------------

TInt CNSmlDmDbHandler::SearchUriL( TUint32 aAdapterId,

	const TDesC8& aURI,

	TNSmlDmSearchMethod aSearchMethod,

	TInt& aAdIndex,

	RArray<TInt>& aUriIndex)