// 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 "cimapcompounddeletefolder.h"
#include "cimapsyncmanager.h"
#include "cimapfolder.h"
#include "cimapsession.h"
#include "cimapfolderinfo.h"
#include "cimapsessionconsts.h"
#include "cimaplogger.h"
#include "imappaniccodes.h"

#include "mobilitytestmtmapi.h"

_LIT8(KAllUids, "1:*");
_LIT8(KMessageDataItem, "+FLAGS");
_LIT8(KDeleteValue,	 "\\Deleted");
			
CImapCompoundDeleteFolder::CImapCompoundDeleteFolder(CImapSyncManager& aSyncManager, CMsvServerEntry& aServerEntry, CImapSettings& aImapSettings)
 :	CImapCompoundBase(aSyncManager, aServerEntry, aImapSettings)
	{
	}

CImapCompoundDeleteFolder::~CImapCompoundDeleteFolder()
	{
	delete iDeleteSel;
	iOutMessageFlagInfo.Close();
	}
	
CImapCompoundDeleteFolder* CImapCompoundDeleteFolder::NewL(CImapSyncManager& aSyncManager, CMsvServerEntry& aServerEntry, CImapSettings& aImapSettings, const CMsvEntrySelection& aSourceSel)
	{
	CImapCompoundDeleteFolder* self = new (ELeave) CImapCompoundDeleteFolder(aSyncManager, aServerEntry, aImapSettings);
	CleanupStack::PushL(self);
	self->ConstructL(aSourceSel);
	CleanupStack::Pop(self);
	return self;
	}

void CImapCompoundDeleteFolder::ConstructL(const CMsvEntrySelection& aSourceSel)
	{
	iDeleteSel=new (ELeave) CMsvEntrySelection;

	// Check the source selection for acceptable types (folders)
	// Messages         EFalse
	// Handle Parts     EFalse
	// Handle Folders   ETrue
	// Check source     ETrue
	// Makes a local copy of the source selection in iDeleteSel
	CheckSelectionL(aSourceSel, iDeleteSel, EFalse, EFalse, ETrue, ETrue);

	// Initialise the progress counters	
	iFoldersToDelete=iDeleteSel->Count();
	iFoldersDone = 0;
	
	// Add to the active scheduler
	CActiveScheduler::Add(this);
	}
	

void CImapCompoundDeleteFolder::StartOperation(TRequestStatus& aStatus, CImapSession& aSession)
	{
	iSession = &aSession;
	__LOG_TEXT(iSession->LogId(), "CImapCompoundDeleteFolder::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 CImapCompoundDeleteFolder::DoRunLoopL()
	{
	SetCurrentStep();
	switch (iCurrentStep)
		{
		case ESelectSourceMailboxRW:  // asynchronous
			{
			MOBILITY_TEST_MTM_STATE(iImapSettings.ServiceId(), KMobilityTestMtmStateImapDeleteFolder1); // selecting folder
			// anything to do?
			if (iDeleteSel->Count() <= 0)
				{
				iNextStep = EFinished;
				return EFalse;
				}
				
			// suspend operation if stop for migrate has been requested
			if (iStopForMigrate)
				{
				__LOG_TEXT(iSession->LogId(), "CImapCompoundDeleteFolder::Stopped for migrate");
				iCurrentStep = ESuspendedForMigrate;
				iNextStep = ESelectSourceMailboxRW;
				Complete(KErrNone);
				return ETrue;
				}
			
			// Note that SelectSourceMailboxL() calls SetActive();	
			SelectSourceMailboxL();
			break;
			}

		case EDeleteAllMessages:  // asynchronous
			{
			MOBILITY_TEST_MTM_STATE(iImapSettings.ServiceId(), KMobilityTestMtmStateImapDeleteFolder2); // deleting all messages
			// mark all messages in the selected folder /deleted
			DeleteAllMessagesL(); // note this method calls SetActive();
			break;
			}
			
		case ECloseFolder:  // asynchronous
			{
			MOBILITY_TEST_MTM_STATE(iImapSettings.ServiceId(), KMobilityTestMtmStateImapDeleteFolder3); // closing the folder
			// closing the folder causes messages 
			// marked /Deleted to be expunged
			iSession->CloseL(iStatus);
			iNextStep=EDeleteFolder;
			SetActive();
			break;
			}
			
		case EDeleteFolder:  // asynchronous
			{
			MOBILITY_TEST_MTM_STATE(iImapSettings.ServiceId(), KMobilityTestMtmStateImapDeleteFolder4); // issued delete command
			iSession->DeleteL(iStatus, iFolder->FullFolderPathL());
			iNextStep=EDeleteLocalFolder;
			SetActive();
			break;
			}
		
		case EDeleteLocalFolder:  // synchronous
			{
			DeleteLocalFolderL();
			// No async request issued, loop.
			return EFalse;
			}
			
		case EFinished:  // finished
			{
			__LOG_TEXT(iSession->LogId(), "CImapCompoundDeleteFolder::Completing OK");
			iProgressState = TImap4GenericProgress::EIdle;
			Complete(KErrNone);
			return ETrue;
			}
			
		default:
			{
			__ASSERT_DEBUG(EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::EDeleteFolderCompoundUnexpectedState));
			// unexpected state - complete the request
			iProgressState = TImap4GenericProgress::EIdle;
			return ETrue;
			}
		} // end switch (iCurrentStep)
	return EFalse;
	}

void CImapCompoundDeleteFolder::SelectSourceMailboxL()
	{
	iFolder = NULL;
	iRemoteFolderNotDeleted=EFalse;
	
	// Get a temporary folder object for the delete operation, as this
	// can be performed on non-subscribed folders for which the sync manager
	// does not own a folder object. Owned by this class.
	iFolder = iSyncManager.GetFolderL((*iDeleteSel)[0]);
	if (iFolder==NULL)
		{
		IncrementProgress();
		// Try with the next folder in the array, unless this was the last.
		if (iDeleteSel->Count()==0)
			{
			iNextStep=EFinished;
			}
		CompleteSelf();
		}
	else
		{
		SetEntryL(iFolder->MailboxId());
		TMsvEmailEntry entry = iServerEntry.Entry();
		if (entry.Mailbox())
			{
			iFolder->SelectL(iStatus, *iSession);
			iProgressState = TImap4GenericProgress::ESelecting;
			iNextStep=EDeleteAllMessages;
			SetActive();
			}
		else
			{
			// do not attempt to select a folder marked \noselect
			// go straight to the delete folder step.
			iNextStep=EDeleteLocalFolder;
			CompleteSelf();
			}
		}
	}
	
	
void CImapCompoundDeleteFolder::DeleteAllMessagesL()
	{
	// following steps are delete operations...
	iProgressState = TImap4GenericProgress::EDeleting;

	// Are there any messages in the remote folder to delete?
	if (iSession->SelectedFolderInfo()->Exists()==0)
		{
		// No: Skip this step then
		CompleteSelf();
		}
	else
		{
		// DeleteAllMessages is a special case: we want to delete everything,
		// regardless of wether it's in the mirror or not. So, we set deleted
		// flags on everything then close the folder to expunge the messages.

		// Mark all messages in the folder for delete
		iSession->StoreL(iStatus, KAllUids, KMessageDataItem, KDeleteValue, ETrue, iOutMessageFlagInfo);
		SetActive();
		}
	iNextStep=ECloseFolder;
	}


void CImapCompoundDeleteFolder::DeleteLocalFolderL()
	{
	// sync manager deletes the local folder, any children entries
	iSyncManager.DeleteFolderContentsL((*iDeleteSel)[0]);

	if (!iRemoteFolderNotDeleted)
		{
		// update the sync manager's view of folders.
		iSyncManager.RemoveFolderL((*iDeleteSel)[0]);
		}
	
	// finished with this folder now, 
	// increment the progress
	IncrementProgress();
	iNextStep=ESelectSourceMailboxRW;
	}

/**
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 CImapCompoundDeleteFolder::DoCancel()
	{
	switch (iCurrentStep)
		{
		case ESelectSourceMailboxRW:
		case EDeleteAllMessages:
		case ECloseFolder:
			{
			// outstanding request on the session.
			// Note that although select operations are performed on a folder they
			// actually pass our iStatus to the session, so that is why we cancel
			// the session for them.
			// either the SELECT, STORE or the CLOSE session command is 
			// to be cancelled... restart from the beginning to make sure 
			// the folder has been emptied and the delete happens properly.
			iSession->Cancel();
			iNextStep = ESelectSourceMailboxRW;
			break;
			}
		case EDeleteFolder:
			{
			// Folder has been emptied. After migrate, just delete it.
			iSession->Cancel();
			iNextStep=EDeleteFolder;
			break;
			}
		case EDeleteLocalFolder:
		case EFinished:
			{
			// self-completed or no outstanding request.
			break;
			}
		case ESuspendedForMigrate:
		default:
			{
			__ASSERT_DEBUG(EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::EDeleteFolderCompoundCancelUnexpectedState));
			// attempt to resume the operation from the start.
			iNextStep = ESelectSourceMailboxRW;
			break;
			}
		} // end switch (iCurrentStep)

	if (!iCancelForMigrate)
		{
		// genuine cancel - update progress
		iProgressErrorCode = KErrCancel;
		}
	CMsgActive::DoCancel();
	}
	
void CImapCompoundDeleteFolder::Progress(TImap4CompoundProgress& aCompoundProgress)
	{
	aCompoundProgress.iGenericProgress.iOperation = TImap4GenericProgress::EDelete;
	aCompoundProgress.iGenericProgress.iState = iProgressState;
	aCompoundProgress.iGenericProgress.iMsgsToDo = iFoldersToDelete;
	aCompoundProgress.iGenericProgress.iMsgsDone = iFoldersDone;

	// Put error into progress buffer
	if( aCompoundProgress.iGenericProgress.iErrorCode == KErrNone )
		{
		aCompoundProgress.iGenericProgress.iErrorCode = iProgressErrorCode;
		}	
	}

/**
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 CImapCompoundDeleteFolder::ProcessNegativeServerResponse()
	{
	TInt err = iStatus.Int();
	switch(iCurrentStep)
		{
		case ESelectSourceMailboxRW:
			{
			if (err == KErrImapNo)
				{
				err = KErrNotFound;
				}
			} // fall through
		case EDeleteFolder:
			{
			// The folder is not selectable for some reason, or
			// failed to delete the folder on the remote server,
			// setting this flag prevents the local folder being
			// deleted, but the contents will still be deleted.
			iProgressErrorCode = KErrImapCantDeleteFolder;
			iRemoteFolderNotDeleted=ETrue;
			iNextStep=EDeleteLocalFolder;
			break;
			}
		case EDeleteAllMessages:
		case ECloseFolder:
			{
			// Error indicates a problem with the issued STORE or CLOSE command.
			// Attempt to continue regardless.
			break;
			}
		case EDeleteLocalFolder:
		case EFinished:
		case ESuspendedForMigrate:
		default:
			{
			// positive completion code not expected,
			// self-completed states or no outstanding request.
			TImapServerPanic::ImapPanic(TImapServerPanic::EDeleteFolderCompoundUnexpectedState);
			break;
			}
		}
	return KErrNone;
	}

/**
Increments the progress count and removes the deleted folder
from the source array
*/
void CImapCompoundDeleteFolder::IncrementProgress()
	{
	++iFoldersDone;
	iDeleteSel->Delete(0,1);
	}

/**
Resumes the operation following a migration.
*/
void CImapCompoundDeleteFolder::ResumeOperationL(TRequestStatus& aStatus, CImapSession& aSession)
	{
	iSession = &aSession;
	__LOG_TEXT(iSession->LogId(), "CImapCompoundDeleteFolder::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 EDeleteFolder:
			{
			// just return to the main state machine
			CompleteSelf();
			break;
			}

		case EDeleteAllMessages:
		case ECloseFolder:
		case EDeleteLocalFolder:
		case EFinished:
			// not expected
		default:
			{
			__ASSERT_DEBUG(EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::EDeleteCompoundUnexpectedState));
			// abandon the compound operation
			iNextStep=EFinished;
			CompleteSelf();
			break;
			}
		}
	Queue(aStatus);
	}