// 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 "cimap4servermtm.h"

#include "cimapofflinecontrol.h"

#include "cimapprotocolcontroller.h"

#include "cimaplogger.h"

#include <e32std.h>

#include <imapset.h>

#include <imapcmds.h>

#include <mentact.h>

#include <msventry.h>	// CMsvServerEntry

#include <tmsvsystemprogress.h>

#if (defined SYMBIAN_USER_PROMPT_SERVICE)

#include "cimapupsresponsewaiter.h"

#endif 

#ifdef __IMAP_LOGGING

_LIT(KDefaultLogFileName, "imaplog");

#endif //__IMAP_LOGGING

/**

Static constructor for the server MTM. The server MTMs default constructor is 

private hence this method must be called to instantiate the class.

@param aRegisteredMtmDll

@param aEntry

@return A pointer to the newly created CImap4ServerMtm object. The caller is 

responsible for cleanup

*/

EXPORT_C CImap4ServerMtm* CImap4ServerMtm::NewL( CRegisteredMtmDll& aRegisteredMtmDll,

										   		 CMsvServerEntry* aEntry )

	{

	CImap4ServerMtm* self = new ( ELeave ) CImap4ServerMtm( aRegisteredMtmDll, 

															aEntry );		

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

	}

/**

CImap4ServerMtm constructor

@param aRegisteredMtmDll

@param aEntry

*/

CImap4ServerMtm::CImap4ServerMtm( CRegisteredMtmDll& aRegisteredMtmDll, 

								  CMsvServerEntry* aServerEntry) :

 CBaseServerMtm( aRegisteredMtmDll, aServerEntry ), iServerEntry (aServerEntry)

	{

	}

/**

CImap4SeverMtm destructor

*/	

CImap4ServerMtm::~CImap4ServerMtm()

	{

	__LOG_TEXT(KDefaultLog, "CImap4ServerMtm::~CImap4ServerMtm()");

	Cancel();

	delete iImapProtocolController;

	delete iImapOfflineControl;

	__LOG_CLOSE(KDefaultLog);

	CImapUtils::Delete();

#if (defined SYMBIAN_USER_PROMPT_SERVICE)

	delete iWaiter;

#endif		

	}

/**

CImap4ServerMtm second phase constructor

*/	

void CImap4ServerMtm::ConstructL()

	{

	CImapUtils::CreateL();

	__LOG_CREATE_DEFAULT(KDefaultLogFileName);

	iImapOfflineControl = CImapOfflineControl::NewL( *iServerEntry );

	iImapProtocolController = CImapProtocolController::NewL( *iServerEntry , *iImapOfflineControl);

#if (defined SYMBIAN_USER_PROMPT_SERVICE)

	iWaiter = CImapUpsResponseWaiter::NewL(*iServerEntry, *iImapProtocolController);

	iHasCapability = ETrue;

#endif	

	// We need to see invisible entries

	TMsvSelectionOrdering invisible;

	invisible=iServerEntry->Sort();

	invisible.SetShowInvisibleEntries(ETrue);

	iServerEntry->SetSort(invisible);

	// Add us to the scheduler

	CActiveScheduler::Add( this );

	}

/**

This command is used to copy a message to a local folder. This may be 

the local mirror of the IMAP folder, i.e. the local representation of 

the online IMAP folder as it exists on the remote server, or a local 

service folder (eg the global inbox) in which case the message is fetched 

completely to the mirror folder then copied to the destination folder. 

This command results in an entire message being fetched, as it fetches 

according to the default parameters, which are:

iTotalSizeLimit = KMaxTInt

iBodyTextSizeLimit = KMaxTInt

iAttachmentSizeLimit = KMaxTInt

iGetMailBodyParts = EGetImap4EmailBodyTextAndAttachments	 

iPartialMailOptions = ENoSizeLimits

iDestinationFolder = <target destination>

This command can result in additional IMAP sessions being instantiated. 

As it is a "read only" operation (ie, the contents of the remote server 

are not updated as a result of performing this operation) it is safe to 

perform such fetches while a background sync is in progress.

@param aSelection The selection of message TMsvIds that are copied.

@param aDestination The TMsvId of the destination folder.

@param aStatus The request status to be completed when the operation has finished.

*/

void CImap4ServerMtm::CopyToLocalL( const CMsvEntrySelection& aSelection, 

				  					TMsvId aDestination, 

				  					TRequestStatus& aStatus )

	{

	__LOG_TEXT(KDefaultLog, "CImap4ServerMtm::CopyToLocalL()");

	if (!iImapProtocolController->Connected())

		{

		iState = EMtmStateOffLineCopyToLocal;

		CImapOfflineControl::TImap4OpType opType=CImapOfflineControl::EImap4OpCopyToLocal;

		iImapOfflineControl->StoreOfflineCommandL(opType, aSelection, aDestination, iStatus);

		}

	else

		{

		iState = EMtmStateCopyToLocal;

		iImapProtocolController->CopyToLocalL(iStatus, aSelection, aDestination);

		}	

	Queue(aStatus);

	SetActive();										   

	}

/**

CopyFromLocalL appends entire messages in the mirror to the server.

@param aSelection The selection of message TMsvIds that are copied.

@param aDestination The TMsvId of the destination folder.

@param aStatus The request status to be completed when the operation has finished.

*/

void CImap4ServerMtm::CopyFromLocalL( const CMsvEntrySelection& aSelection,

								      TMsvId aDestination, 

				   					  TRequestStatus& aStatus )

	{

	__LOG_TEXT(KDefaultLog, "CImap4ServerMtm::CopyFromLocalL()");

	// Check the destination folder is a mailbox

	User::LeaveIfError(iServerEntry->SetEntry(aDestination));

	TMsvEmailEntry destination = iServerEntry->Entry();

	if (!destination.Mailbox())

		{

		Queue(aStatus);

		User::RequestComplete(iRequest, KErrNotSupported);

		return;

		}

	if (!iImapProtocolController->Connected())

		{

		iState = EMtmStateOffLineCopyFromLocal;

		CImapOfflineControl::TImap4OpType opType=CImapOfflineControl::EImap4OpCopyFromLocal;

		iImapOfflineControl->StoreOfflineCommandL(opType, aSelection, aDestination, iStatus);

		}

	else

		{

		iState = EMtmStateCopyFromLocal;

		iImapProtocolController->CopyFromLocalL(iStatus, aSelection, aDestination);

		}	

	Queue(aStatus);

	SetActive();

	}

/**

CopyWithinService copies entire messages to other folders on the server, 

using the IMAP COPY command.

@param aSelection The selection of message TMsvIds that are copied.

@param aDestination The TMsvId of the destination folder.

@param aStatus The request status to be completed when the operation has finished.

*/

void CImap4ServerMtm::CopyWithinServiceL( const CMsvEntrySelection& aSelection, 

							 			  TMsvId aDestination, 

							 			  TRequestStatus& aStatus )

	{

	__LOG_TEXT(KDefaultLog, "CImap4ServerMtm::CopyWithinServiceL()");

	// Check the destination folder is a mailbox

	User::LeaveIfError(iServerEntry->SetEntry(aDestination));

	TMsvEmailEntry destination = iServerEntry->Entry();

	if (!destination.Mailbox())

		{

		Queue(aStatus);

		User::RequestComplete(iRequest, KErrNotSupported);

		return;

		}

	if (!iImapProtocolController->Connected())

		{

		iState = EMtmStateOffLineCopyWithinService;

		CImapOfflineControl::TImap4OpType opType=CImapOfflineControl::EImap4OpCopyWithinService;

		iImapOfflineControl->StoreOfflineCommandL(opType, aSelection, aDestination, iStatus);

		}

	else

		{

		iState = EMtmStateCopyWithinService;

		iImapProtocolController->CopyWithinServiceL(iStatus, aSelection, aDestination);

		}	

	Queue(aStatus);

	SetActive();

	}

/**

MoveToLocalL moves a message from the remote server to a local folder: this 

is performed as a fetch, then a delete on the remote server.

@param aSelection The selection of message TMsvIds that are moved.

@param aDestination The TMsvId of the destination folder.

@param aStatus The request status to be completed when the operation has finished.

*/

void CImap4ServerMtm::MoveToLocalL( const CMsvEntrySelection& aSelection, 

				  	   			    TMsvId aDestination, 

				  	   				TRequestStatus& aStatus )

	{

	__LOG_TEXT(KDefaultLog, "CImap4ServerMtm::MoveToLocalL()");

	if (!iImapProtocolController->Connected())

		{

		iState = EMtmStateOffLineMoveToLocal;

		CImapOfflineControl::TImap4OpType opType=CImapOfflineControl::EImap4OpMoveToLocal;

		iImapOfflineControl->StoreOfflineCommandL(opType, aSelection, aDestination, iStatus);

		}

	else

		{

		iState = EMtmStateMoveToLocal;

		iImapProtocolController->MoveToLocalL(iStatus, aSelection, aDestination);

		}	

	Queue(aStatus);

	SetActive();

	}

/**

MoveFromLocalL does a CopyFromLocal (ie, IMAP APPEND of the message), then 

deletes the local message if it was sucessful.

@param aSelection The selection of message TMsvIds that are moved.

@param aDestination The TMsvId of the destination folder.

@param aStatus The request status to be completed when the operation has finished.

*/

void CImap4ServerMtm::MoveFromLocalL( const CMsvEntrySelection& aSelection,

						 			  TMsvId aDestination, 

						 			  TRequestStatus& aStatus )

	{

	__LOG_TEXT(KDefaultLog, "CImap4ServerMtm::MoveFromLocalL()");

	// Check the destination folder is a mailbox

	User::LeaveIfError(iServerEntry->SetEntry(aDestination));

	TMsvEmailEntry destination = iServerEntry->Entry();

	if (!destination.Mailbox())

		{

		Queue(aStatus);

		User::RequestComplete(iRequest, KErrNotSupported);

		return;

		}

	if (!iImapProtocolController->Connected())

		{

		iState = EMtmStateOffLineMoveFromLocal;

		CImapOfflineControl::TImap4OpType opType=CImapOfflineControl::EImap4OpMoveFromLocal;

		iImapOfflineControl->StoreOfflineCommandL(opType, aSelection, aDestination, iStatus);

		}

	else

		{

		iState = EMtmStateMoveFromLocal;

		iImapProtocolController->MoveFromLocalL(iStatus, aSelection, aDestination);

		}	

	Queue(aStatus);

	SetActive();

	}

/**

MoveWithinServiceL copies entire messages to other folders on the server, 

using the IMAP COPY command. If the copy was successful, the original is deleted, 

resulting in a move operation having been performed.

@param aSelection The selection of message TMsvIds that are moved.

@param aDestination The TMsvId of the destination folder.

@param aStatus The request status to be completed when the operation has finished.

*/

void CImap4ServerMtm::MoveWithinServiceL( const CMsvEntrySelection& aSelection, 

										  TMsvId aDestination, 

										  TRequestStatus& aStatus )

	{

	__LOG_TEXT(KDefaultLog, "CImap4ServerMtm::MoveWithinServiceL()");

	// Check the destination folder is a mailbox

	User::LeaveIfError(iServerEntry->SetEntry(aDestination));

	TMsvEmailEntry destination = iServerEntry->Entry();

	if (!destination.Mailbox())

		{

		Queue(aStatus);

		User::RequestComplete(iRequest, KErrNotSupported);

		return;

		}

	if (!iImapProtocolController->Connected())

		{

		iState = EMtmStateOffLineMoveWithinService;

		CImapOfflineControl::TImap4OpType opType=CImapOfflineControl::EImap4OpMoveWithinService;

		iImapOfflineControl->StoreOfflineCommandL(opType, aSelection, aDestination, iStatus);

		}

	else

		{

		iState = EMtmStateMoveWithinService;

		iImapProtocolController->MoveWithinServiceL(iStatus, aSelection, aDestination);

		}	

	Queue(aStatus);

	SetActive();

	}

/**

Can be used to delete a selection of messages, a selection of folders, or 

local parts of a message. The intention of the user is inferred from the

entry type at location 0 of the passed CMsvEntrySelection.

@param aSelection

@param aStatus

*/

void CImap4ServerMtm::DeleteAllL( const CMsvEntrySelection& aSelection, 

								  TRequestStatus& aStatus )

	{

	__LOG_TEXT(KDefaultLog, "CImap4ServerMtm::DeleteAllL()");

	if (PruneMessages(aSelection, aStatus))

		{

		// Was this call to DeleteAllL an instruction to delete local parts of a message ?

		// If so then we don't need to continue. PruneMessages will complete the outstanding request.

		return;

		}

	// Not a prune of local messages. 

	// Is the first entry a message or a folder?			

	User::LeaveIfError(iServerEntry->SetEntry(aSelection[0]));

	if (iServerEntry->Entry().iType==KUidMsvMessageEntry)

		{

		if (!iImapProtocolController->Connected())

			{

			iState = EMtmStateOffLineDelete;

			CImapOfflineControl::TImap4OpType opType=CImapOfflineControl::EImap4OpDelete;

			iImapOfflineControl->StoreOfflineCommandL(opType, aSelection,  KMsvNullIndexEntryId, iStatus);

			}

		else

			{

			iState = EMtmStateDelete;

			iImapProtocolController->DeleteL(iStatus, aSelection);

			}

		}

	else if (iServerEntry->Entry().iType==KUidMsvFolderEntry)

		{

		// no offline support for delete folder

		if (!iImapProtocolController->Connected())

			{

			Queue(aStatus);

			User::RequestComplete(iRequest, KErrDisconnected);

			return;

			}

		else

			{

			iState = EMtmStateDeleteFolder;

			iImapProtocolController->DeleteFolderL(iStatus, aSelection);

			}

		}

	else

		{

		TImapServerPanic::ImapPanic(TImapServerPanic::EDeleteOfUnknownType);

		}

	Queue(aStatus);

	SetActive();

	}

/**

Create: make a folder or mailbox.

Only supported when online.

@param aNewEntry The Details of the folder or mailbox to be created.

@param aStatus The request status to be completed when the operation has finished.

*/

void CImap4ServerMtm::CreateL( TMsvEntry aNewEntry,

							   TRequestStatus& aStatus )

	{

	__LOG_TEXT(KDefaultLog, "CImap4ServerMtm::CreateL()");

	// Creating a folder?

	if (aNewEntry.iType!=KUidMsvFolderEntry)

		{

		// No - illegal op

		Queue(aStatus);

		User::RequestComplete(iRequest, KErrNotSupported);

		return;

		}

	// Not supported as an offline operation

	if (!iImapProtocolController->Connected())

		{

		Queue(aStatus);

		User::RequestComplete(iRequest, KErrDisconnected);

		return;

		}

	TBool isfolder = ETrue;

	if ( ((TMsvEmailEntry)aNewEntry).Mailbox() )

		{

		isfolder = EFalse;

		}

	iImapProtocolController->CreateL(iStatus, aNewEntry.Parent(), aNewEntry.iDetails, isfolder);

	iState = EMtmStateCreateFolder;

	Queue(aStatus);

	SetActive();

	}

/**

This command has been recinded, and is replaced by IMAP Client MTM command 

KIMAP4MTMRenameFolder

This command has been recinded,

and is replaced by IMAP Client MTM command KIMAP4MTMRenameFolder

@param aNewEntry The Details of the folder or mailbox to be renamed.

@param aStatus The request status to be completed when the operation has finished.

*/

void CImap4ServerMtm::ChangeL( TMsvEntry aNewEntry, TRequestStatus& aStatus ) 

	{

	__LOG_TEXT(KDefaultLog, "CImap4ServerMtm::ChangeL()");

	TMsvEmailEntry origEntry = iServerEntry->Entry();

	TMsvEntry *newEntry1 = new (ELeave) TMsvEntry;

	CleanupStack::PushL(newEntry1);

	TMsvEmailEntry newEntry = (TMsvEmailEntry) aNewEntry;

	TMsvEmailEntry *newEntry2= new (ELeave) TMsvEmailEntry();

	CleanupStack::PushL(newEntry2);

	if(origEntry.Id() != aNewEntry.Id())

		{

		iServerEntry->GetEntryFromId(aNewEntry.Id(), newEntry1);

		newEntry2 = (TMsvEmailEntry*) newEntry1;

		origEntry = newEntry;

		}

	else

		{

		newEntry2 = &newEntry;

		}

	TBool flagChanged = EFalse;

	if((origEntry.SeenIMAP4Flag()!= newEntry2->SeenIMAP4Flag())

	 || (origEntry.UnreadIMAP4Flag()!=newEntry2->UnreadIMAP4Flag())

	 || (origEntry.Unread()!=newEntry2->Unread())

	 || (origEntry.New()!=newEntry2->New()))

		{	

		flagChanged = ETrue;

		}

	User::LeaveIfError(iServerEntry->SetEntry(aNewEntry.Id()));

	User::LeaveIfError(iServerEntry->ChangeEntry(aNewEntry));

	//if not offline

	if (iImapProtocolController->Connected() && flagChanged)

		{

		//to update read/unread flags at remote server

		iImapProtocolController->UpdateFlagL(iStatus);	

  	 	iState= EMtmStateUpdateFlag;

  	 	Queue(aStatus);

		SetActive();	

		}

	else

		{

		Queue(aStatus);

		User::RequestComplete(iRequest, KErrNone);

		}

	CleanupStack::PopAndDestroy(2);

	}

/**