// 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:

//

#include <msventry.h>

#include <offop.h>

#include "POPSOFFL.H"

#include "popstran.h"

#include "POPS.PAN"

// API

// ===

// The CImPop3OfflineOperationFinder class is used to find and order offline

// operations. It can also be used to obtain progress information eg. the

// number of operations queued of a particular type.

// Offline operations are retrieved by first calling the asynchronous

// FindFirstL function. After completetion call the OperationFound function

// to find out whether or not an offline operation has been found, if it has

// then the OfflineOperation function should be called to retrive it.

//

// The FindNextL function should be called to find other offline operations

// (in conjunction with the OperationFound and OfflineOperations functions.)

// It should be noted that the FindNextL function is synchronous.

// The DeleteCurrentOperationL() function deletes the current entry from the

// message store.

// OperationDetails returns TOperationDetails which can be used for providing

// progress information.

// Implementaiton

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

// The asynchronous FindFirstL function builds up a list of

// CImOffLineOperationArray objects, each array holds a list of operations

// of a particular type.

// The operations are stored this way to facilitate easy ordering based on

// operation type as well as being useful for generating progress

// information.

// The operations are retrieved by first visiting each message under the

// service, this potentially slow operation is handled by the asynchronous

// function.

CImPop3OfflineOperationFinder* CImPop3OfflineOperationFinder::NewL(CMsvServerEntry& aEntry)

	{

	CImPop3OfflineOperationFinder* self = NewLC(aEntry);

	CleanupStack::Pop(); // self

	return self;

	}

CImPop3OfflineOperationFinder* CImPop3OfflineOperationFinder::NewLC(CMsvServerEntry& aEntry)

	{

	CImPop3OfflineOperationFinder* self = new (ELeave) CImPop3OfflineOperationFinder(aEntry);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CImPop3OfflineOperationFinder::FindFirstL(TMsvId aServiceId, TBool aQuitting, TRequestStatus &aStatus)

// Asynchronous function for finding all the offline operations and setting

// the current operation (iOperationArrayIndex and iOperationIndex) to point

// to the first one.

// Use OperationFound(), OfflineOperation() and OperationDetails() to access

// the results of this search.

	{

	TInt index = 0;

	// Delete each of the CImOffLineOperationArrays

	while (index < iOfflineOperations->Count())

		{

		delete (*iOfflineOperations)[index];

		index++;

		}

	iOfflineOperations->Reset();

	iServiceId = aServiceId;

	iState = EPopsOffOpLookingForMessages;

	iQuitting = aQuitting;

	if (iChildMessages)

		{

		delete iChildMessages;

		iChildMessages = 0;

		}

	iChildMessages = new (ELeave) CMsvEntrySelection();

	User::LeaveIfError(iEntry.GetChildren(*iChildMessages));

	iMessageIndex = 0;

	Queue(aStatus);

	if (iChildMessages->Count())

		{

		// Check the first message for offline operations.

		CheckNextChildMessageL();

		}

	else

		{

		// There are no messages found so complete and stop searching here.

		delete iChildMessages;

		iChildMessages = 0;

		Complete(KErrNone);

		}

	}

void CImPop3OfflineOperationFinder::CheckNextChildMessageL()

// Check the current message (iMessageIndex) and append any offline operations

// to the offline operations list.

	{

	if (iMessageIndex < iChildMessages->Count())

		{

		iEntry.SetEntry((*iChildMessages)[iMessageIndex]);

		TMsvEmailEntry entry = iEntry.Entry();

		if (entry.DisconnectedOperation() != ENoDisconnectedOperations)

			// If the entry has offline operations queued then add it to the list.

			{

			AppendOfflineOpsL();

			}

		}

	SetActive();

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

	}

void CImPop3OfflineOperationFinder::AppendOfflineOpsL()

// This private help function appends the offline operations associated with the

// current message to the appropriate offline operations array.

// The array to which it is added depends on the operation type. If there

// is currently no array for this operation type then one is created.

	{

	// Get the offline operations for the current message.

	CImOffLineOperationArray* localOfflineOpArray = CImOffLineOperationArray::NewL();

	CleanupStack::PushL(localOfflineOpArray);

	CImOffLineArrayStore* offlineArrayStore = new (ELeave) CImOffLineArrayStore(*localOfflineOpArray);

	CleanupStack::PushL(offlineArrayStore);

	CMsvStore* messageStore = iEntry.ReadStoreL();

	CleanupStack::PushL(messageStore);

	offlineArrayStore->RestoreL(*messageStore);

	// Append the local offline operations to the correct operations list.

	TInt opCounter;

	TInt offlineOps = localOfflineOpArray->CountOperations();

	const CImOffLineOperation* newOperation;

	for (opCounter = 0; opCounter < offlineOps; opCounter++)

		{

		newOperation = &localOfflineOpArray->Operation(opCounter);

		// Append newOperation to the correct list as each list holds a different operation type.

		// Find the appropriate offline operation list.

		CImOffLineOperationArray* operationArray = 0;

		if (iOfflineOperations->Count() == 0)

			{

			// If there are no arrays then create the first one.

			operationArray = CImOffLineOperationArray::NewL();

			CleanupStack::PushL(operationArray);

			iOfflineOperations->AppendL(operationArray, sizeof(void*));

			CleanupStack::Pop(operationArray);

			}

		else

			{

			TBool found = EFalse;

			TInt index = 0;

			// Search the different arrays for one that contains the correct operation types.

			while ((!found) && (index < iOfflineOperations->Count()))

				{

				if ((*iOfflineOperations)[index]->CountOperations())

					{

					if (((*iOfflineOperations)[index]->Operation(0)).OpType() == newOperation->OpType())

						{

						found = ETrue;

						operationArray = (*iOfflineOperations)[index];

						}

					}

				index++;

				}

			if (!found)

				{

				// If there are no appropriate arrays then create a new one.

				operationArray = CImOffLineOperationArray::NewL();

				CleanupStack::PushL(operationArray);

				iOfflineOperations->AppendL(operationArray, sizeof(void*));

				CleanupStack::Pop(operationArray);

				}

			}

		operationArray->AppendOperationL(*newOperation);

		}

	CleanupStack::PopAndDestroy(3); // offlineArrayStore, messageStore, localOfflineOperationArray

	}

TBool CImPop3OfflineOperationFinder::AppropriateOperation(const CImOffLineOperation& aOperation) const

	{

// Returns true if the operation should be run at this point.

// Delete operations should be run at the end of the session, all others at the start.

	return (aOperation.OpType()==CImOffLineOperation::EOffLineOpDelete) ? iQuitting : (!iQuitting);

	}

void CImPop3OfflineOperationFinder::FindNext()

// Finds the next offline operations.

// The results of this function call are valid as soon as the function returns.

	{

	TBool go = ETrue;

	CImOffLineOperationArray* operationArray = 0;

	iOperationIndex++;

	while (go)

		{

		go = ETrue;

		if (iOfflineOperations->Count())

			{

			operationArray = (*iOfflineOperations)[iOperationArrayIndex];

			}

		else

			{

			operationArray = 0;

			}

		if (operationArray == 0)

			{

			go = EFalse;

			}

		else if (iOperationIndex == operationArray->CountOperations())

		// If there are no more operations in this array then move on to the next one.

			{

			iOperationArrayIndex++;

			iOperationIndex = 0;

			}

		else if (!AppropriateOperation(operationArray->Operation(0)))

		// If the operations in this array aren't of an appropriate type then move on to the next one.

			{

			iOperationArrayIndex++;

			iOperationIndex = 0;

			}

		else

		// An appropriate operation has been found.

			{

			go = EFalse;

			}

		if (iOperationArrayIndex == iOfflineOperations->Count())

		// If there are no more operation arrays then don't carry on looking.

			{

			go = EFalse;

			}

		}

	// Set the operaitons details for later.

	if (OperationFound())

		{

		iOperationDetails.iOpType = OfflineOperation().OpType();

		iOperationDetails.iOperationNumber = iOperationIndex;

		iOperationDetails.iOperationsOfType = ((*iOfflineOperations)[iOperationArrayIndex])->CountOperations();

		}

	else

		{

		iOperationDetails.iOpType = CImOffLineOperation::EOffLineOpNone;

		}

	}

TBool CImPop3OfflineOperationFinder::OperationFound() const

// Returns true if an operation has been found.

	{

	return (iOperationArrayIndex < (iOfflineOperations->Count()));

	}

const CImOffLineOperation& CImPop3OfflineOperationFinder::OfflineOperation() const

// Returns the current offline operations.

	{

	return ((*iOfflineOperations)[iOperationArrayIndex])->Operation(iOperationIndex);

	}

const CImPop3OfflineOperationFinder::TOperationDetails& CImPop3OfflineOperationFinder::OperationDetails() const

// Returns the details for the current operation.

	{

	return iOperationDetails;

	}

CImPop3OfflineOperationFinder::~CImPop3OfflineOperationFinder()

	{

	delete iChildMessages;

	TInt index = 0;

	if (iOfflineOperations)

		{

		// Delete each of the CImOffLineOperationArrays

		while (index < iOfflineOperations->Count())

			{

			delete (*iOfflineOperations)[index];

			index++;

			}

		delete iOfflineOperations;

		}

	}

void CImPop3OfflineOperationFinder::DoRunL()

	{

	++iMessageIndex;

	if (iMessageIndex < iChildMessages->Count())

		// If there are more messages then check them for offline operations.

		{

		CheckNextChildMessageL();

		}

	else

		// If there are no more messages then go back and find all the offline operations.

		{

		delete iChildMessages;

		iChildMessages = 0;

		// Move the offline copy opertion array to the front of the list.

		TInt index = 0;

		TBool go = ETrue;

		while ((index < iOfflineOperations->Count())

				&& go)

			{

			CImOffLineOperation::TOffLineOpType opType = ((*iOfflineOperations)[index]->Operation(0)).OpType();

			if (opType == CImOffLineOperation::EOffLineOpCopyToLocal)

				{

				// Move the offline copy operation array to the front of the list.

				go = EFalse;

				CImOffLineOperationArray* populateOperationList = (*iOfflineOperations)[index];

				iOfflineOperations->Delete(index);

				iOfflineOperations->InsertL(index, populateOperationList, sizeof(void*));

				}

			else

				{

				index++;

				}

			}

		// Move the offline populate opertion array to the front of the list.

		index = 0;

		go = ETrue;

		while ((index < iOfflineOperations->Count())

				&& go)

			{

			CImOffLineOperation::TOffLineOpType opType = ((*iOfflineOperations)[index]->Operation(0)).OpType();

			if (opType == CImOffLineOperation::EOffLineOpCopyWithinService)

				{

				// Move the offline populate operation array to the front of the list.

				go = EFalse;

				CImOffLineOperationArray* populateOperationList = (*iOfflineOperations)[index];

				iOfflineOperations->Delete(index);

				iOfflineOperations->InsertL(index, populateOperationList, sizeof(void*));

				}

			else

				{

				index++;

				}

			}

		// Set the iOperationIndex to the first appropriate operation.

		iOperationArrayIndex = 0;

		iOperationIndex = -1;

		FindNext();

		Complete(KErrNone);

		}

	}

void CImPop3OfflineOperationFinder::DoCancel()

	{

	CMsgActive::DoCancel();

	}

void CImPop3OfflineOperationFinder::DoComplete()

	{

	}

void CImPop3OfflineOperationFinder::ConstructL()

	{

	CActiveScheduler::Add(this);

	iOfflineOperations = new (ELeave) CArrayVarFlat<CImOffLineOperationArray*>(3);

	}

CImPop3OfflineOperationFinder::CImPop3OfflineOperationFinder(CMsvServerEntry& aEntry) : CMsgActive(EPriorityStandard), iEntry(aEntry)

	{

	}

// API

// ===

// The CImPop3SetOfflineOps class provides a means of asynchronously adding

// offline operations to the message stores of the appropriate messages.

// Use the AddOfflineOperationL to add the offline operations.

CImPop3SetOfflineOps* CImPop3SetOfflineOps::NewL(CMsvServerEntry& aEntry)

	{

	CImPop3SetOfflineOps* self = NewLC(aEntry);

	CleanupStack::Pop(); // self

	return self;

	}

CImPop3SetOfflineOps* CImPop3SetOfflineOps::NewLC(CMsvServerEntry& aEntry)

	{

	CImPop3SetOfflineOps* self = new (ELeave) CImPop3SetOfflineOps(aEntry);

	CleanupStack::PushL(self);

	self->ConstructL();

	CActiveScheduler::Add(self);

	//	ConstructL();

	return self;

	}

void CImPop3SetOfflineOps::AddOfflineOperationL(const CMsvEntrySelection *aMessageSelection,

							CImOffLineOperation::TOffLineOpType aOperationType,

							TMsvId aTargetFolderId,

							TRequestStatus& aStatus)

// Adds the aOperationType operation to each message in aMessageSelection.

// The aTargetFolderId is not used for some operation types, eg. deleting.

	{

	iState = EAddingOfflineOperations;

	iMessageCounter = 0;

	iOperationType = aOperationType;

	iDestinationEntryId = aTargetFolderId;

	delete iSourceMessages;

	iSourceMessages = 0;

	delete iMessagesToCopyLocally;

	iMessagesToCopyLocally = new (ELeave) CMsvEntrySelection;

	iSourceMessages = aMessageSelection->CopyL();

	TInt count = iSourceMessages->Count();

	iOfflineOperationArrayFlag.Reset();

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

		{

		iOfflineOperationArrayFlag.AppendL(EFalse);	

		}

	Queue(aStatus);

	AddOfflineOperationL();

	}

void CImPop3SetOfflineOps::CancelOfflineOperationsL(const CMsvEntrySelection& aSelection, TRequestStatus& aStatus)

// Cancel all pending operations on each message in aSelection.

	{

	iState = ECancellingOfflineOperations;

	iMessageCounter = 0;

	delete iSourceMessages;

	iSourceMessages = 0;

	iSourceMessages = aSelection.CopyL();

	Queue(aStatus);

	CancelOfflineOperationL();

	}

// Resumes a cancelled "Cancel Offline Operations" operation.

void CImPop3SetOfflineOps::ResumeCancelOfflineOperationsL(TRequestStatus& aStatus)

	{

	Queue(aStatus);

	CancelOfflineOperationL();

	}

void CImPop3SetOfflineOps::AddOfflineOperationL()

	{

	// Set the current entry, ready for the operation to be attached to it.

	User::LeaveIfError(iEntry.SetEntry((*iSourceMessages)[iMessageCounter]));

	iModifiedOperationType = iOperationType;

	if ((iEntry.Entry()).Complete())

	// Any messages that have already been populated can be copied locally without

	// the need to be online.

	// This is done after any offline operations have been added but they are

	// saved for later here:

		{

		if (iOperationType == CImOffLineOperation::EOffLineOpCopyToLocal)

			{

			iMessagesToCopyLocally->AppendL(iEntry.Entry().Id());

			iModifiedOperationType = CImOffLineOperation::EOffLineOpNone;

			}

		if (iOperationType == CImOffLineOperation::EOffLineOpMoveToLocal)

			{

			iMessagesToCopyLocally->AppendL(iEntry.Entry().Id());

			iModifiedOperationType = CImOffLineOperation::EOffLineOpDelete;

			}

		}

	if (iModifiedOperationType == CImOffLineOperation::EOffLineOpNone)

		{

		iStatus = KRequestPending;

		SetActive();

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, KErrNone);

		return;

		}

	CImOffLineOperationArray* operationArray = CImOffLineOperationArray::NewL();

	CleanupStack::PushL(operationArray);

	CImOffLineArrayStore* operationStore = new (ELeave) CImOffLineArrayStore(*operationArray);

	CleanupStack::PushL(operationStore);

	CMsvStore* messageStore = iEntry.EditStoreL();

	CleanupStack::PushL(messageStore);