// 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 Offline operations.

// 

//

#include "impspan.h"

#include <msventry.h>

#include <imapset.h>

#include <miutset.h>

#include <offop.h>

#include <msvreg.h>

#include <imapcmds.h>

#include "imapsess.h"

#include "imapoffl.h"

#ifdef _DEBUG

#define DBG(a) iSession->LogText a

#define PRINTING

#else

#define DBG(a)

#undef PRINTING

#endif

// ----------------------------------------------------------------------

#ifdef PRINTING

LOCAL_D TPtrC8 OffLineOpTypeString(const CImOffLineOperation& aOp)

	{

	switch (aOp.OpType())

		{

	case CImOffLineOperation::EOffLineOpNone:

		return _L8("None");

	case CImOffLineOperation::EOffLineOpCopyToLocal:

		return _L8("CopyToLocal");

	case CImOffLineOperation::EOffLineOpCopyFromLocal:

		return _L8("CopyFromLocal");

	case CImOffLineOperation::EOffLineOpCopyWithinService:

		return _L8("CopyWithinService");

	case CImOffLineOperation::EOffLineOpMoveToLocal:

		return _L8("MoveToLocal");

	case CImOffLineOperation::EOffLineOpMoveFromLocal:

		return _L8("MoveFromLocal");

	case CImOffLineOperation::EOffLineOpMoveWithinService:

		return _L8("MoveWithinService");

	case CImOffLineOperation::EOffLineOpDelete:

		return _L8("Delete");

	case CImOffLineOperation::EOffLineOpChange:

		return _L8("Change");

	case CImOffLineOperation::EOffLineOpCreate:

		return _L8("Create");

	case CImOffLineOperation::EOffLineOpMtmSpecific:

		switch (aOp.MtmFunctionId())

			{

		case EFnOffLineOpMoveDelete:

			return _L8("MoveDelete");

		case EFnOffLineOpPopulate:

			return _L8("Populate");

		default:

			return _L8("UnknownMtmSpecific");

			}

	default:

		break;

		}

	return _L8("Unknown");

	}

LOCAL_D TPtrC8 Imap4OpTypeString(CImap4OffLineControl::TImap4OpType aOpType)

	{

	switch (aOpType)

		{

	case CImap4OffLineControl::EImap4OpCopyToLocal:

		return _L8("CopyToLocal");

	case CImap4OffLineControl::EImap4OpCopyFromLocal:

		return _L8("CopyFromLocal");

	case CImap4OffLineControl::EImap4OpCopyWithinService:

		return _L8("CopyWithinService");

	case CImap4OffLineControl::EImap4OpMoveToLocal:

		return _L8("MoveToLocal");

	case CImap4OffLineControl::EImap4OpMoveFromLocal:

		return _L8("MoveFromLocal");

	case CImap4OffLineControl::EImap4OpMoveWithinService:

		return _L8("MoveWithinService");

	case CImap4OffLineControl::EImap4OpDelete:

		return _L8("Delete");

	case CImap4OffLineControl::EImap4OpMoveTypeDelete:

		return _L8("MoveDelete");

	case CImap4OffLineControl::EImap4OpPopulate:

		return _L8("Populate");

	default:

		break;

		}

	return _L8("Unknown");

	}

#endif

// ----------------------------------------------------------------------

// construction/destruction routines

CImap4OffLineControl* CImap4OffLineControl::NewL(CMsvServerEntry* aEntry, CImImap4Session *aSession)

	{

	CImap4OffLineControl* self = NewLC(aEntry,aSession);

	CleanupStack::Pop(); // self

	return self;

	}

CImap4OffLineControl* CImap4OffLineControl::NewLC(CMsvServerEntry* aEntry, CImImap4Session *aSession)

	{

	CImap4OffLineControl* self = new (ELeave) CImap4OffLineControl(aEntry,aSession);

	CleanupStack::PushL(self);

	CActiveScheduler::Add(self);

	self->ConstructL();

	return self;

	}

CImap4OffLineControl::CImap4OffLineControl(CMsvServerEntry* aEntry, CImImap4Session *aSession)

	: CMsgActive(EPriorityStandard), iEntry(aEntry), iSession(aSession)

	{

	}

void CImap4OffLineControl::ConstructL()

	{

	iCopyDirect = new (ELeave) CMsvEntrySelection;

	iMoveDirect = new (ELeave) CMsvEntrySelection;

	iMoveToLocalDirect = new (ELeave) CMsvEntrySelection;

	}

CImap4OffLineControl::~CImap4OffLineControl()

	{

	delete iCopyDirect;

	delete iMoveDirect;

	delete iMoveToLocalDirect;

	}

// ----------------------------------------------------------------------

// public routines

// Store an offline copy/move/delete command: we need to determine which

// folder the offline command should be stored in dependent on the

// source of the command.

// CopyToLocal can contain whole messages or parts (but not embedded

// messages). It can also be a copy to NULL, in which case it means

// just populate the mirror

// TODO: Pass in the GetMailOptions to the copy to mirror option

// Any item can contain whole messages, but not folders, and can

// contain shadow ids

void CImap4OffLineControl::StoreOfflineCommandL(TImap4OpType aOperation,

												const CMsvEntrySelection& aSelection,

												TMsvId aDestination,

												TRequestStatus& aStatus)

	{

	TBuf8<128> params = _L8("");

	StoreOfflineCommandL( aOperation, aSelection, aDestination, params, aStatus );

	}

void CImap4OffLineControl::StoreOfflineCommandL(TImap4OpType aOperation,

												const CMsvEntrySelection& aSelection,

												TMsvId aDestination,

												const TDesC8& aParams,

												TRequestStatus& aStatus)

	{

#ifdef PRINTING

	TPtrC8 p = Imap4OpTypeString(aOperation);

	DBG((_L8("StoreOfflineCommand: op %S %d entries to %x param bytes %d"),

		 &p, aSelection.Count(), aDestination, aParams.Length()));

#endif

	Queue(aStatus);

	iDestination = aDestination;

	// work our which service we are dealing with

	iServiceId = ServiceOfL( aOperation == EImap4OpCopyFromLocal ||

							 aOperation == EImap4OpMoveFromLocal ?

							 aDestination : aSelection[0] );

	// clear list of Direct operations to do after storing

	// commands

	iCopyDirect->Reset();

	iMoveDirect->Reset();

	iMoveToLocalDirect->Reset();

	for (TInt i = 0; i < aSelection.Count(); i++)

		{

		CImOffLineOperation op;

		// See if the message is in fact a shadow

		TMsvId origId = aSelection[i];

		SetEntryL(origId);

		TMsvId shadowId = KMsvNullIndexEntryId;

		TMsvId shadowParentId = KMsvNullIndexEntryId;

		TMsvEmailEntry entry = iEntry->Entry();

		if (entry.iRelatedId)

			{

			shadowId = origId;

			shadowParentId = entry.Parent();

			origId = entry.iRelatedId;

			// it is possible that the original has been deleted by

			// now (if it were local). If so then skip this operation

			TInt err = iEntry->SetEntry(origId);

			if (err != KErrNone)

				origId = KMsvNullIndexEntryId;

			else

				entry = iEntry->Entry();

			}

		if (origId != KMsvNullIndexEntryId)

			{

			// entry contains original (not shadow) message details

			// it is an undo type operation if we are copying or moving a

			// shadow back to its original folder and the original is

			// invisible or deleted

			TBool undeleteOp = shadowId != KMsvNullIndexEntryId &&

				entry.Parent() == iDestination &&

				(!entry.Visible() || entry.DisconnectedOperation() == EDisconnectedDeleteOperation);

			// Make operation & save it

			switch(aOperation)

				{

			case EImap4OpCopyToLocal:

				if (undeleteOp)

					{

					UndeleteOperationL(origId, shadowParentId, ETrue);

					}

				else if (IdIsLocalL(origId) || entry.Complete())

					{

					// either direct local copy or copy from mirror of completely populated message

					// either way, add new entry to todo array

					iCopyDirect->AppendL(origId);

					}

				else

					{

					op.SetCopyToLocal(origId,iDestination);

					SaveOperationL(op);

					}

				break;

			case EImap4OpCopyFromLocal:

			case EImap4OpCopyWithinService:

				if (undeleteOp)

					{

					UndeleteOperationL(origId, shadowParentId, ETrue);

					}

				else if (IdIsLocalL(origId))

					{

					op.SetCopyFromLocal(origId,iDestination);

					SaveOperationL(op);

					}

				else

					{

					op.SetCopyWithinService(origId,iDestination);

					SaveOperationL(op);

					}

				break;

			case EImap4OpMoveToLocal:

				if (undeleteOp)

					{

					UndeleteOperationL(origId, shadowParentId, EFalse);

					DeleteEntryL(shadowId);

					}

				else if (IdIsLocalL(origId))

					{

					CImOffLineOperation origOp;

					if (FindOffLineOpByIdL( origId, shadowParentId, origOp, ETrue /* delete op */) == 0)

						User::Leave(KErrNotSupported);

					if ( OffLineOpIsCopy(origOp) )

						// add new local to local copy op

						iCopyDirect->AppendL(origId);

					else

						// direct local move

						iMoveDirect->AppendL(origId);

					DeleteEntryL(shadowId);

					}

				else if (entry.Complete())

					{

					//	Not local, but completely populated

					iMoveToLocalDirect->AppendL(origId);

					}

				else

					{

					op.SetMoveToLocal(origId,iDestination);

					SaveOperationL(op);

					}

				break;

			case EImap4OpMoveFromLocal:

			case EImap4OpMoveWithinService:

				if (undeleteOp)

					{

					UndeleteOperationL(origId, shadowParentId, EFalse);

					// this one can fail depending on what kind of

					// undelete operation it was

					CImOffLineOperation origOp;

					FindOffLineOpByIdL( origId, shadowParentId, origOp, ETrue /* delete op */);

					DeleteEntryL(shadowId);

					}

				else if (shadowId)

					{

					CImOffLineOperation origOp;

					if (FindOffLineOpByIdL( origId, shadowParentId, origOp, ETrue /* delete op */) == 0)

						User::Leave(KErrNotSupported);

					// Clean disconnected flags

					SetEntryL(origId);

					TMsvEmailEntry entry = iEntry->Entry();

					if (entry.DisconnectedOperation() != EDisconnectedMultipleOperation)

						{

						entry.SetDisconnectedOperation(ENoDisconnectedOperations);

						ChangeEntryL(entry);

						}

					// if shadow was the result of a copy then change

					// original copy to point to new destination

					// if shadow was result of a move then change move to

					// point to new destination

					if ( OffLineOpIsCopy(origOp) )

						{

						if (IdIsLocalL(origId))

							op.SetCopyFromLocal(origId,iDestination);

						else

							op.SetCopyWithinService(origId,iDestination);

						}

					else

						{

						if (IdIsLocalL(origId))

							op.SetMoveFromLocal(origId,iDestination);

						else

							op.SetMoveWithinService(origId,iDestination);

						}

					SaveOperationL(op);

					DeleteEntryL(shadowId);

					}

				else

					{

					if (IdIsLocalL(origId))

						op.SetMoveFromLocal(origId,iDestination);

					else

						op.SetMoveWithinService(origId,iDestination);

					SaveOperationL(op);

					}

				break;

			case EImap4OpDelete:

				// we treat shadows and real items the same for deletion

				// currently

				op.SetDelete( shadowId ? shadowId : origId );

				SaveOperationL(op);

				break;

			case EImap4OpUndelete:

				if (shadowId)

					{

					UndeleteOperationL(shadowId, shadowParentId, EFalse);

					}

				else

					{

					// if the entry is not a shadow then we need to

					// replace the disconnected op flags with the original

					// flags before it was deleted.

					CImOffLineOperation origOp;

					// this searches the list before the delete is

					// removed.  However since deletes are stored at

					// the end of the list then if there are any other

					// operations it will return the other, and a

					// count of 2 or greater.

					TInt count = FindOffLineOpByIdL(origId, KMsvNullIndexEntryId, origOp, EFalse);

					TImDisconnectedOperationType disconnectedType = ENoDisconnectedOperations;

					if (count == 2)

						disconnectedType = OffLineOpToDisconnectedOp( origOp );

					else if (count > 2)

						disconnectedType = EDisconnectedMultipleOperation;

					UndeleteOperationL(origId, KMsvNullIndexEntryId, EFalse, disconnectedType);

					}

				break;

			case EImap4OpPopulate:

				/* easy one, just populate the original */

				op.SetMtmSpecificCommandL(origId, iDestination, EFnOffLineOpPopulate, aParams);

				SaveOperationL(op);

				break;

			case EImap4OpMoveTypeDelete:

				__ASSERT_DEBUG(0, gPanic(EBadUseOfImap4Op));

				break;

				}

			}

		}

	// if there are entries left over then they are ones we added to

	// be done immediately

	if (!DoLocalOpL())

		{

		// Request has been queued, complete immediately

		Complete(KErrNone);

		}

	}

// Cancel offline operations queued in the folders/service mentioned

// in the selection

void CImap4OffLineControl::CancelOffLineOperationsL(const CMsvEntrySelection& aSelection)

	{

	DBG((_L8("CancelOfflineOperations: %d entries"), aSelection.Count()));

	for (TInt i = 0; i < aSelection.Count(); i++)

		{

		TMsvId id = aSelection[i];

		SetEntryL(id);

		TMsvEmailEntry entry = iEntry->Entry();

		if (entry.iType == KUidMsvFolderEntry)

			{

			CImOffLineOperationArray* array = OffLineOpArrayL(id);

			CleanupStack::PushL(array);

			if (array->CountOperations())

				{

				// remove the queued ops

				while (array->CountOperations())

					{

					CImOffLineOperation thisOp;

					thisOp.CopyL(array->Operation(0));

					UndoOfflineOpL(thisOp, ETrue);

					array->Delete(0);

					}

				// write back empty array to store

				SetOffLineOpArrayL(id, *array);

				}

			CleanupStack::PopAndDestroy(); // array

			}

#if 0

		else

			{

			CImOffLineOperation op;

			while (FindOffLineOpByIdL(id, KMsvNullIndexEntryId, op, ETrue))

				{

				CMsvEntrySelection* selection=new (ELeave) CMsvEntrySelection;

				CleanupStack::PushL(selection);

				}

			CleanupStack::PopAndDestroy(); // selection

			}

#endif

		}

	}

// ----------------------------------------------------------------------

TImDisconnectedOperationType CImap4OffLineControl::OffLineOpToDisconnectedOp(const CImOffLineOperation& aOp)

	{

	TImDisconnectedOperationType type;

	switch (aOp.OpType())

		{

	case CImOffLineOperation::EOffLineOpMoveToLocal:

		type = EDisconnectedMoveToOperation;

		break;

	case CImOffLineOperation::EOffLineOpMoveFromLocal:

		type = EDisconnectedMoveFromOperation;

		break;

	case CImOffLineOperation::EOffLineOpMoveWithinService:

		type = EDisconnectedMoveWithinServiceOperation;

		break;

	case CImOffLineOperation::EOffLineOpCopyToLocal:

		type = EDisconnectedCopyToOperation;

		break;

	case CImOffLineOperation::EOffLineOpCopyFromLocal:

		type = EDisconnectedCopyFromOperation;

		break;

	case CImOffLineOperation::EOffLineOpCopyWithinService:

		type = EDisconnectedCopyWithinServiceOperation;

		break;

	case CImOffLineOperation::EOffLineOpDelete:

		type = EDisconnectedDeleteOperation;

		break;

	case CImOffLineOperation::EOffLineOpMtmSpecific:

		type = EDisconnectedSpecialOperation;

		break;

	default: