// 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 <msventry.h>

#include <miutset.h>

#include <imapset.h>

#include "cimapofflinecontrol.h"

#include "cimaplogger.h"

#ifdef __IMAP_LOGGING

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(CImapOfflineControl::TImap4OpType aOpType)

	{

	switch (aOpType)

		{

	case CImapOfflineControl::EImap4OpCopyToLocal:

		return _L8("CopyToLocal");

	case CImapOfflineControl::EImap4OpCopyFromLocal:

		return _L8("CopyFromLocal");

	case CImapOfflineControl::EImap4OpCopyWithinService:

		return _L8("CopyWithinService");

	case CImapOfflineControl::EImap4OpMoveToLocal:

		return _L8("MoveToLocal");

	case CImapOfflineControl::EImap4OpMoveFromLocal:

		return _L8("MoveFromLocal");

	case CImapOfflineControl::EImap4OpMoveWithinService:

		return _L8("MoveWithinService");

	case CImapOfflineControl::EImap4OpDelete:

		return _L8("Delete");

	case CImapOfflineControl::EImap4OpMoveTypeDelete:

		return _L8("MoveDelete");

	case CImapOfflineControl::EImap4OpPopulate:

		return _L8("Populate");

	default:

		break;

		}

	return _L8("Unknown");

	}

#endif

EXPORT_C CImapOfflineControl* CImapOfflineControl::NewL(CMsvServerEntry& aEntry)

	{

	CImapOfflineControl* self = new (ELeave) CImapOfflineControl(aEntry);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CImapOfflineControl::CImapOfflineControl(CMsvServerEntry& aEntry)

	: CMsgActive(EPriorityStandard), iEntry(aEntry) 

	{

	CActiveScheduler::Add(this);

	}

void CImapOfflineControl::ConstructL()

	{

	iCopyDirect = new (ELeave) CMsvEntrySelection;

	iMoveDirect = new (ELeave) CMsvEntrySelection;

	iMoveToLocalDirect = new (ELeave) CMsvEntrySelection;

	}

CImapOfflineControl::~CImapOfflineControl()

	{

	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

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

 contain shadow ids

*/

EXPORT_C void CImapOfflineControl::StoreOfflineCommandL(TImap4OpType aOperation,

												const CMsvEntrySelection& aSelection,

												TMsvId aDestination,

												TRequestStatus& aStatus)

	{

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

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

	}

EXPORT_C void CImapOfflineControl::StoreOfflineCommandL(TImap4OpType aOperation,

												const CMsvEntrySelection& aSelection,

												TMsvId aDestination,

												const TDesC8& aParams,

												TRequestStatus& aStatus)

	{

#ifdef __IMAP_LOGGING

	TPtrC8 p = Imap4OpTypeString(aOperation);

	__LOG_FORMAT((KDefaultLog,"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();

	//update the progress info

	iProgressMsgsToDo=aSelection.Count();

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

		{

		CImOffLineOperation* op = new(ELeave)CImOffLineOperation();

		CleanupStack::PushL(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:

				iRequestedOperation=TImap4GenericProgress::EOffLineCopyToLocal;

				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 array

					iCopyDirect->AppendL(origId);

					}

				else

					{

					op->SetCopyToLocal(origId,iDestination);

					SaveOperationL(*op);

					}

				break;

			case EImap4OpCopyFromLocal:

				iRequestedOperation=TImap4GenericProgress::EOffLineCopyFromLocal;

			case EImap4OpCopyWithinService:

				iRequestedOperation=TImap4GenericProgress::EOffLineCopyWithinService;

				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:

				iRequestedOperation=TImap4GenericProgress::EOffLineMoveToLocal;

				if (undeleteOp)

					{

					UndeleteOperationL(origId, shadowParentId, EFalse);

					DeleteEntryL(shadowId);

					}

				else if (IdIsLocalL(origId))

					{

					CImOffLineOperation* origOp = new(ELeave)CImOffLineOperation();

					CleanupStack::PushL(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);

					CleanupStack::PopAndDestroy(origOp);

					}

				else if (entry.Complete())

					{

					//	Not local, but completely populated

					iMoveToLocalDirect->AppendL(origId);

					}

				else

					{

					op->SetMoveToLocal(origId,iDestination);

					SaveOperationL(*op);

					}

				break;

			case EImap4OpMoveFromLocal:

				iRequestedOperation=TImap4GenericProgress::EOffLineMoveFromLocal;

			case EImap4OpMoveWithinService:

				iRequestedOperation=TImap4GenericProgress::EOffLineMoveWithinService;

				if (undeleteOp)

					{

					UndeleteOperationL(origId, shadowParentId, EFalse);

					// this one can fail depending on what kind of

					// undelete operation it was

					CImOffLineOperation* origOp = new(ELeave)CImOffLineOperation();

					CleanupStack::PushL(origOp);

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

					DeleteEntryL(shadowId);					

					CleanupStack::PopAndDestroy(origOp);

					}

				else if (shadowId)

					{

					CImOffLineOperation* origOp = new(ELeave)CImOffLineOperation();

					CleanupStack::PushL(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);

					CleanupStack::PopAndDestroy(origOp);

					}

				else

					{

					if (IdIsLocalL(origId))

						op->SetMoveFromLocal(origId,iDestination);

					else

						op->SetMoveWithinService(origId,iDestination);

					SaveOperationL(*op);

					}

				break;

			case EImap4OpDelete:

				iRequestedOperation=TImap4GenericProgress::EOffLineDelete;

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

				// currently

				op->SetDelete( shadowId ? shadowId : origId );

				SaveOperationL(*op);

				break;

			case EImap4OpUndelete:

				iRequestedOperation=TImap4GenericProgress::EOffLineUndelete;

				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 = new(ELeave)CImOffLineOperation();

					CleanupStack::PushL(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);

					CleanupStack::PopAndDestroy(origOp);

					}

				++iProgressMsgsDone; // this is normally done in SaveOperationL() but the undelete op does not use that method.

				break;

			case EImap4OpPopulate:

				iRequestedOperation=TImap4GenericProgress::EOffLinePopulate;

				/* easy one, just populate the original */

				op->SetMtmSpecificCommandL(origId, iDestination, EFnOffLineOpPopulate, aParams);

				SaveOperationL(*op);

				break;

			case EImap4OpMoveTypeDelete:

				__ASSERT_DEBUG(0, User::Invariant());

				break;

				}

			}

		CleanupStack::PopAndDestroy(op);

		} // end of for loop

	// 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

EXPORT_C void CImapOfflineControl::CancelOffLineOperationsL(const CMsvEntrySelection& aSelection)

	{

	__LOG_FORMAT((KDefaultLog, "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 = new(ELeave)CImOffLineOperation();

					CleanupStack::PushL(thisOp);

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

					UndoOfflineOpL(*thisOp, ETrue);

					array->Delete(0);

					CleanupStack::PopAndDestroy(thisOp);

					}

				// write back empty array to store

				SetOffLineOpArrayL(id, *array);

				}

			CleanupStack::PopAndDestroy(); // array

			}

		}

	}

TImDisconnectedOperationType CImapOfflineControl::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:

		type = EDisconnectedUnknownOperation;

		break;

		}

	return type;

	}

// This returns TRUE is it is a strict copy operation. Populate can be

// considered False by the callers of this function.