// Copyright (c) 1998-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:

// IMAP4 compound operations

// This class wraps up operations which require more than one IMAP command

// (the imapsess.cpp class deals with single IMAP commands generally),

// allowing increased neatness in the higher classes.

// 

//

#include <e32base.h>

#include <e32cons.h>

#include <mentact.h>

#include "impspan.h"

#include "imapsess.h"

#include <imapset.h>

#include "imapcomp.h"

#ifdef _DEBUG

#define LOG_COMMANDS(a) a

#define DBG(a) a

#define PRINTING

#else

#define LOG_COMMANDS(a)

#define DBG(a)

#undef PRINTING

#endif

// Priority of MsgActive object

const TInt ECompoundPriority=1;

// Operations that can be chained

enum

	{

	EFinished=0,

	ESelectSourceMailboxRW,

	ESelectSourceMailboxRO,

	ESelectDestinationMailboxRW,

	ESelectDestinationMailboxRO,

	EFetchMessage,

	ECopyMessage,

	EAppendMessage,

	EDeleteMessage,

	EDeleteLocalMessage,

	EDeleteAllMessages,

	ENewSyncFolder,

	ESyncFolder,

	EInboxDuplicateMove,

	EInboxDuplicateCopy,

	ECloseFolderWithoutExpunge,

	EDeleteFolder,

	EStartIdle,

	EStopIdle,

	ECreate,

	ERename,

	ESelectInbox

	};

//DS - Split EInboxDuplicate into EInboxDuplicateCopy and EInboxDuplicateMove to allow

//use of either CMsvServerEntry::CopyL or MoveL depending on what operation the user

//is attempting.

CImImap4Compound::CImImap4Compound():CMsgActive(ECompoundPriority)

	{

	__DECLARE_NAME(_S("CImImap4Compound"));

	}

CImImap4Compound::~CImImap4Compound()

	{

	// We don't delete iSession as we don't own it, we were just passed it to use.

	delete iSourceSel;

	}

CImImap4Compound* CImImap4Compound::NewL(CImImap4Session* aSession)

	{

	CImImap4Compound* self=new (ELeave) CImImap4Compound();

	CleanupStack::PushL(self);

	// Non-trivial constructor

	self->ConstructL(aSession);

	CleanupStack::Pop();

	return self;

	}

// The non-trivial constructor

void CImImap4Compound::ConstructL(CImImap4Session* aSession)

	{

	// Save session & entry

	iSession=aSession;

	iPopulateCommand=EFalse;

	iIdleBeforeFirstPopulate = EFalse;

	// We're an active object...

	CActiveScheduler::Add(this);

	// Initialise static sequences. There must be a better way

	// than this without causing complaints :-(

	SeqCopyToLocal[0]=EStopIdle;

	SeqCopyToLocal[1]=ESelectSourceMailboxRO;

	SeqCopyToLocal[2]=EFetchMessage;

	SeqCopyToLocal[3]=EInboxDuplicateCopy;

	SeqCopyToLocal[4]=ESelectInbox;

	SeqCopyToLocal[5]=EStartIdle;

	SeqCopyToLocal[6]=EFinished;

	SeqMoveToLocal[0]=EStopIdle;

	SeqMoveToLocal[1]=ESelectSourceMailboxRW;

	SeqMoveToLocal[2]=EFetchMessage;

	SeqMoveToLocal[3]=EInboxDuplicateMove;

	SeqMoveToLocal[4]=EDeleteMessage;

	SeqMoveToLocal[5]=ESelectInbox;

	SeqMoveToLocal[6]=EStartIdle;

	SeqMoveToLocal[7]=EFinished;

	SeqCopyWithinService[0]=EStopIdle;

	SeqCopyWithinService[1]=ESelectSourceMailboxRO;

	SeqCopyWithinService[2]=ECopyMessage;

	SeqCopyWithinService[3]=ESelectDestinationMailboxRO;

	SeqCopyWithinService[4]=ENewSyncFolder;

	SeqCopyWithinService[5]=ESelectInbox;

	SeqCopyWithinService[6]=EStartIdle;

	SeqCopyWithinService[7]=EFinished;

	SeqMoveWithinService[0]=EStopIdle;

	SeqMoveWithinService[1]=ESelectSourceMailboxRW;

	SeqMoveWithinService[2]=ECopyMessage;

	SeqMoveWithinService[3]=EDeleteMessage;

	SeqMoveWithinService[4]=ESelectDestinationMailboxRO;

	SeqMoveWithinService[5]=ENewSyncFolder;

	SeqMoveWithinService[6]=ESelectInbox;

	SeqMoveWithinService[7]=EStartIdle;

	SeqMoveWithinService[8]=EFinished;

	SeqCopyFromLocal[0]=EAppendMessage;

	SeqCopyFromLocal[1]=ESelectDestinationMailboxRO;

	SeqCopyFromLocal[2]=ENewSyncFolder;

	SeqCopyFromLocal[3]=EFinished;

	SeqMoveFromLocal[0]=EStopIdle;

	SeqMoveFromLocal[1]=EAppendMessage;

	SeqMoveFromLocal[2]=EDeleteLocalMessage;

	SeqMoveFromLocal[3]=ESelectDestinationMailboxRO;

	SeqMoveFromLocal[4]=ENewSyncFolder;

	SeqMoveFromLocal[5]=ESelectInbox;

	SeqMoveFromLocal[6]=EStartIdle;

	SeqMoveFromLocal[7]=EFinished;

	SeqDelete[0]=EStopIdle;

	SeqDelete[1]=ESelectSourceMailboxRW;

	SeqDelete[2]=EDeleteMessage; // Explicit expunge

	SeqDelete[3]=ESelectInbox;

	SeqDelete[4]=EStartIdle;

	SeqDelete[5]=EFinished;

	SeqDeleteFolder[0]=EStopIdle;

	SeqDeleteFolder[1]=ESelectSourceMailboxRW;

	SeqDeleteFolder[2]=EDeleteAllMessages;

	SeqDeleteFolder[3]=ECloseFolderWithoutExpunge;

	SeqDeleteFolder[4]=EDeleteFolder;

	SeqDeleteFolder[5]=ESelectInbox;

	SeqDeleteFolder[6]=EStartIdle;

	SeqDeleteFolder[7]=EFinished;

	SeqNewSync[0]=EStopIdle;

	SeqNewSync[1]=ESelectSourceMailboxRW;

	SeqNewSync[2]=ENewSyncFolder;

	SeqNewSync[3]=ESelectInbox;

	SeqNewSync[4]=EStartIdle;

	SeqNewSync[5]=EFinished;

	SeqFullSync[0]=EStopIdle;

	SeqFullSync[1]=ESelectSourceMailboxRW;

	SeqFullSync[2]=ESyncFolder;

	SeqFullSync[3]=ESelectInbox;

	SeqFullSync[4]=EStartIdle;

	SeqFullSync[5]=EFinished;

	SeqSelect[0]=EStopIdle;

	SeqSelect[1]=ESelectSourceMailboxRW;

	SeqSelect[2]=EFinished;

	SeqSynchronise[0]=EStopIdle;

	SeqSynchronise[1]=ESyncFolder;

	SeqSynchronise[2]=ESelectInbox;

	SeqSynchronise[3]=EStartIdle;

	SeqSynchronise[4]=EFinished;

	SeqCreate[0]=EStopIdle;

	SeqCreate[1]=ECreate;

	SeqCreate[2]=ESelectInbox;

	SeqCreate[3]=EStartIdle;

	SeqCreate[4]=EFinished;

	SeqRename[0]=EStopIdle;

	SeqRename[1]=ERename;

	SeqRename[2]=ESelectInbox;

	SeqRename[3]=EStartIdle;

	SeqRename[4]=EFinished;

	// operations when done as part of a synchronisation process

	SeqSyncCopyToLocal[0]=EFetchMessage;

	SeqSyncCopyToLocal[1]=EInboxDuplicateCopy;

	SeqSyncCopyToLocal[2]=EFinished;

	}

// Set a new session

void CImImap4Compound::SetSession(CImImap4Session* aSession)

	{

	iSession=aSession;

	}

// Set entry for access to server's database

void CImImap4Compound::SetEntry(CMsvServerEntry* aEntry)

	{

	iEntry=aEntry;

	}

// Do setentry, leave if there is an error

void CImImap4Compound::SetEntryL(const TMsvId aId)

	{

#ifdef PRINTING

	TInt error=iEntry->SetEntry(aId);

	if (error)

		iSession->LogText(_L8("SetEntryL(%x) returned %d"),aId,error);

	User::LeaveIfError(error);

#else

	User::LeaveIfError(iEntry->SetEntry(aId));

#endif

	}

// Called when async child completes

void CImImap4Compound::DoRunL()

	{

	DBG((iSession->LogText(_L8("COMPOUND dorunl, step %d, status=%d"),iStep,iStatus.Int())));

	// Are we still connected? Worth checking...

	if (!iSession->Connected())

		{

		Complete(KErrDisconnected);

		return;

		}

	// Any error from last operation?

	if (iStep>0 && iStatus.Int()!=KErrNone)

		{

		switch(iSequence[iStep-1])

			{

		// If we get KErrIMAPNO from a selection state, we need to report this as KErrNotFound

		case ESelectSourceMailboxRW:

		case ESelectSourceMailboxRO:

		case ESelectDestinationMailboxRW:

		case ESelectDestinationMailboxRO:

		case ESelectInbox:

			if (iStatus.Int()==KErrIMAPNO)

				{

				Complete(KErrNotFound);

				break;

				}

			// Fall through

		default:

			// Complete with this error

			Complete(iStatus.Int());

			break;

			}

		// Reset step (shouldn't really be necessary, but it looks neat!)

		iStep=0;

		return;

		}

	while (!IsActive() && !DoRunLoopL())

		{

		// do nothing in the body of this

		}

	}

// Called when async child completes

TBool CImImap4Compound::DoRunLoopL()

	{

        DBG((iSession->LogText(_L8("CImImap4Compound::DoRunLoopL(): step to execute: %d"), iSequence[iStep])));

	switch(iSequence[iStep++])

		{

	case EFinished:

		// All done

		DBG((iSession->LogText(_L8("COMPOUND finished"))));

		Complete(KErrNone);

		iStep=0;

		return ETrue;

	case ESelectSourceMailboxRW:

		iSession->Select(iStatus,iSourceFolder,ETrue);

		break;

	case ESelectSourceMailboxRO:

		iSession->Select(iStatus,iSourceFolder,EFalse);

		break;

	case ESelectDestinationMailboxRW:

		iSession->Select(iStatus,iDestinationFolder,ETrue);

		break;

	case ESelectDestinationMailboxRO:

		iSession->Select(iStatus,iDestinationFolder,EFalse);

		break;

	case ESelectInbox:

		{

		// Selecting inbox before starting IDLE command

		if (iSession->ImapIdleSupported()==EFalse || iIdleBeforeCommand==EFalse || iIdleBeforeFirstPopulate == EFalse || iMsgCount > 0)

			{

			return EFalse;

			}

		TMsvId inbox = iSession->GetInbox();

                DBG((iSession->LogText(_L8("CImImap4Compound::DoRunLoopL(): selecting inbox"))));

		iSession->Select(iStatus,inbox,ETrue);

		break;

		}

	case ECreate:

		iSession->Create(iStatus,iSource,iLeafName,iFolder);

		break;

	case ERename:

		iSession->Rename(iStatus,iSource,iLeafName);

		break;

	case EFetchMessage:

		{

		// Don't fetch the message if it is marked for delete

		SetEntryL(iSource);

		TMsvEmailEntry entry = static_cast<TMsvEmailEntry> (iEntry->Entry()); 

		if (((TMsvEmailEntry)iEntry->Entry()).DisconnectedOperation() == EDisconnectedDeleteOperation)

			return EFalse;

		// Don't attempt to fetch the message if it has either been fully or partially downloaded, unless this is a populate command.

        if ( entry.Complete() && entry.PartialDownloaded() && !iPopulateCommand )

   			return EFalse;

		// We fetch to the mirror in all cases

                DBG((iSession->LogText(_L8("CImImap4Compound::DoRunLoopL(): fetching message"))));

		iSession->FetchBody(iStatus,iSource,iGetPartialMailInfo);

		break;

		}

	case ECopyMessage:

		if (iSequence==SeqCopyWithinService || iSequence==SeqMoveWithinService)

			{

			if (iSelectionStillToCopy-->0) 

				{

				 // Copy all messages before moving onto next step.

				iSession->Copy(iStatus,(*iSourceSel)[iSelectionStillToCopy],iDestinationFolder,ETrue);

				if (iSelectionStillToCopy>0)

					iStep--; // still copying.

				}

			}

		else

			iSession->Copy(iStatus,iSource,iDestinationFolder,ETrue);

		break;

	case EAppendMessage:

		iSession->Append(iStatus,iSource,iDestinationFolder);

		break;

	case EDeleteMessage:

		// Deletes a message remotely

		if (iSequence==SeqMoveWithinService && iSession->CommandFailure()==KErrIMAPNO)

			{

			DBG((iSession->LogText(_L8("Copy failed, Cancelling Delete"))));

			// Copy failed, so do not continue with delete.

			return EFalse;

			}

		if (iSelectionStillToDelete>1)

			iSession->Delete(iStatus,*iSourceSel);

		else

			iSession->Delete(iStatus,iSource);

		iSelectionStillToDelete=0;

		break;

	case EDeleteLocalMessage:

		// Deletes a message locally: only for messages not within the service

		iSession->DeleteMessageL(iSource);

		// As this is an instant operation, loop

		return EFalse;

	case EDeleteAllMessages:

		// Deletes all messages/folder (must have no subfolders)

		iSession->DeleteAllMessagesL(iStatus);

		break;

	case EDeleteFolder:

		// Delete the folder

		iSession->Delete(iStatus,iSourceFolder);

		break;

	case ENewSyncFolder:

		// New only sync.

		// if the current folder hasn't actually changed then don't

		// bother with the Sync

		if (!iSession->FolderChanged())

			return EFalse;

		// This used to do just that, new only messages, but it causes a lot of problems 

		// with sync limits, as for that to work deletes need to be taken into account also.

		// This will fix that.

                DBG((iSession->LogText(_L8("CImImap4Compound::DoRunLoopL(): ESyncNewFolder: synchronising"))));

		iSession->Synchronise(iStatus,EFalse);

		break;

	case ESyncFolder:

		// Full sync

                DBG((iSession->LogText(_L8("CImImap4Compound::DoRunLoopL(): ESyncFolder: synchronising"))));

		iSession->Synchronise(iStatus,EFalse);

		break;

	case ECloseFolderWithoutExpunge:

		// Close current folder

		iSession->Close(iStatus,EFalse);

		break;

	case EInboxDuplicateCopy:

	case EInboxDuplicateMove:

		{

		// SJM: if we asked to fetch to the mirror then we can skip

		// this stage

		if (iDestinationFolder == KMsvNullIndexEntryId)

			{

			return EFalse;

			}

		// Move the message to the destination (the local inbox) then duplicate it

		// back to the original folder for the mirror.

		iEntry->SetEntry(iSource);

		TMsvId sourcefolder=iEntry->Entry().Parent();

		// Do the move & copy back structure: we update iSource here as the message

		// in the mirror is actually a recreated one with a new TMsvId. We may want

		// to delete this (if we're doing a MoveToLocal, for example) and so we need

		// the correct TMsvId

#if 1

		// always copy so that on a move the delete happens on the original correctly

		iSession->CopyMessage(iStatus,sourcefolder,iSource,iDestinationFolder,

							  &iSource,EFalse);

#else

		//DS - Added the iSequence[iStep]==EInboxDuplicateMove to represent whether or not

		//to remove the original (i.e. copy or move).

		iSession->CopyMessage(iStatus,sourcefolder,iSource,iDestinationFolder,

							  &iSource,iSequence[iStep-1]==EInboxDuplicateMove);

#endif

		break;

		}

	case EStartIdle:

		 // if there are more messages(iMsgCount) to populate don't go to IDLE state.

		if (iSession->ImapIdleSupported()==EFalse || iIdleBeforeCommand==EFalse || iIdleBeforeFirstPopulate == EFalse || iMsgCount > 0)

			{

			return EFalse;

			}

                DBG((iSession->LogText(_L8("CImImap4Compound::DoRunLoopL(): EStartIdle: calling StartIdle()"))));

        iIdleBeforeFirstPopulate = EFalse;

		iSession->StartIdle(iStatus);

		break;

	case EStopIdle:

		if (iSession->ImapIdleSupported()==EFalse || iSession->IsIdling()==EFalse)

			{

                        DBG((iSession->LogText(_L8("CImImap4Compound::DoRunLoopL(): EStopIdle: not idling or waitng for idle"))));

			iIdleBeforeCommand = EFalse;

			// If last message being fetched , then should start IDLE after that.

			if (iMsgCount == 1 )

				{

				iIdleBeforeCommand = ETrue;	

				}

			return EFalse;

			}

 		iIdleBeforeFirstPopulate = ETrue;//Are we "IDLE" before first populate..

		iIdleBeforeCommand = ETrue;

                DBG((iSession->LogText(_L8("CImImap4Compound::DoRunLoopL(): EStopIdle: Calling StopIdle()"))));

		iSession->StopIdle(iStatus);

		break;

	default:

		gPanic(EUnknownState);

		return ETrue;

		}

	// Next step in sequence...

        DBG((iSession->LogText(_L8("CImImap4Compound::DoRunLoopL(): Setting active"))));

	SetActive();

	return EFalse;

	}

// Called when parent wants to cancel us

void CImImap4Compound::DoCancel()

	{

	DBG((iSession->LogText(_L8("CImImap4Compound::DoCancel()"))));

	// Cancel any session object we're using

	switch( iSequence[iStep-1] )

		{

	case EStopIdle:

	case ESelectSourceMailboxRO:

	case EFetchMessage: