// 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 "cimapcompounddelete.h"

#include "cimapsession.h"

#include "cimapfolder.h"

#include "cimapsessionconsts.h"

#include "cimaplogger.h"

#include "imappaniccodes.h"

#include "mobilitytestmtmapi.h"

_LIT8(KImapAddFlags, "+FLAGS");

_LIT8(KImapFlagDeleted, "(\\Deleted)");

CImapCompoundDelete::CImapCompoundDelete(CImapSyncManager& aSyncManager,

						 				 CMsvServerEntry& aServerEntry,

						 				 CImapSettings& aImapSettings) :

	CImapCompoundBase(aSyncManager, aServerEntry, aImapSettings)

	{

	}

CImapCompoundDelete::~CImapCompoundDelete()

	{

	delete iSourceSel;

	iMessageUids.Reset();

	iFlagInfoResponseArray.Reset();

	}

CImapCompoundDelete* CImapCompoundDelete::NewL(CImapSyncManager& aSyncManager,

						 				  	   CMsvServerEntry& aServerEntry,

						 				  	   CImapSettings& aImapSettings, 

						 				  	   const CMsvEntrySelection& aSourceSel)

	{

	CImapCompoundDelete* self = new (ELeave) CImapCompoundDelete(aSyncManager,

																 aServerEntry,

																 aImapSettings );

	CleanupStack::PushL(self);

	self->ConstructL(aSourceSel);

	CleanupStack::Pop(self);

	return self;

	}

void CImapCompoundDelete::ConstructL(const CMsvEntrySelection& aSourceSel)

	{

	iSourceSel=new (ELeave) CMsvEntrySelection;

	// Check the source selection contains only messages

	// Messages         True

	// Handle Parts     False

	// Handle Folders   False

	// Check source     True

	// Makes a local copy of the source selection in iSourceSel

	CheckSelectionL(aSourceSel, iSourceSel, ETrue, EFalse, EFalse, ETrue);

	// Initialise the progress counters	

	iProgressMsgsToDo=iSourceSel->Count();

	iProgressMsgsDone=0;

	// Add to the active scheduler

	CActiveScheduler::Add(this);

	}

void CImapCompoundDelete::StartOperation(TRequestStatus& aStatus, CImapSession& aSession)

	{

	iSession = &aSession;

	__LOG_TEXT(iSession->LogId(), "CImapCompoundDelete::StartOperation()");

	iNextStep = ESelectSourceMailboxRW;

	Queue(aStatus);

	CompleteSelf();

	}

/**

Handles the compound operation state machine

@return ETrue if compound operation is completed, 

		EFalse otherwise (will be called again, unless active)

*/

TBool CImapCompoundDelete::DoRunLoopL()

	{

	SetCurrentStep();

	switch (iCurrentStep)

		{

		case ESelectSourceMailboxRW: // asynchronous

			{

			MOBILITY_TEST_MTM_STATE(iImapSettings.ServiceId(), KMobilityTestMtmStateImapDelete1); // select source folder

			// Anything to do?

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

				{

				iNextStep = EFinished;

				return EFalse;

				}

			// suspend operation if stop for migrate has been requested

			if (iStopForMigrate)

				{

				__LOG_TEXT(iSession->LogId(), "CImapCompoundDelete::Stopped for migrate");

				iCurrentStep = ESuspendedForMigrate;

				iNextStep = ESelectSourceMailboxRW;

				Complete(KErrNone);

				return ETrue;

				}

			// Find the parent folder for the first entry in the array

			iParentFolderId = FindFolderL((*iSourceSel)[0]);

			iParentFolder = iSyncManager.GetFolderL(iParentFolderId);

			if (iParentFolder==NULL)

				{

				// Try again with the next message

				// Delete the first entry in the source selection

				iSourceSel->Delete(0, 1);

				// increment progress counter

				++iProgressMsgsDone;

				return EFalse;

				}

			// reset the message UID list

			iMessageUids.Reset();

			__LOG_FORMAT((iSession->LogId(), "Deleting message %x in folder %x", (*iSourceSel)[0], iParentFolderId));

			iParentFolder->SelectL(iStatus, *iSession);

			iProgressState = TImap4GenericProgress::ESelecting;

			iNextStep = EDeleteMessage;

			SetActive();

			break;

			}

		case EDeleteMessage: // asynchronous

			{

			MOBILITY_TEST_MTM_STATE(iImapSettings.ServiceId(), KMobilityTestMtmStateImapDelete2); // issue the STORE /deleted command

			// build an array of the UIDs to delete,

			// mark local IMAP \deleted flag.

			TInt  i = 0;

			TInt  count = iSourceSel->Count();

			TBool sameParent = ETrue;

			while (i<count && sameParent)

				{

				SetEntryL((*iSourceSel)[i]);

				TMsvEmailEntry entry = iServerEntry.Entry();

				if (entry.Parent()==iParentFolderId)

					{

					TUint id = entry.UID();

					iMessageUids.AppendL(id);

					// Set deleted flag on local entry

					entry.SetDeletedIMAP4Flag(ETrue);

					User::LeaveIfError(iServerEntry.ChangeEntry(entry));

					++iSelectionToDelete;

					}

				else

					{

					sameParent=EFalse;

					}

				++i;

				}

			HBufC8* uidSeq = CImapSession::CreateSequenceSetLC(iMessageUids);

			// issue the store command

			iSession->StoreL(iStatus, uidSeq->Des(), KImapAddFlags, KImapFlagDeleted, ETrue, iFlagInfoResponseArray);

			iProgressState = TImap4GenericProgress::EDeleting;

			CleanupStack::PopAndDestroy(uidSeq);

			if (iImapSettings.UseExpunge())

				{

				iNextStep=EExpunge;

				}

			else

				{

				iNextStep=ECloseFolder;

				}

			SetActive();

			break;

			}

		case EExpunge: // asynchronous

			{

			MOBILITY_TEST_MTM_STATE(iImapSettings.ServiceId(), KMobilityTestMtmStateImapDelete3); // issue the EXPUNGE command

			// Messages have been marked for delete on the remote server

			// issue the expunge command to remove them completely

			iSession->ExpungeL(iStatus);

			// no change in progress state

			iNextStep = EDeleteLocalMessage;

			SetActive();

			break;

			}

		case ECloseFolder:

			{

			MOBILITY_TEST_MTM_STATE(iImapSettings.ServiceId(), KMobilityTestMtmStateImapDelete4); // CLOSE FOLDER

			//Permanently removes all messages that have the deleted flag set

			//from the currently selected mailbox

			iSession->CloseL(iStatus);

			iNextStep=ESelectFolderAfterClose;

			SetActive();

			break;

			}

		case ESelectFolderAfterClose:

			{

			MOBILITY_TEST_MTM_STATE(iImapSettings.ServiceId(), KMobilityTestMtmStateImapDelete5); // SELECT FOLDER

			//Selecting a mailbox so that messages in the mailbox can be accessed. 

			iParentFolder->SelectL(iStatus, *iSession);

			iNextStep=EDeleteLocalMessage;

			SetActive();

			break;

			}

		case EDeleteLocalMessage: // synchronous

			{

			DeleteLocalMessagesL();

			// test for remaining messages to delete performed in state ESelectSourceMailboxRW;

			iNextStep=ESelectSourceMailboxRW;

			// no async request made.

			return EFalse;

			}

		case EFinished:	// finished

			{

			__LOG_TEXT(iSession->LogId(), "CImapCompoundDelete::Completing OK");

			iProgressState = TImap4GenericProgress::EIdle;

			Complete(KErrNone);

			return ETrue;

			}

		default:

			{

			__ASSERT_DEBUG(EFalse, 

				TImapServerPanic::ImapPanic(TImapServerPanic::EDeleteCompoundUnexpectedState));

			// unexpected state - complete the request

			iProgressState = TImap4GenericProgress::EIdle;

			return ETrue;

			}

		}

	return EFalse;

	}

/**

May be called in case of a genuine cancel or a cancel for migrate.

Following a genuine cancel, the compound operation will be deleted.

Following a cancel for migrate, the compound operation will be resumed,

so the iNextState is updated here to ensure the operation is

correctly restarted.

In either case, CMsgActive::DoCancel() is called to complete the

user request with KErrCancel.

Note that if the default CMsgActive::DoComplete() is overridden,

then that must also be modified to handle either case described above.

*/	

void CImapCompoundDelete::DoCancel()

	{

	switch (iCurrentStep)

		{

		case ESelectSourceMailboxRW:

			{

			// There is an outstanding select command issued. Cancel it.

			// Need to re-start with next step = ESelectSourceMailboxRW

			iSession->Cancel();

			iNextStep = ESelectSourceMailboxRW;

			break;

			}

		case EDeleteMessage: 

			{

			// in DoRunL an array of messages in this folder has been created

			// so, it is possible that that requested delete has not actually

			// been received by the remote server. When the operation re-starts

			// it will need to re-select the parent folder and then re-issue the

			// STORE \deleted command.

			// the entries have already been marked locally.

			// we still have the iUID array - iMessageUids.

			// Cancel the session command

			iSession->Cancel();

			iSelectionToDelete = 0; // reset the count of messages to delete locally

			iNextStep = EDeleteMessage; // restart function

			break;

			}

		case EExpunge:

			{

			// Messages have been marked for delete on the remote server

			// and the expunge command issued - cancel it

			// Cancel the session command

			iSession->Cancel();

			// need to re-issue the expunge command after migrate 

			// (and re-select of correct folder)

			iNextStep = EExpunge;

			break;

			}

		case ECloseFolder:

			{

			iSession->Cancel();

			iNextStep = ECloseFolder;

			break;

			}

		case ESelectFolderAfterClose:

			{

			iSession->Cancel();

			iNextStep = ESelectFolderAfterClose;

			break;

			}

		case EDeleteLocalMessage:

		case EFinished:

			{

			// self-completed or no outstanding request.

			break;

			}

		case ESuspendedForMigrate:

		default:

			{

			__ASSERT_DEBUG(EFalse, 

				TImapServerPanic::ImapPanic(TImapServerPanic::EDeleteCompoundCancelUnexpectedState));

			break;

			}

		} // end switch (iCurrentStep)	

	if (!iCancelForMigrate)

		{

		// genuine cancel - update progress

		iProgressErrorCode = KErrCancel;

		}

	CMsgActive::DoCancel();

	}

void CImapCompoundDelete::Progress(TImap4CompoundProgress& aCompoundProgress)

	{

	aCompoundProgress.iGenericProgress.iOperation = TImap4GenericProgress::EDelete;

	aCompoundProgress.iGenericProgress.iState = iProgressState;

	aCompoundProgress.iGenericProgress.iMsgsToDo = iProgressMsgsToDo;

	aCompoundProgress.iGenericProgress.iMsgsDone = iProgressMsgsDone;

	// Put error into progress buffer

	if( aCompoundProgress.iGenericProgress.iErrorCode == KErrNone )

		{

		aCompoundProgress.iGenericProgress.iErrorCode = iProgressErrorCode;

		}

	}

/**

Deletes messages locally

Deletes messages in iSourceSel contains only messages

belonging to a single parent folder.

*/

void CImapCompoundDelete::DeleteLocalMessagesL()

	{

	// Set the server entry context to the parent.

	SetEntryL((*iSourceSel)[0]);

	SetEntryL(iServerEntry.Entry().Parent());

	// delete local entries that have been expunged remotely

	TInt count = 0;

	while(count<iSelectionToDelete)

		{

		// Do not leave when entry is in use 

		TInt err = iServerEntry.DeleteEntry((*iSourceSel)[count]);

		if(err!=KErrNone)

			{

			if(err!=KErrInUse)

				{

				User::LeaveIfError(err);

				}

			}

		++count;

		} // end while()

	// remove deleted items from the selection 

	iSourceSel->Delete(0,count);

	iSelectionToDelete=0;

	// increment progress counter

	iProgressMsgsDone+=count;

	}

/**

Handles NO/BAD responses according to current step.

Negative server responses are not fatal - the error is saved in

the message currently being operated on and the state machine pushed

on to process the next message in the requested selection.

@return KErrNone if the error has been handled

		Completion error code otherwise.

*/

TInt CImapCompoundDelete::ProcessNegativeServerResponse()

	{

	TInt err = iStatus.Int();

	switch (iCurrentStep)

		{

		case ESelectSourceMailboxRW:

		case ESelectFolderAfterClose:

			{

			// only knowingly operating on a single message at this point.

			if (err == KErrImapNo)

				{

				err = KErrNotFound;

				}

			// save the error with the associated message

			TRAP_IGNORE(MessageErrorL((*iSourceSel)[0], err));

			++iProgressMsgsDone;

			// Skip to the next message, or finish

			iNextStep = (iProgressMsgsDone<iProgressMsgsToDo)?ESelectSourceMailboxRW:EFinished;

			break;

			}

		case EDeleteMessage:

		case EExpunge:

		case ECloseFolder:

			{

			// failed to mark one or more messages for delete.

			// ignore the error - no point in storing it in a 

			// message that is just about to be deleted.

			break;

			}

		case EDeleteLocalMessage:

		case EFinished:

		case ESuspendedForMigrate:

		default:

			{

			// positive error code not expected,

			// self-completed states or no outstanding request.

			TImapServerPanic::ImapPanic(TImapServerPanic::EDeleteCompoundUnexpectedState);

			break;

			}

		} // end switch (iCurrentStep)

	iProgressErrorCode = err;

	return KErrNone;

	}

/**

Resumes the operation following a migration.

*/

void CImapCompoundDelete::ResumeOperationL(TRequestStatus& aStatus, CImapSession& aSession)

	{

	iSession = &aSession;

	__LOG_TEXT(iSession->LogId(), "CImapCompoundDelete::Resuming");

	__ASSERT_DEBUG(iCurrentStep==ESuspendedForMigrate, TImapServerPanic::ImapPanic(TImapServerPanic::EDeleteCompoundUnexpectedState));

	iStopForMigrate = EFalse;

	// Switch on next step - some "next steps" require a SELEECT first...

	switch (iNextStep)

		{

		case ESelectSourceMailboxRW:

		case ESelectFolderAfterClose:

			{

			// just return to the main state machine

			CompleteSelf();

			break;

			}

		case EDeleteMessage: 

		case EExpunge:

		case ECloseFolder:

			{

			// re-issue the SELECT before kicking off the DELETE or EXPUNGE command:

			iParentFolder->SelectL(iStatus, *iSession);

			iCurrentStep = ESelectSourceMailboxRW;

			SetActive();

			break;

			}

		case EDeleteLocalMessage:

		case EFinished:

			// not expected

		default:

			{

			__ASSERT_DEBUG(EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::EDeleteCompoundUnexpectedState));

			// abandon the compound operation

			iNextStep=EFinished;

			CompleteSelf();

			break;

			}

		} // end switch (iNextStep)

	Queue(aStatus);

	}