// 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 <msvsearchsortoperation.h>

#include <msvuids.h>

#include "msvsearchsortoponheaderbody.h"

/** 

Allocates and constructs a CMsvSearchSortOperation object.

@param aMsvSession: The client’s Message Server session 

@return If the function succeeds, this is a pointer to a newly allocated 

and initialised object. 

@leave KErrNotFound The requested entry does not exist 

@leave KErrNoMemory A memory allocation failed 

*/

EXPORT_C CMsvSearchSortOperation* CMsvSearchSortOperation::NewL(CMsvSession& aMsvSession)

	{

	CMsvSearchSortOperation* self = new(ELeave) CMsvSearchSortOperation(aMsvSession);

	CleanupStack::PushL(self);

	self->ConstructL(aMsvSession);

	CleanupStack::Pop();

	return self;

	}

/**

Second phase construction

*/

void CMsvSearchSortOperation::ConstructL(CMsvSession& aMsvSession)

	{

	iHeaderBodySearch = CMsvSearchsortOpOnHeaderBody::NewL(aMsvSession, EPriorityStandard);

	CActiveScheduler::Add(this);

	}

/**

CMsvSearchSortOperation Constructor

@param aMsvSession: The client’s Message Server session 

*/

CMsvSearchSortOperation::CMsvSearchSortOperation(CMsvSession& aMsvSession) : CActive(EPriorityStandard), iMsvSession(aMsvSession)

	{

	iOpId = iMsvSession.OperationId();

	}

/** 

Destructor.

*/

EXPORT_C CMsvSearchSortOperation::~CMsvSearchSortOperation()

	{

	Cancel();

	delete iHeaderBodySearch;

	delete iQuery;

	iIdArray.Close();

	iEntryArray.Close();

	iTMsvIdWithSortField.Close();

	}

/**

Search-sort operation is performed on a specified folder (e.g, on INBOX, 

SENT-ITEMS, DRAFT, OUTBOX or any user created folder).

@param aQuery: A search-sort query object with search-sort options. 

The ownership of this pointer is passed to CMsvSearchSortOperation

@param aMarkQuery:Marks the query to indicate the framework to store this 

query in the internal search-sort cache for future use.  The queries are 

stored by default in the search-sort cache, but they are disposed when 

the cache reaches a maximum limit to accommodate the fresh query in the cache. 

The marked queries are less preferred to be disposed from the cache than the 

queries which are not marked during such a cache full condition unless all 

the queries in the cache are marked.

@param aQueryStatus: Provides the status of the asynchronous operation

@param aIterator: The number of result values to be returned at a time. 

By default the value is zero which indicates the results are expected in chunk 

and not using iterative mechanism. Currently the only other value this parameter can have is '1', due to limitation from SQLite.

@leave If iterator count is morethan one, it will with leave with KErrArgument

@return: None

*/	

EXPORT_C void CMsvSearchSortOperation::RequestL(CMsvSearchSortQuery* aQuery, TBool aMarkQuery, TRequestStatus& aQueryStatus, TInt aIterator)	

	{

	//Validate aQuery object

	if(aQuery->GetMaxQuerySize() <= 0)

		{

		//whether is it a sort query

		if(aQuery->iCountMultilevelSort <= 0)

			{

			//aQuery object doesn't contains any query fields to search/sort, so delete CMsvSearchSortQuery object.

			delete aQuery;

			User::Leave(KErrArgument);

			}

		}	

	/** 

	 For enabling the Iterator: aIterator value should be 1, 

	 if aIterator value is 0, then there is no Iterator mechanisam.

	 If iterator count is morethan one, it will with leave with KErrArgument.

	 */

	if(aIterator > 1)

		{

		delete aQuery;

		User::Leave(KErrArgument);

		}

	//Iterator is not supported for Header and/or Body or Combined (Header and/or Body and TMsvEntry) Query.

	//Do query validation when aIterator value is equal to one. 

	if(aIterator == 1)

		{

		TInt error = ValidateQueryString(aQuery);

		if(error != KErrNone)

			{

			delete aQuery;

			User::LeaveIfError(error);

			}

		}

	//If aQuery is a sort query, then sorting in subfolder is not supported

	CheckWhetherSubFolderOptionIsEnabledForSortQueryL(aQuery);

	ConstructSearchSortOperation(aQuery, aMarkQuery, aQueryStatus, aIterator);

	SendRequestL();

	}

/**

Getting Search-sort results for  specified QueryId.  

@param aQueryId: A unique 32 bit integer value associated with a query which is 

already executed ones in the past and which is assumed to be present in the 

search-sort cache.

@param aQueryStatus: Provides the status of the asynchronous operation

@param aIterator: Whether client requested results in Iterator

@leave If iterator count is morethan one, it will with leave with KErrArgument

@return: None

*/	

EXPORT_C void CMsvSearchSortOperation::RequestL(TInt aQueryId, TRequestStatus& aQueryStatus, TInt aIterator)

	{

	/* For enabling the Iterator: aIterator value should be 1, 

	 * if aIterator value is 0, then there is no Iterator mechanisam.

	 * If iterator count is morethan one, it will with leave with KErrArgument.

	 */

	if(aIterator > 1)

		{

		User::Leave(KErrArgument);

		}

	ConstructSearchSortOperation(aQueryId, aQueryStatus, aIterator);

	SendRequestL();	

	}

/** 

After the completion of asynchronous function RequestL(), this function provides 

the query Id corresponding to a particular search-sort query.

@param None

@return A unique integer query Id which can be used later to refer to the same 

search-sort query.

@leave KErrRequestPending if the asynchronous function RequestL() is not yet completed. 

*/

EXPORT_C TInt CMsvSearchSortOperation::GetQueryIdL()

	{

	//send query id to client

	iMsvSession.Session().GetSearchSortRequestQueryIdL(iQueryId);

	return iQueryId;

	}

/**

Unmarks the query listed in search-sort cache. The unmarked queries are preferred 

over marked queries for being disposed from the search-sort cache when the 

search-sort cache reaches a maximum limit

@param aQueryId: An unique queryId  associated with a query in search-sort cache. 

The query will be considered for being disposed off the search-sort cache when 

the search-sort cache reaches the maximum limit. The query will be actually 

disposed if it was unmarked, sometime in future when there is not enough space 

to store the newer query in the cache.

@leave KErrNotFound The requested queryId does not exist 

*/

EXPORT_C TInt CMsvSearchSortOperation::UnmarkQuery (const TInt aQueryId)

	{

	//unmark the query id

	TRAPD(error, iMsvSession.Session().UnmarkSearchSortRequestQueryIdL(aQueryId));

	return error;

	}

/** 

Returns the count of search-sort results, without returning the actual 

search-sort results.

@param None

@return The count of search-sort results

*/

EXPORT_C TInt CMsvSearchSortOperation::GetResultCountL()

	{

	if(*iObserverRequestStatus == KRequestPending)

		{

		User::Leave(KRequestPending);

		}

	iMsvSession.Session().GetResultCountL(iCount);

	return iCount;

	}

/**

After the completion of asynchronous function RequestL(), this function provides 

a list of index entry Id objects (TMsvId). 

@param aMsvIdList: output parameter containing the list of index entry Id objects 

which are the result of search-sort operation.

@return KErrRequestPending - GetResults() function is called before the completion 

of asynchronous function, else KErrNone.

@leave  KErrMsvInvalidResultRequest - If the result type requested during execution 

of query was set to TMsvEntry, but the messaging client is trying to receive TMsvId 

objects

*/

EXPORT_C TInt CMsvSearchSortOperation::GetResultsL (RArray<TMsvId>& aMsvIdList)

	{

	if(*iObserverRequestStatus == KRequestPending)

		{

		return KRequestPending;

		}

	if ((iResultType != EMsvResultAsTMsvId) && (iIterator != 0))

		{

		User::Leave(KErrMsvInvalidResultRequest);

		}

	TInt count = iIdArray.Count();

	for(TInt index = 0; index < count; ++index)

		{

		aMsvIdList.AppendL(iIdArray[index]);

		}

	return KErrNone;

	}

/** 

After the completion of asynchronous function RequestL(), this function provides 

a list of index entry objects (TMsvEntry).

@param aMsvEntryList: output parameter containing the list of index entry objects 

which are the result of search-sort operation.

@return KErrRequestPending - GetResults() function is called before the completion 

of asynchronous function, else KErrNone.

@leave  KErrMsvInvalidResultRequest - If the result type requested during execution 

of query was set to TMsvEntry, but the messaging client is trying to receive TMsvId 

objects

*/

EXPORT_C TInt CMsvSearchSortOperation::GetResultsL (RArray<TMsvEntry>& aMsvEntryList)

	{

	if(*iObserverRequestStatus == KRequestPending)

		{

		return KRequestPending;

		}

	if((iResultType != EMsvResultAsTMsvEntry) && (iIterator != 0))

		{

		User::Leave(KErrMsvInvalidResultRequest);

		}

	TInt count = iEntryArray.Count();

	for(TInt index = 0; index < count; ++index)

		{

		aMsvEntryList.AppendL(iEntryArray[index]);

		}

	return KErrNone;	

	}

/** 

Gets the TMsvId of a single index entry object at a time. This function is used 

when getting the results using iterative mechanism.

@param aTMsvId:  A reference of index entry Id of the index entry, which is one 

of the results of search-sort operation. All the TMsvId objects could be received 

one after the other using this function.

@return  Count of remaining search-sort results

*/

EXPORT_C TInt CMsvSearchSortOperation::GetNextResultL(TMsvId& aTMsvId)

	{

	if(*iObserverRequestStatus == KRequestPending)

		{

		return KRequestPending;

		}

	if ((iResultType != EMsvResultAsTMsvId) && (iIterator != 1))

		{

		User::Leave(KErrMsvInvalidResultRequest);

		}

	iMsvSession.Session().GetNextIdL(aTMsvId, iCount);

	return iCount;

	}

/** 

Gets one index entry object at a time. This function is used when getting the results 

using iterative mechanism.

@param aTMsvId: next result as TMsvEntry 

@return Count of remaining search-sort results

*/

EXPORT_C TInt CMsvSearchSortOperation::GetNextResultL(TMsvEntry& aTMsvEntry)

	{

	if(*iObserverRequestStatus == KRequestPending)

		{

		return KRequestPending;

		}

	if((iResultType != EMsvResultAsTMsvEntry) && (iIterator != 1))

		{

		User::Leave(KErrMsvInvalidResultRequest);

		}

	iMsvSession.Session().GetNextEntryL(aTMsvEntry, iCount);

	return iCount;

	}	

/** 

Returns progress information on the current search-sort request.

@return The progress information on an asynchronous search-sort operation.

@leave  

*/

EXPORT_C TInt CMsvSearchSortOperation::ProgressL()

	{

	iOperationProgress = KMsvSearchSortOpNone;

	if(*iObserverRequestStatus == KRequestPending)

		{

		iMsvSession.Session().SearchSortOperationProgressL(OpId(), iOperationProgress);

		return iOperationProgress;

		}

	return iOperationProgress;

	}

// Requet is SearchSort Query 	

void CMsvSearchSortOperation::ConstructSearchSortOperation(CMsvSearchSortQuery* aQuery, TBool aMarkQuery, TRequestStatus& aQueryStatus, TInt aIterator)

	{

	iQuery = aQuery;

	iMarkQuery = aMarkQuery;

	iIterator = aIterator;

	iObserverRequestStatus = &aQueryStatus;

	iResultType = iQuery->GetResultType();

	if(iIterator == 1)

		{

		SetRequestType(EMsvSearchSortQuery, EMsvReqWithIterator);

		}

	else

		{

		SetRequestType(EMsvSearchSortQuery, EMsvReqWithoutIterator);

		}

	}

// Requet is SearchSort QueryId

void CMsvSearchSortOperation::ConstructSearchSortOperation(TInt aQueryId, TRequestStatus& aQueryStatus, TInt aIterator)

	{

	iQueryId = aQueryId;

	iIterator = aIterator;

	iObserverRequestStatus = &aQueryStatus;

	iIsQueryIdRequest = ETrue;

	if(iIterator == 1)

		{

		SetRequestType(EMsvQueryId, EMsvReqWithIterator);

		}

	else

		{

		SetRequestType(EMsvQueryId, EMsvReqWithoutIterator);

		}

	}

// send a request to server according to the Request given by client

void CMsvSearchSortOperation::SendRequestL()

	{

	switch(iReqType)

		{

		case EMsvSearchSortQuery:

			//search and sort both are TMsvEntry fields 

			//or sort query only on TMsvEntry fields (sort query)

			if (IsSearchOnlyOnEntry() || IsSortOnlyOnEntry())

				{

				iIsSearchSortOnIndexEntry = ETrue;

				iMsvSession.Session().SearchSortRequestOnEntryL(iQuery, OpId(), iMarkQuery, iIterator, iStatus);

				}

			else

				{

				// Iterator is not supported for Header and/or Body or Combination of Header and/or Body with TMsvEntry fields.

				iIsSearchSortOnIndexEntry = EFalse;

				iMsvSession.Session().SearchSortRequestOnHeaderBodyL(iQuery, OpId(), iMarkQuery, iStatus);	

				}

			break;

		case EMsvQueryId:

			// send request to server to get resuls from this query id. 

			iMsvSession.Session().GetResultsForQueryId(iQueryId, OpId(), iIterator, iStatus);

			break;

		}

	// setActive

	DoSetActive();

	}

// do setActive

void CMsvSearchSortOperation::DoSetActive()

	{

	*iObserverRequestStatus = KRequestPending;

	SetActive();

	}

void CMsvSearchSortOperation::RunL()

	{

	TInt error = iStatus.Int();

	//do process

	if(error == KErrNone)

		{

		TRAP(error, DoRunL());

		}

	//complete with error	

	if(error != KErrNone)

		{

		//KErrNotFound comes when results are zero for a query, completed with KErrNone, 

		//so that client can show '0' results found

		if(error == KErrNotFound)

			{

			error = KErrNone;

			}

		//KErrUnknown comes when query id doesn't exist, so completing with KErrNotFound

		if(error == KErrUnknown)

			{

			error = KErrNotFound;

			}

		DoComplete(error);

		}

	}

void CMsvSearchSortOperation::DoRunL()

	{

	switch(iReqType)

		{

	case EMsvSearchSortQuery:

		{

		ProcessSearchSortQueryL();

		}

		break;

	case EMsvQueryId:

		{

		ProcessSearchSortUsingQueryIdL();

		}

		break;

	case EMsvSearchSortOnHeaderBody:

		{

		ProcessSearchSortOnHeaderBodyL();

		}

		break;

	case EMsvGetEntryForIds:

		{

		iEntryArray.Reset();

		iHeaderBodySearch->GetResultAsTmsvEntryL(iEntryArray);

		Complete();

		}

		break;

	default:

		break;

		}

	}

void CMsvSearchSortOperation::ProcessSearchSortQueryL()

	{

	if(iIsSearchSortOnIndexEntry)

		{

		DoPorcessOnEntryResultsL();

		} 

	else // seraching on Header and/or Body

		{

		/**

		If search query on Header and/or Body or combined (TMsvEntry and Header and/or Body) query

		call GetResultAsIdL(iIdArray, resultStatus), 

		from the resultStatus, will come to know the ResultType

		i) final result (complete results from cache)

		ii) partial result (cache results + delat cache entries)

		iii) It's new search for all id's

		Iterator is not supported for Header and/or Body search

		*/

		iIdArray.Reset();

		iMsvSession.Session().GetResultAsIdL(iIdArray, iResultStatus);

		switch(iResultStatus)

			{

		case KFinalResult:

			{

			CheckIsArrayEmptyL(iIdArray);

			if (iQuery->GetResultType() == EMsvResultAsTMsvEntry)

				{

				iReqType = EMsvGetEntryForIds;

				iHeaderBodySearch->DoGetEntryForAllIdL(iIdArray, iStatus);

				DoSetActive();

				}

			else

				{

				Complete();	

				}

			}

			break;