// 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 connect & synchronise operation control

// This class deals with stepping through a synchronise operation - this

// involves:

// 1. Select inbox

// 2. Perform any outstanding operations on inbox

// 3. Synchronise inbox

// 4. Synchronise folder list

// 5. Build list of folders to synchronise, sorted by 'last sync' date

// (oldest first), and outstanding operations (folders with outstanding

// operations are first, whatever their date).

// 6. Mirror subscription flags as necessary

// 7. For each folder in the 'to synchronise' list...

// i)   Select folder

// ii)  Perform any outstanding operations

// iii) Synchronise folder

// 8. Reselect inbox

// 

//

#include <e32base.h>

#include <e32cons.h>

#include <mentact.h>

#include "impspan.h"

#include "imapsess.h"

#include "imapsync.h"

#include "fldsync.h"

#include <imapset.h>

#include <offop.h>

#include "imapcomp.h"

#include "imapoffl.h"

#include "impsutil.h"

#ifdef _DEBUG

#define DBG(a) iSession->LogText a

#define PRINTING

#else

#define DBG(a)

#undef PRINTING

#endif

// Inbox name for newly created one

_LIT(KInbox, "Inbox");

#ifdef PRINTING

LOCAL_C const TText8* SynchroniseStateString(CImImap4Synchronise::TSynchroniseState aState)

	{

	switch (aState)

		{

	case CImImap4Synchronise::ESyncStateIdle:

		return _S8("Idle");

	case CImImap4Synchronise::EInboxSelect:

		return _S8("InboxSelect");

	case CImImap4Synchronise::EInboxPendingOps:

		return _S8("InboxPendingOps");

	case CImImap4Synchronise::EInboxSync:

		return _S8("InboxSync");

	case CImImap4Synchronise::ESynchroniseFolderTree:

		return _S8("SynchroniseFolderTree");

	case CImImap4Synchronise::ECheckRemoteSubscription:

		return _S8("CheckRemoteSubscription");

	case CImImap4Synchronise::EProcessRemoteSubscription:

		return _S8("ProcessRemoteSubscription");

	case CImImap4Synchronise::EUpdateRemoteSubscription:

		return _S8("UpdateRemoteSubscription");

	case CImImap4Synchronise::EFolderSelect:

		return _S8("FolderSelect");

	case CImImap4Synchronise::EFolderPendingOps:

		return _S8("FolderPendingOps");

	case CImImap4Synchronise::EFolderSynchronise:

		return _S8("FolderSynchronise");

	case CImImap4Synchronise::EInboxEarlyDeletes:

		return _S8("InboxEarlyDeletes");

	case CImImap4Synchronise::EFolderEarlyDeletes:

		return _S8("FolderEarlyDeletes");

	case CImImap4Synchronise::EFolderEarlyExpunge:

		return _S8("FolderEarlyExpunge");

	case CImImap4Synchronise::EInboxLateExpunge:

		return _S8("InboxLateExpunge");

	case CImImap4Synchronise::EFolderLateDeletes:

		return _S8("FolderLateDeletes");

	case CImImap4Synchronise::EFolderLateExpunge:

		return _S8("FolderLateExpunge");

#if 0

	case CImImap4Synchronise::EInboxLateNewSync:

		return _S8("InboxLateNewSync");

	case CImImap4Synchronise::EFolderLateNewSync:

		return _S8("FolderLateNewSync");

#endif

	case CImImap4Synchronise::EEndSelectInbox:

		return _S8("EndSelectInbox");

	case CImImap4Synchronise::EInboxLogMessage:

		return _S8("InboxLogMessage");

	case CImImap4Synchronise::EFolderLogMessage:

  		return _S8("FolderLogMessage");

	case CImImap4Synchronise::EStartIdle:

		return _S8("StartIdle");

	case CImImap4Synchronise::ESynchronise:

		return _S8("Synchronise");	

	case CImImap4Synchronise::ESynchroniseTree:

		return _S8("SynchroniseTree");		

	case CImImap4Synchronise::ESynchroniseDeletes:

		return _S8("SynchroniseDeletes");		

		}

	return _S8("Unknown");

	}

#endif

CImImap4Synchronise::CImImap4Synchronise()

	: CMsgActive(1), iState(ESyncStateIdle)

	{

	__DECLARE_NAME(_S("CImImap4Synchronise"));

	}

CImImap4Synchronise::~CImImap4Synchronise()

	{

	// Global bits

	delete iFolderList;

	delete iFolderListDest;

	delete iFolderSync;

	delete iSubscribeList;

	delete iUnsubscribeList;

	delete iOutstandingOps;

	delete iCompound;

	delete iOutstandingMoveTypeDeletes;

	delete iOutstandingLocalDeletes;

	// We don't delete iSession as we don't own it, we were just

	// passed it to use.  similarly iOffLineControl

	}

CImImap4Synchronise* CImImap4Synchronise::NewLC(CImImap4Session *aSession)

	{

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

	CleanupStack::PushL(self);

	// Non-trivial constructor

	self->ConstructL(aSession);

	return self;

	}

CImImap4Synchronise* CImImap4Synchronise::NewL(CImImap4Session *aSession)

	{

	CImImap4Synchronise* self=NewLC(aSession);

	CleanupStack::Pop();

	return self;

	}

// The non-trivial constructor

void CImImap4Synchronise::ConstructL(CImImap4Session *aSession)

	{

	// Save session

	iSession=aSession;

	// We're an active object...

	CActiveScheduler::Add(this);

	// One-off bits

	iFolderList=new (ELeave) CArrayFixFlat<TImImap4SyncList>(16);

	iFolderListDest=new (ELeave) CArrayFixFlat<TImImap4SyncList>(16);

	iFolderSync=CImImap4FolderSync::NewL(iSession);

	iSubscribeList=new (ELeave) CArrayFixFlat<TMsvId>(4);

	iUnsubscribeList=new (ELeave) CArrayFixFlat<TMsvId>(4);

	iOutstandingMoveTypeDeletes=new (ELeave) CArrayFixFlat<TMsvId>(4);

	iOutstandingLocalDeletes=new (ELeave) CArrayFixFlat<TMsvId>(4);

	// Compound operation

	iCompound=CImImap4Compound::NewL(iSession);

	// Make a thread-local timer

	iCheckMailbox.CreateLocal();

	iProgress.iType=EImap4SyncProgressType;

	iIdleBeforeCommand = EFalse;

	}

void CImImap4Synchronise::SetOffLineControl(CImap4OffLineControl* aOffLineControl)

	{

	iOffLineControl = aOffLineControl;

	}

void CImImap4Synchronise::SetUtils(CImap4Utils* aUtils)

	{

	iUtils = aUtils;

	}

// Set the entry to use to talk to the server

void CImImap4Synchronise::SetEntry(CMsvServerEntry* aEntry)

	{

	// Save it

	iEntry=aEntry;

	// Tell compound about it

	iCompound->SetEntry(iEntry);

	}

// Do setentry, leave if there is an error

void CImImap4Synchronise::SetEntryL(const TMsvId aId)

	{

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

	}

// Change entry, leave if error

void CImImap4Synchronise::ChangeEntryL(const TMsvEntry& aEntry)

	{

	User::LeaveIfError(iEntry->ChangeEntry(aEntry));

	}

// Change entry in bulk mode (i.e no index file commit. no notify),

// leave if error

void CImImap4Synchronise::ChangeEntryBulkL(const TMsvEntry& aEntry)

	{

	User::LeaveIfError(iEntry->ChangeEntryBulk(aEntry));

	}

// Get children, leave if error

void CImImap4Synchronise::GetChildrenL(CMsvEntrySelection& aSelection)

	{

	User::LeaveIfError(iEntry->GetChildren(aSelection));

	}

// Given an id of a folder or the service then restore the offline

// operation array out of it. Returns the number of operations in the

// array

TBool CImImap4Synchronise::RefreshOutstandingOpsL(TMsvId aId)

	{

	if (iOutstandingOps)

		{

		delete iOutstandingOps;

		iOutstandingOps=NULL;

		}

	iOutstandingOps = iOffLineControl->OffLineOpArrayL(aId);

	iOutstandingOpsFolder = aId;

	// reset the count

	iProgress.iMsgsToDo = iOutstandingOps->CountOperations();

	iProgress.iMsgsDone = 0;

	iMovedId = KMsvNullIndexEntryId;

	iShadowId = KMsvNullIndexEntryId;

	return iProgress.iMsgsToDo;

	}

// Called when async child completes with an error

#ifdef PRINTING

void CImImap4Synchronise::DoComplete(TInt& aStatus)

#else

void CImImap4Synchronise::DoComplete(TInt& /*aStatus*/)

#endif

	{

	DBG((_L8("CImImap4Synchronise::DoComplete(state=%s, istatus=%d)"),

		 SynchroniseStateString(iState),aStatus));

	// No alteration of the error code

	}

// This routine sets up iShadowId which will be deleted when the

// operation completes successfully

void CImImap4Synchronise::DoOpL(const CImOffLineOperation& aOp)

	{

	iShadowId = iMovedId = KMsvNullIndexEntryId;

	// clean the disconnected op flags and ensure its visible and get

	// an entry copy

	SetEntryL(aOp.MessageId());

	TMsvEmailEntry entry = iEntry->Entry();

	entry.SetVisible(ETrue);

	entry.SetDisconnectedOperation(ENoDisconnectedOperations);

	ChangeEntryBulkL(entry);

	// check and see if there is a shadow and whether it has been

	// removed or marked for deletion

	TBool shadowOK = ETrue;

	if ( aOp.OpType() != CImOffLineOperation::EOffLineOpMtmSpecific &&

		 aOp.OpType() != CImOffLineOperation::EOffLineOpDelete )

		{

		iShadowId = iOffLineControl->FindShadowIdL(aOp);

		shadowOK = iShadowId != KMsvNullIndexEntryId &&

			iEntry->SetEntry(iShadowId) == KErrNone &&

			((TMsvEmailEntry)iEntry->Entry()).DisconnectedOperation() != EDisconnectedDeleteOperation;

		}

	iUtils->ClearLogMessage();

	// Deal with operation

	switch(aOp.OpType())

		{

	case CImOffLineOperation::EOffLineOpCopyToLocal:

		// do the copy, if not a message

		if (entry.iType != KUidMsvMessageEntry ||

			// or the shadow exists

			shadowOK )

			{

			iUtils->SetUpLogMessageL(aOp.MessageId());

			SetActive();

			iCompound->SyncCopyToLocalL(iStatus,aOp.MessageId(),aOp.TargetMessageId());

			}

		break;

	case CImOffLineOperation::EOffLineOpCopyFromLocal:

		if (shadowOK)

			{

			SetActive();

			iSession->Append(iStatus,aOp.MessageId(),aOp.TargetMessageId());

			}

		break;

	case CImOffLineOperation::EOffLineOpCopyWithinService:

		if (shadowOK)

			{

			SetActive();

			iSession->Copy(iStatus,aOp.MessageId(),aOp.TargetMessageId(),EFalse);

			}

		break;

	case CImOffLineOperation::EOffLineOpMoveToLocal:

		if (shadowOK)

			{

			iUtils->SetUpLogMessageL(aOp.MessageId());

			SetActive();

			iCompound->SyncCopyToLocalL(iStatus,aOp.MessageId(),aOp.TargetMessageId());

			}

		// even if the shadow has been removed we still want to delete

		// the original

		iMovedId=aOp.MessageId();

		break;

	case CImOffLineOperation::EOffLineOpMoveFromLocal:

		if (shadowOK)

			{

			SetActive();

			iSession->Append(iStatus,aOp.MessageId(),aOp.TargetMessageId());

			}

		// even if the shadow has been removed we still want to delete

		// the original

		iMovedId=aOp.MessageId();

		break;

	case CImOffLineOperation::EOffLineOpMoveWithinService:

		if (shadowOK)

			{

			SetActive();

			iSession->Copy(iStatus,aOp.MessageId(),aOp.TargetMessageId(),EFalse);

			}

		// even if the shadow has been removed we still want to delete

		// the original, unless the folder itself has been removed

		if (iEntry->SetEntry(aOp.TargetMessageId()) == KErrNone)

			iMovedId=aOp.MessageId();

		break;

	case CImOffLineOperation::EOffLineOpMtmSpecific:

		switch (aOp.MtmFunctionId())

			{

		case EFnOffLineOpPopulate:

			{

			TImap4GetMailOptions options;

			TPckgC<TImap4GetMailOptions> package(options);

			package.Set(aOp.MtmParameters());

			// Copy TImImap4GetMailOptions information into TImImap4GetPartialMailInfo

			TImImap4GetPartialMailInfo imap4GetPartialMailInfo;	

			imap4GetPartialMailInfo.iGetMailBodyParts = package();

			// Set to default

			imap4GetPartialMailInfo.iMaxEmailSize = KMaxTInt;

			// Set the remaining members to default so that the server can check 

			// if these are defaults, then this package is for TImImap4GetMailInfo

			imap4GetPartialMailInfo.iTotalSizeLimit	= KMaxTInt;

			imap4GetPartialMailInfo.iBodyTextSizeLimit = KMaxTInt;

			imap4GetPartialMailInfo.iAttachmentSizeLimit = KMaxTInt;

			imap4GetPartialMailInfo.iPartialMailOptions = ENoSizeLimits;

			TPckgBuf<TImImap4GetPartialMailInfo> partialPackage(imap4GetPartialMailInfo);

			iUtils->SetUpLogMessageL(aOp.MessageId());

			SetActive();

			iSession->FetchBody(iStatus,aOp.MessageId(),partialPackage());

			break;

			}

		default:

			break;

			}

		break;

	case CImOffLineOperation::EOffLineOpDelete:

	default:

		break;

		}

	}

void CImImap4Synchronise::MakeVisibleL(TMsvId aId)

	{

	DBG((_L8("  This folder isn't selectable, just making it visible")));

	// Just make it visible

	SetEntryL(aId);

	TMsvEmailEntry mbcheck=iEntry->Entry();

	do

		{

		// Ensure visibility

		if (!mbcheck.Visible())

			{

			mbcheck.SetVisible(ETrue);

			ChangeEntryBulkL(mbcheck);

			}

		// Move up one

		SetEntryL(mbcheck.Parent());

		mbcheck=iEntry->Entry();

		}

	while(mbcheck.iType!=KUidMsvServiceEntry && mbcheck.Id()!=KMsvRootIndexEntryId);

	}

void CImImap4Synchronise::DonePendingOpL()

	{

	// if we've done one then...

	if (iProgress.iMsgsDone != 0)

		{

		// if this was a move then append a delete

		if (iMovedId != KMsvNullIndexEntryId)

			{

			SetEntryL(iMovedId);

			if (iEntry->Entry().Parent() == iOutstandingOpsFolder)

				{

				DBG((_L8("Append MoveDelete for %x"), iMovedId));

				iOutstandingMoveTypeDeletes->AppendL(iMovedId);

				}

			else

				{

				// if this id was from a MoveFrom (ie its parent is not

				// this folder) then put it in a different pending array

				DBG((_L8("Append LocalDelete for %x"), iMovedId));

				iOutstandingLocalDeletes->AppendL(iMovedId);

				}

			}

		// delete the shadowid if there is one, ignore errors

		if (iShadowId != KMsvNullIndexEntryId &&

			iEntry->SetEntry(iShadowId) == KErrNone &&

			iEntry->SetEntry(iEntry->Entry().Parent()) == KErrNone)

			{

			iEntry->DeleteEntry(iShadowId);

			}

		if (iUtils->SendLogMessageL(KErrNone,iStatus))

			SetActive();

		}

	}

TBool CImImap4Synchronise::NextPendingOpL()

	{

	TBool finished = EFalse;

	// Any operations in outstanding list?

	if (iOutstandingOps->CountOperations())

		{

		DBG((_L8("Outstanding operations on this folder (%d)"),

			 iOutstandingOps->CountOperations()));

		// Fetch operation

		CImOffLineOperation thisop;

		thisop.CopyL(iOutstandingOps->Operation(0));

		// when we get to one of the Delete operations then it is time

		// to stop

		if (thisop.OpType() == CImOffLineOperation::EOffLineOpDelete ||

			(thisop.OpType() == CImOffLineOperation::EOffLineOpMtmSpecific &&

			 thisop.MtmFunctionId() == EFnOffLineOpMoveDelete))

			{

			DBG((_L8("Reached delete op. Finished")));

			finished = ETrue;

			}

		else

			{

			// remove from list and save back

			iOutstandingOps->Delete(0);

			iOffLineControl->SetOffLineOpArrayL(iOutstandingOpsFolder, *iOutstandingOps);

			// and execute

			DoOpL(thisop);

			iProgress.iMsgsDone++;

			}

		}

	else

		{

		// No more operations to do, return to what we should be doing next

		finished = ETrue;

		}

	// when we are about to finish this folder then tidy up

	if (finished)

		{

		// add the list of pending deletes to the front of the

		// offline op array

		for (TInt i = 0; i < iOutstandingMoveTypeDeletes->Count(); i++)

			{

			TMsvId id = (*iOutstandingMoveTypeDeletes)[i];

			TBuf8<128> paramBuf(_L8(""));

			CImOffLineOperation thisop;

			// if we are doing deletes on connection then store this

			// as a delete and we will do all deletes at the end of

			// the sync.

			// if we are doing deletes on disconnection then store

			// this as a special code - it will still get done at end

			// of sync, but real deletes will be done on

			// disconnection.

			if (iPerformDeletes)

				thisop.SetDelete(id);

			else

				thisop.SetMtmSpecificCommandL(id, EFnOffLineOpMoveDelete, 0, paramBuf);

			iOutstandingOps->InsertOperationL(thisop, 0);

			}