// Copyright (c) 2006-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 <cntdb.h>

#include "pbapfoldernodepb.h"
#include "pbaprequest.h"
#include "pbapfolderclient.h"
#include "pbapexporter.h"
#include "pbaperrorreporter.h"
#include "pbapserver.h"
#include "pbapappheader.h"

#include "btaccesshostlog.h"

// constants
_LIT(KFolderPb, "pb");


/*static*/ CFolderNodePb* CFolderNodePb::NewL(MVirtualFolderClient& aClient)
	{
	LOG_STATIC_FUNC
	CFolderNodePb* self = new (ELeave) CFolderNodePb(aClient);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}


CFolderNodePb::CFolderNodePb(MVirtualFolderClient& aClient)
: CFolderNode(aClient, KFolderPb())
	{
	LOG_FUNC
	}

		
void CFolderNodePb::ConstructL()
	{
	LOG_FUNC
	iHandleCache = CPbapPbHandleCache::NewL(iClient.ContactDB(), *this);
	}


CFolderNodePb::~CFolderNodePb()
	{
	LOG_FUNC

	delete iHandleCache;
	delete iAsyncExporter;		
	delete iSearchResults;
	iCacheIndexesToExport.Close();
	}
	
	
void CFolderNodePb::CancelGet()
	{
	LOG_FUNC
	// cancel asynchronous searching and sorting of contacts
	iClient.ContactDbViews().CancelSearchAndSortRequest();
	
	// cancel any asynchronous export operations and avoid iAsyncExporter is deleted
	// by itself
	CPbapPbExporter* tmpExporter = iAsyncExporter;
	iAsyncExporter = NULL;
	delete tmpExporter;
	
	// reset for next get request
	Reset();
	}

void CFolderNodePb::GetComplete()
	{
	LOG_FUNC
	
	if (iAsyncExporter)
		{
		delete iAsyncExporter;
		iAsyncExporter = NULL;
		}
	}


 void CFolderNodePb::Reset()
 	{
 	LOG_FUNC
	
 	delete 	iSearchResults;
	iSearchResults = NULL;
 
	delete iAppHeader;
	iAppHeader = NULL;
	
	iCacheIndexesToExport.Reset();	
 	}
 
 				
TInt CFolderNodePb::DoGetItem(TInt aHandle)
	{
	LOG_FUNC
	// check that state has been reset after previous get request
	if(iAsyncExporter)
		{
		__ASSERT_DEBUG(EFalse, Panic(EVirtualFolderPbExportAlreadyExists));
		return KErrAlreadyExists;
		}

	TInt error = KErrNone;
	TInt index = 0;
				
	if (iPhonebookChanged)
		{
		// the Pb phonebook has been modified since the last get request
		// report precondition failed error to obex until next listing
		// request completes (or new Pbap session initiated)
		iClient.ErrorReporter().SendPreconditionFailedError();
		// error already reported above so don't update error
		
		delete iAppHeader;
		iAppHeader = NULL;
		}
	// search for the requested handle in the cache
	else if ((index = iHandleCache->FindHandle(aHandle)) != KErrNotFound)
		{
		// export the contact associated with this handle
		TRAP(error, iAsyncExporter = CPbapPbItemExporter::NewL(iClient, *this, *iHandleCache, index, 1, iAppHeader->VCardVersion(), iAppHeader->Filter()));
		}
	else 
		{
		// the handle does not exist must report not found error to Obex
		iClient.ErrorReporter().SendNotFoundError();
		// error already reported above so don't update error
		
		delete iAppHeader;
		iAppHeader = NULL;
		}
	return error;
	}


TInt CFolderNodePb::DoGetListing()
	{
	LOG_FUNC
	
	TInt error = KErrNone;	
	if (iAppHeader->SearchValue().Length() || iAppHeader->Order() != SymbianPBAP::EIndexed)
		{
		// search or non-indexed sort requested
		TRAP(error, SearchAndSortItemsL());
		}
	else
		{
		// the order is indexed and no search was requested so export listing now
		TRAP(error, ExportIndexSortedListingL());
		}
	
	if (error != KErrNone)
		{
		// error occurred so reset state ready for next get request
		Reset();
		}
	return error;	
	}


/**
 Use database views to search and sort contacts
*/
void CFolderNodePb::SearchAndSortItemsL()
	{
	LOG_FUNC
	if(iSearchResults)
		{
		__ASSERT_DEBUG(EFalse, Panic(EVirtualFolderSearchInProgress));
		User::Leave(KErrAlreadyExists);
		}
	
	// The views only support alphabetical and phonetic sort orders so for index ordered
	// searches use alphabetical order and then resort the results when search complete			
	SymbianPBAP::TOrder order = (iAppHeader->Order() == SymbianPBAP::EIndexed ? SymbianPBAP::EAlphabetical : iAppHeader->Order());

	// create empty array to store results
	iSearchResults = CContactIdArray::NewL();
				
	// start the asynchronous search and sort				
	iClient.ContactDbViews().GetContactIdsMatchingCriteriaL(order, iAppHeader->SearchAttribute(), iAppHeader->SearchValue(), *iSearchResults, *this);
	}


void CFolderNodePb::ExportIndexSortedListingL()
	{
	LOG_FUNC
	// check that state has been reset after previous get request
	if(iAsyncExporter)
		{
		__ASSERT_DEBUG(EFalse, Panic(EVirtualFolderPbExportAlreadyExists));
		User::Leave(KErrAlreadyExists);
		}
	
	if(iCacheIndexesToExport.Count() != 0)
		{
		__ASSERT_DEBUG(EFalse, Panic(EVirtualFolderCachedIndexes));
		User::Leave(KErrAlreadyExists);
		}
	
	// build an array of indexes to cache items (handle/contact Id pairs) to export.
	// Since the cache is ordered on handle the indexes match the ordering of the cache

	// determine the last handle to export and then start the append loop from iListStartOffset
	TInt maxHandle = Min(iAppHeader->MaxListCount() + iAppHeader->ListStartOffset(), HandleCount());
	for (TInt index = iAppHeader->ListStartOffset(); index < maxHandle; ++index)
		{
		iCacheIndexesToExport.AppendL(index);
		}
			
	// export array of cache items as listing
	iAsyncExporter = CPbapPbListingExporter::NewL(iClient, *this, *iHandleCache, iCacheIndexesToExport);
	}


TInt CFolderNodePb::DoGetCount()
	{
	LOG_FUNC
	// check that state has been reset correctly
	if(iAsyncExporter)
		{
		__ASSERT_DEBUG(EFalse, Panic(EVirtualFolderPbExportAlreadyExists));
		return KErrAlreadyExists;
		}
	
	// export the Pb phonebook size. This is equal to the number of handles in the
	// cache (assuming that 0.vcf is always counted even if no owner card is set)
	TRAPD(error, iAsyncExporter = CPbapPbCountExporter::NewL(iClient, *this, HandleCount()));
	return error;
	}


TInt CFolderNodePb::DoGetFolder()
	{
	LOG_FUNC
	// check that state has been reset correctly
	if(iAsyncExporter)
		{
		__ASSERT_DEBUG(EFalse, Panic(EVirtualFolderPbExportAlreadyExists));
		return KErrAlreadyExists;
		}
	
	// setup range of items to export
	TInt count = 0;
	if (iAppHeader->ListStartOffset() < HandleCount())
		{
		// limit the number of items to export to the number of handles available from
		// the offset
		count = Min(iAppHeader->MaxListCount(), HandleCount() - iAppHeader->ListStartOffset());
		}
				
	// export the contacts associated with range of handle cache indexes (these
	// are aleady sorted in increasing handle order)
	TRAPD(error, iAsyncExporter = CPbapPbItemExporter::NewL(iClient, *this, *iHandleCache, iAppHeader->ListStartOffset(), count, iAppHeader->VCardVersion(), iAppHeader->Filter()));
	return error;
	}


void CFolderNodePb::HandleCacheChanged()
	{
	LOG_FUNC
		
	// the contact item a handle refers to has changed. All PullvCard requests will
	// now be blocked until the next listing request (or session close)
	iPhonebookChanged = ETrue;
	// check to see if there is an export in progress
	if (iSearchResults || iAsyncExporter)
	
		{
		// cancel the export and report error according to the error reporting
		// scheme for modified/deleted handles
		CancelGet();
		}
	}


void CFolderNodePb::HandleSearchAndSortComplete(TInt aError)
	{
	LOG_FUNC
	
	if (aError == KErrNone)
		{
		// sorting and searching completed successfully
		TRAP(aError, ExportSearchAndSortResultsL());
		}
	
	if (aError != KErrNone)
		{
		// get request failed report error to obex and reset
		iClient.ErrorReporter().SendServiceUnavailableError();
		Reset();
		}
	}


void CFolderNodePb::ExportSearchAndSortResultsL()
	{
	LOG_FUNC	
	
	// check that state has been reset after previous get request
	if(iAsyncExporter)
		{
		__ASSERT_DEBUG(EFalse, Panic(EVirtualFolderPbExportAlreadyExists));
		User::Leave(KErrAlreadyExists);
		}
	if(iCacheIndexesToExport.Count() != 0)
		{
		__ASSERT_DEBUG(EFalse, Panic(EVirtualFolderCachedIndexes));
		User::Leave(KErrAlreadyExists);
		}

	TInt count = iSearchResults->Count();
	
	// if the order is indexed then to get here means that a search value has been specified
	if (iAppHeader->Order() == SymbianPBAP::EIndexed)
		{
		// sort the search result into index order
		RArray<TInt> sortedIndexes;
		CleanupClosePushL(sortedIndexes);
		for (TInt ii = 0; ii < count; ++ii)
			{
			TContactItemId contactId = (*iSearchResults)[ii];
			TInt index = iHandleCache->FindContactId(contactId);
			if (index != KErrNotFound)
				{
				// insert index in order to match handle ordering of cache
				sortedIndexes.InsertInOrderL(index);
				}
			}
		
		// results array no longer required
		delete iSearchResults;
		iSearchResults = NULL;
		
		// extract range of cache indexes to export
		count = Min(iAppHeader->MaxListCount() + iAppHeader->ListStartOffset(), sortedIndexes.Count());		
		for (TInt jj = iAppHeader->ListStartOffset(); jj < count; ++jj)
			{
			iCacheIndexesToExport.AppendL(sortedIndexes[jj]);
			}
		CleanupStack::PopAndDestroy(); // sortedIndexes	
		}
	// to get here means it's a non-index order sort or search
	else
		{
		// the search results array is sorted in the correct (alphabetic or
		// phonetic) order. Build array of indexes of cache items which match the
		// contact ids 
		TInt maxAndOffset = iAppHeader->MaxListCount() + iAppHeader->ListStartOffset();
		count = Min(count, maxAndOffset);
		
		// decide whether there is a OwnCard
		TBool hasOwnCard = ETrue;
		TInt ownCardItemIndex = iHandleCache->FindHandle(KOwnCardHandle); // always present
		TContactItemId contactId = iHandleCache->ContactIdAtL(ownCardItemIndex);
		if(contactId == KNullContactId)
			{
			hasOwnCard = EFalse;
			}

		// fill the array iCacheIndexsToExport
		for (TInt ii = iAppHeader->ListStartOffset(); ii < count; ++ii)
			{
			TContactItemId contactId = (*iSearchResults)[ii];
			TInt index = iHandleCache->FindContactId(contactId);
			if (index!=KErrNotFound)
				{
				iCacheIndexesToExport.AppendL(index);
				}
			}

		// append an empty own card (0.vcf) when doing sorting on alphabetic or phonetic order
		// search value should be empty when doing sorting
		if(iAppHeader->SearchValue().Size() == 0 && !hasOwnCard)
			{
			// "count < maxAndOffset" means that 
			// "iSearchResults->Count()" < "iAppHeader->MaxListCount() + iAppHeader->ListStartOffset()" 
			// in which case, we need to append an empty OwnCard entry to iCacheIndexesToExport.
			if(count < maxAndOffset)
				{
				iCacheIndexesToExport.AppendL(KOwnCardHandle);
				}
			}
		// results array no longer required
		delete iSearchResults;
		iSearchResults = NULL;			
		}
		
	// export items associated with list of handle cache indexes
	iAsyncExporter = CPbapPbListingExporter::NewL(iClient, *this, *iHandleCache, iCacheIndexesToExport);
	}


 void CFolderNodePb::HandleExportComplete(TInt aError)
 	{
 	LOG_FUNC
 		
 	if (aError)
 		{
 		if(iPhonebookChanged)
 			{
	 		iClient.ErrorReporter().SendPreconditionFailedError();
 			}
 		else
 			{
	 		// error occured during export report service unavailable error to obex 
	 		iClient.ErrorReporter().SendServiceUnavailableError();
 			}
 		}
 	
 	// a successful listing request allows the pb phonebook to be read from again
 	// after it has been modified
 	if (aError == KErrNone && iAppHeader->Operation() == EPullVCardListing)
 		{
 		iPhonebookChanged = EFalse;
 		}
 		
 	// get request complete	so reset state ready for next one
 	Reset();
 	}


 TInt CFolderNodePb::HandleCount()
 	{
 	return iHandleCache->Count();
 	}