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

//

#ifdef _DEBUG

#undef _NO_SERVER_LOGGING_

#endif

/**

 * User Includes

 */

#include "MSVSERV.H"

#include "MSVARRAY.H"

#include "msvdbadapter.h"

#include "msvcacheentry.h"

#include "msvindexadapter.h"

#include "msventryfreepool.h"

#include "msvcachevisiblefolder.h"

#include "msvsearchsortdeltacache.h"

#include "msvsearchsortcachemanager.h"

/**

 *System Includes

 */

#include <msvuids.h>

#include <msvstd.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS 

#include "msvconsts.h"

#endif

/**

 * MACRO DEFINITIONS

 */

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

	#define INITIAL_NUM_ENTRIES 10

#else

	#define INITIAL_NUM_ENTRIES 13

#endif

/**

 * CONSTANT DEFINITIONS

 */

const TInt KMsvMtmListGranularity=8;

const TInt KMsvChangeAttributesListGranularity=32;

/**

 * FUNCTION DEFINITIONS

 */

/**

 * CMsvIndexAdapter()

 */

CMsvIndexAdapter::CMsvIndexAdapter(CMsvServer& aServer)

    :CActive(EPriorityStandard), iServer(aServer), iFolderListHeader(CMsvCacheVisibleFolder::iOffset)

	{	

	CActiveScheduler::Add(this);		

	}

/**

 * ~CMsvIndexAdapter()

 */

CMsvIndexAdapter::~CMsvIndexAdapter()

	{

#ifndef _NO_SERVER_LOGGING_

	iServer.Log(_L("Destroying CMsvIndexAdapter object."));

#endif

	Cancel();

	// 1. Close the database.

#ifndef _NO_SERVER_LOGGING_

	iServer.Log(_L("Closing the database."));

#endif

	if(iDbAdapter != NULL)

		delete iDbAdapter;

	// 2. Delete Cache.

#ifndef _NO_SERVER_LOGGING_

	iServer.Log(_L("Destroying Cache."));

#endif

	CMsvCacheVisibleFolder* folderNode = NULL;

	TDblQueIter<CMsvCacheVisibleFolder> dqIter(iFolderListHeader);

    dqIter.SetToFirst();

    while ((folderNode = dqIter++) != NULL)

        {

        folderNode->iDlink.Deque();

        delete folderNode;

        }

    iFreePoolInstance->ReleaseEntry(iRootEntry);

    iRootEntry = NULL;

    // 3. Delete internal data structure.

    iNonCommittedAddedEntryList.ResetAndDestroy();

    iNonCommittedChangedEntryList.Reset();

    iNonCommittedAddedEntryList.Close();

	iNonCommittedChangedEntryList.Close();

    // 4. Flush extra memory in entry freepool.

    if(iFreePoolInstance != NULL)

    	{

    	iFreePoolInstance->FlushExcessMemory();	

    	}

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

	// Added for 557.

	iMaxMsvIdList.Close();

#endif

	delete iIdle;

	}

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

/**

 * NewL()

 * @return The newly created index adapter object.

 * 

 * Function added as part of PREQ 557.

 * It returns an instance of CMsvIndexAdapter class. 

 */

CMsvIndexAdapter* CMsvIndexAdapter::NewL(CMsvServer& aServer)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

/**

 * ConstructL()

 * 

 * Function added as part of PREQ 557.

 * The function is called from NewL().

 * 1. Create the DB adapter object.

 * 2. Initialize freepool object.

 * 3. Create the root entry in cache.

 * 4. Browse through the preferred drive list.

 *    i. For each drive in the preferred drive list the function 

 *       assigns a unique drive-id (0< Id <8).

 *	 ii. Attach the DB to the primary database.

 *  iii. Update the maxId of the database to MaxId table.

 *   iv. If the database is not compatible or corrupt, update the 

 *       appropriate drive status in CMsvServer data structure.

 *    v. Fetch children of root entry and Local-Service entry from the DB to the cache.      

 */

void CMsvIndexAdapter::ConstructL()

	{

#ifndef _NO_SERVER_LOGGING_

	iServer.Log(_L("Inside ConstructL()..."));

#endif

	// Create database adapter object.

	iDbAdapter = CMsvDBAdapter::NewL();

#ifndef _NO_SERVER_LOGGING_

	iServer.Log(_L("The database object is created succesfully."));

#endif

	iProgress.iCompleted = 0;

	iProgress.iTotal = iProgress.iRemaining = INITIAL_NUM_ENTRIES;

	// Initialize freepool object.

	iFreePoolInstance = CMsvEntryFreePool::Instance();

	iFreePoolInstance->SetEssentialParam(&iFolderListHeader, this);

	// Drive id zero will be synonym of KCurrentDriveId. Drive

	// id of a drive (including current) drive will never be zero.

	// Drive of the current drive will always by KCurrentDriveId.

	TUint driveId = KCurrentDriveId;

	// Since driveId starts from 1, the first 

	// entry in iMaxMsvIdList is not used.

	// Enter a dummy entry in location zero.

	iMaxMsvIdList.InsertL(0, 0);

	iProgress.iCompleted++;

	iProgress.iRemaining--;

	iProgress.iId = KMsvRootIndexEntryId;

	// For each drive in the preferred drive list, perform followings...

	// 1. Check if a valid message store is available.

	// 2. If not, skip the drive.

	// 3. Assign a new drive Id to the drive and

	//    update the entry in preferred drive list.

	// 4. Attach the drive database to the primary DB.

	// 5. Update the max Id list.

	// 6. For current drive, fetch the children of root entry into cache.

	// 7. Fetch children of localService into cache.

	CMsvPreferredDriveList *driveList = CMsvPreferredDriveList::GetDriveList();

	TUint curDriveIndex = driveList->CurrentDriveIndex();

	for(TInt index=curDriveIndex; index<driveList->Count(); index++)

		{

		TMsvPreferredDrive driveEntry;

		driveList->DriveInfoL(index, driveEntry);

		if(EMsvMessageStoreAvailableStatus == driveEntry.status)

			{

			// Assign a unique drive-id.

			driveList->UpdateDriveIdL(index, driveId);

			// Attach the database.

			TMsvId maxId;

			iDbAdapter->AttachDBL(driveEntry.driveNum, driveId, maxId);

			// Insert the max Id in the list.

			iMaxMsvIdList.InsertL( ((maxId >= MaskTMsvId(driveId, KFirstFreeEntryId))? (maxId+1): MaskTMsvId(driveId, KFirstFreeEntryId)), driveId);

			driveId++;

			}

		iProgress.iCompleted++;

		iProgress.iRemaining--;

		}

	iFirstFreeDriveId = (driveId%8)? (driveId%8): 2;

	// Initializing remaining entries in MaxMsvId list.

	for(TInt index=driveId; index<8; index++)

		{

		iMaxMsvIdList.InsertL(NULL, index);

		}

	// For current drive fetch children of root entries also.

	RPointerArray<CMsvCacheEntry> childEntryList;

	CleanupClosePushL(childEntryList);	

	// Create root entry node in the cache. A root folder node will never 

	// be swapped out of cache. The children of root entry will be the 

	// children of root entry in the current drive.

	// Root id is masked to set the driveId in the folder node.

	iRootNode = CMsvCacheVisibleFolder::NewL(MaskTMsvId(KCurrentDriveId, KMsvRootIndexEntryId));

	iFolderListHeader.AddFirst(*iRootNode);

	iRootNode->SetComplete(ETrue);

	iDbAdapter->GetChildrenL(KMsvRootIndexEntryId, childEntryList);

	iRootNode->AddEntryListL(childEntryList, ETrue);

	childEntryList.Reset();

	// Fetch child of LocalServices.

	CMsvCacheVisibleFolder* localServiceFolder = CMsvCacheVisibleFolder::NewL(MaskTMsvId(KCurrentDriveId, KMsvLocalServiceIndexEntryId));

	iFolderListHeader.AddFirst(*localServiceFolder);

	iDbAdapter->GetChildrenL(KMsvLocalServiceIndexEntryId, childEntryList);

	localServiceFolder->AddEntryListL(childEntryList, ETrue);

	CleanupStack::PopAndDestroy(1);   //childEntryList

	// Create root entry.

	iRootEntry = iFreePoolInstance->EntryL(); //taking it from the freepool.

	iRootEntry->Entry().iType = KUidMsvRootEntry;

	iRootEntry->Entry().iDate.UniversalTime();

	iRootEntry->Entry().SetId(KMsvRootIndexEntryId);

	iRootEntry->Entry().SetParent(KErrNotFound);

	iRootEntry->Entry().SetOwner(ETrue);

	iRootEntry->Entry().iSize = 0;

	// Update progress

	iProgress.iCompleted = iProgress.iTotal;

	iProgress.iRemaining = 0;

	iProgress.iId = KMsvRootIndexEntryId;

#ifndef _NO_SERVER_LOGGING_

	iServer.Log(_L("Cache initialized succesfully."));

#endif

	iIdle = CIdle::NewL(CActive::EPriorityIdle);

	CompleteSelf();

	}

/**

GetInPreparationIds

*/

void CMsvIndexAdapter::GetInPreparationIds(CMsvEntrySelection& aSelection, TUint aDriveId /*DEFAULT = 0 */)

	{

	if(iDbAdapter)

		{

		TRAP_IGNORE(iDbAdapter->GetInPreparationIdL(aSelection, aDriveId));

		}

	}

#else		// #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

/**

 * NewL()

 * @param TFileName: DB File Name.

 * @return The newly created index adapter.

 * 

 * It returns an instance of CMsvIndexAdapter class. 

 */

CMsvIndexAdapter* CMsvIndexAdapter::NewL(CMsvServer& aServer, const TFileName& aDbFileName)

	{

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

	CleanupStack::PushL(self);

	self->ConstructNewL(aDbFileName);

	CleanupStack::Pop();

	return self;

	}

/**

 * OpenL()

 * @param TFileName: DB File Name.

 * @return The newly created index adapter.

 * 

 * It returns an instance of CMsvIndexAdapter class. 

 */

CMsvIndexAdapter* CMsvIndexAdapter::OpenL(CMsvServer& aServer, const TFileName& aDbFileName)

	{

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

	CleanupStack::PushL(self);

	self->ConstructOpenL(aDbFileName);

	CleanupStack::Pop();

	return self;

	}

/**

 * ConstructNewL()

 * 

 * The function is called from NewL().

 * 1. Check if a database with the passed name already exists.

 * 1.1. If yes, open the database.

 * 1.2. If no, create a new database with the same name.

 * 2. Creates entry cache.

 * 3. If a new database is created, create root entry also.

 */

void CMsvIndexAdapter::ConstructNewL(const TFileName& aDbFileName)

	{

#ifndef _NO_SERVER_LOGGING_

	iServer.Log(_L("Creating CMsvIndexAdapter instance..."));

#endif

	// Delete the database first, if it already exists.

	CMsvDBAdapter::DeleteDB(aDbFileName);

	// Get the instance of free pool.

	iFreePoolInstance = CMsvEntryFreePool::Instance();

	// Create the new database with the same name.

	// If this leaves, nothing can be done and let NewL() leave.

	iDbAdapter = CMsvDBAdapter::NewL(aDbFileName);

#ifndef _NO_SERVER_LOGGING_

	iServer.Log(_L("A new database %s is created..."), &aDbFileName);

#endif

	iProgress.iTotal = iProgress.iRemaining = 1; //root

	// Create root entry. 

	CreateInitialSetOfEntriesL();

#ifndef _NO_SERVER_LOGGING_

//	iServer.Log(_L("Cache initialized succesfully."));

#endif

	iNextCreateId = KFirstFreeEntryId;

	iIdle = CIdle::NewL(CActive::EPriorityIdle);

	CompleteSelf();

	}

/**

 * ConstructOpenL()

 * 

 * The function is called from NewL().

 * 1. Check if a database with the passed name already exists.

 * 1.1. If yes, open the database.

 * 1.2. If no, create a new database with the same name.

 * 2. Creates entry cache.

 * 3. If a new database is created, it then read message resource file 

 *    and creates entry as mentioned in cache and database.

 */

void CMsvIndexAdapter::ConstructOpenL(const TFileName& aDbFileName)

	{

#ifndef _NO_SERVER_LOGGING_

	iServer.Log(_L("Creating CMsvIndexAdapter instance..."));

#endif

	// Get the instance of free pool

	iFreePoolInstance = CMsvEntryFreePool::Instance();

	// Open the database.

	iDbAdapter = CMsvDBAdapter::OpenL(aDbFileName);

#ifndef _NO_SERVER_LOGGING_

	iServer.Log(_L("Opening database %s is succesful."), &aDbFileName);

#endif

	iProgress.iTotal = iProgress.iRemaining = INITIAL_NUM_ENTRIES;	

	CreateInitialCacheL();

#ifndef _NO_SERVER_LOGGING_

	iServer.Log(_L("Cache initialized succesfully."));

#endif

	TMsvId tmpNextId = NULL;

	iDbAdapter->GetMaxTMsvIdL(tmpNextId);

	iNextCreateId = (tmpNextId >= KFirstFreeEntryId)? (tmpNextId+1) : KFirstFreeEntryId;

	iIdle = CIdle::NewL(CActive::EPriorityIdle);

	CompleteSelf();

	}

/**

 * CreateInitialSetOfEntries()

 * 

 * The function is called from ConstructL(), whenever a new DB is created.

 * The function creates root entry into database and cache.

 */

void CMsvIndexAdapter::CreateInitialSetOfEntriesL()

	{

#ifndef _NO_SERVER_LOGGING_

	iServer.Log(_L("Inside CreateInitialSetOfEntriesL(): Creating standard entries for new DB."));

#endif

	// 1. Initialize the instance of free pool.

	iFreePoolInstance->SetEssentialParam(&iFolderListHeader, this);

	// 2. Creating root entry into database.

	iRootEntry = iFreePoolInstance->EntryL(); //taking it from the freepool.

	iRootEntry->Entry().iType = KUidMsvRootEntry;

	iRootEntry->Entry().iDate.UniversalTime();

	iRootEntry->Entry().SetId(KMsvRootIndexEntryId);

	iRootEntry->Entry().SetParent(KErrNotFound);

	iRootEntry->Entry().iSize = 0;

	TMsvId visibleFolderId = KMsvRootIndexEntryId;

	iDbAdapter->CreateEntryL(iRootEntry->Entry(), visibleFolderId);

	// 3. Add root entry to cache as well

	CMsvCacheVisibleFolder* rootFolder = CMsvCacheVisibleFolder::NewL(KMsvRootIndexEntryId);

	iFolderListHeader.AddFirst(*rootFolder);

	rootFolder->SetComplete(ETrue);

	// Update progress

	iProgress.iCompleted++;

	iProgress.iRemaining--;

	iProgress.iId = KMsvRootIndexEntryId;

	}

/**

 * CreateInitialCache()

 * 

 * The function is called from NewL(), whenever an existing DB is opened.

 * It creates the intial cache. It creates root entry in cache and fetches

 * child of root from DB and push them into cache. It then fetches child

 * entries of LocalServices and push them too into cache. 

 * 

 * >>>> The function can be enhanced to load children of additional folders

 * to cache along with the above standard folders. These additional folders 

 * can be mentioned by licensees in msgs.ini file.

 */

void CMsvIndexAdapter::CreateInitialCacheL()

	{

#ifndef _NO_SERVER_LOGGING_

	iServer.Log(_L("Inside CreateInitialCache(): Initializing Cache."));

#endif

	//1. Initialize the instance of free pool.

	iFreePoolInstance->SetEssentialParam(&iFolderListHeader, this);

	// 2. Add root entry to cache.

	CMsvCacheVisibleFolder* rootFolder = CMsvCacheVisibleFolder::NewL(KMsvRootIndexEntryId);

	iFolderListHeader.AddFirst(*rootFolder);

	// 2.1 Update progress

	iProgress.iCompleted++;

	iProgress.iRemaining--;

	iProgress.iId = KMsvRootIndexEntryId;

	// 3. Fetch child of root entries from DB.

	RPointerArray<CMsvCacheEntry> childrenOfRoot;

	iDbAdapter->GetChildrenL(KMsvRootIndexEntryId, childrenOfRoot);

	// 3.1 Get the root entry from DB.

	CMsvCacheEntry *rootEntry = NULL;

	TMsvId visibleFolder = NULL;

	iDbAdapter->GetEntryL(KMsvRootIndexEntryId, rootEntry, visibleFolder);

	// 3.2 Copy the TMsvEntry of root from CMsvCacheEntry.

	//Mem::Copy(&iRootEntry->Entry(), &rootEntry->Entry(), sizeof(TMsvEntry));

	iRootEntry = rootEntry;

	// 3.3 Release the cache entry back to the freepool.