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

#include "cimapcompounddisconnect.h"

#include "cimapfolder.h"

#include "cimapfolderinfo.h"

#include "cimapsession.h"

#include "cimapsessionmanager.h"

#include "cimapcompoundsyncservice.h"

#include "cimaplogger.h"

#include "imappaniccodes.h"

#include "mobilitytestmtmapi.h"

CImapCompoundDisconnect::CImapCompoundDisconnect( CImapSyncManager& aSyncManager,

						 				  		  CMsvServerEntry& aServerEntry,

						 				  		  CImapSettings& aImapSettings,

						 				  		  CImapSessionManager& aSessionManager,

						 				  		  CImapMailStore& aImapMailStore,

						 				  		  const RPointerArray<CImapSession>& aSessionList,

						 				  		  CImapOfflineControl& aImapOfflineControl,

						 				  		  TBool aDoDeletes  )

 : CImapCompoundBase(aSyncManager, aServerEntry, aImapSettings ),

   iSessionManager(aSessionManager), iSessionList(aSessionList), iImapMailStore(aImapMailStore),iImapOfflineControl(aImapOfflineControl), iDoDeletes(aDoDeletes)

	{

	}

CImapCompoundDisconnect::~CImapCompoundDisconnect()

	{

	delete iCompoundSync;

	}

CImapCompoundDisconnect* CImapCompoundDisconnect::NewL( CImapSyncManager& aSyncManager,

						 				  				CMsvServerEntry& aServerEntry,

						 				  				CImapSettings& aImapSettings, 

						   								CImapSessionManager& aSessionManager,

						   								CImapMailStore& aImapMailStore,

						   								const RPointerArray<CImapSession>& aSessionList,

						   								CImapOfflineControl& aImapOfflineControl,

						   								TBool aDoDeletes  )

	{

	CImapCompoundDisconnect* self = new ( ELeave ) CImapCompoundDisconnect( aSyncManager,

																			aServerEntry,

																			aImapSettings,

																			aSessionManager,

																			aImapMailStore,

																			aSessionList,

																			aImapOfflineControl,

																			aDoDeletes );

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CImapCompoundDisconnect::ConstructL()

	{

	CActiveScheduler::Add(this);

	iCompoundSync = CImapCompoundSyncService::NewL(iSyncManager, 

										    	   iServerEntry, 

										    	   iImapSettings,

										    	   iImapMailStore,

										    	   iImapOfflineControl,

										    	   ETrue);

	}

/**

Starts tha compound object by setting the active object active

@param aStatus

@param aSessionManager Reference to the session manager that is used to disconnect

@param aSessionList List of all connected sessions that need to be disconnected

*/

void CImapCompoundDisconnect::StartOperation(TRequestStatus& aStatus, CImapSession& aSession)

	{

	iSession = &aSession;

	__LOG_TEXT(iSession->LogId(), "CImapCompoundDisconnect::StartOperation()");

	if(iImapSettings.DeleteEmailsWhenDisconnecting() && iDoDeletes)

		iNextStep = EInboxLateDeletes;

	else

		iNextStep = EDisconnect;

	Queue(aStatus);

	CompleteSelf();

	}

/**

Handles the compound operation state machine

@return ETrue if compound operation is completed, 

		EFalse otherwise (will be called again, unless active)

*/

TBool CImapCompoundDisconnect::DoRunLoopL()

	{

	SetCurrentStep();

	switch (iCurrentStep)

		{

		case EInboxLateDeletes:  // asynchronous

			{

			MOBILITY_TEST_MTM_STATE(iImapSettings.ServiceId(), KMobilityTestMtmStateImapDisconnect1); // Sync'ing deletes

			iCompoundSync->StartOperation(iStatus, *iSession);

			iProgressState = TImap4GenericProgress::EDisconnecting;

			iNextStep = EDisconnect;

			SetActive();

			break;

			}

		case EDisconnect:  // asynchronous

			{

			MOBILITY_TEST_MTM_STATE(iImapSettings.ServiceId(), KMobilityTestMtmStateImapDisconnect2); // disconnecting

			iSessionManager.Disconnect( iStatus, iSessionList );

			iProgressState = TImap4GenericProgress::EDisconnecting;

			iNextStep = EFinished;

			SetActive();

			break;

			}

		case EFinished:  // finished

			{

			__LOG_TEXT(iSession->LogId(), "CImapCompoundDisconnect::Completing OK");

			iProgressState = TImap4GenericProgress::EDisconnected;

			Complete(KErrNone);

			return ETrue;

			}

		default:

			{

			__ASSERT_DEBUG(EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::EDisconnectCompoundUnexpectedState));

			// unexpected state - complete the request

			iProgressState = TImap4GenericProgress::EIdle;

			return ETrue;

			}

		} // end switch (iCurrentStep)

	return EFalse;

	}

/**

May be called in case of a genuine cancel or a cancel for migrate.

Following a genuine cancel, the compound operation will be deleted.

Following a cancel for migrate, the compound operation will be resumed,

so the iNextState is updated here to ensure the operation is

correctly restarted.

In either case, CMsgActive::DoCancel() is called to complete the

user request with KErrCancel.

Note that if the default CMsgActive::DoComplete() is overridden,

then that must also be modified to handle either case described above.

*/

void CImapCompoundDisconnect::DoCancel()

	{

	switch (iCurrentStep)

		{

		case EInboxLateDeletes:

			{

			iCompoundSync->Cancel();

			break;

			}

		case EDisconnect:

			{

			iProgressState = TImap4GenericProgress::EDisconnecting;

			iSessionManager.Cancel();

			break;

			}

		case EFinished:

			{

			// self-completed or no outstanding request.

			iProgressState = TImap4GenericProgress::EDisconnected;

			break;

			}

		case ESuspendedForMigrate:

		default :

			{

			__ASSERT_DEBUG(EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::EDisconnectCompoundCancelUnexpectedState));

			iProgressState = TImap4GenericProgress::EIdle;

			break;

			}

		} // end switch (iCurrentStep)

	// shouldn't be restarted after a migrate (in fact, should have 

	// just been cancelled normally), but if it is, then just cut to

	// the finish on resume.

	iNextStep = EFinished;

	if (!iCancelForMigrate)

		{

		// genuine cancel - update progress

		iProgressErrorCode = KErrCancel;

		}

	CMsgActive::DoCancel();

	}

void CImapCompoundDisconnect::Progress(TImap4CompoundProgress& aCompoundProgress)

	{

	aCompoundProgress.iGenericProgress.iOperation = TImap4GenericProgress::EDisconnect;

	aCompoundProgress.iGenericProgress.iState = iProgressState;

	// Put error into progress buffer

	if( aCompoundProgress.iGenericProgress.iErrorCode == KErrNone )

		{

		aCompoundProgress.iGenericProgress.iErrorCode = iProgressErrorCode;

		}

	}

/**

Handles NO/BAD responses according to current step.

Negative server responses are considered fatal during disconnect.

@return KErrGeneral

*/

TInt CImapCompoundDisconnect::ProcessNegativeServerResponse()

	{

	iProgressErrorCode = iStatus.Int();

	return KErrGeneral;

	}

/**

Protocol Controller shouldn't attempt to resume a disconnect!

So this completes with KErrDisconnected.

*/

void CImapCompoundDisconnect::ResumeOperationL(TRequestStatus& aStatus, CImapSession& aSession)

	{

	iSession = &aSession;

	__LOG_TEXT(iSession->LogId(), "CImapCompoundDisconnect::Resuming");

	__ASSERT_DEBUG(EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::EDisconnectCompoundCancelUnexpectedState));

	iStopForMigrate = EFalse;

	Queue(aStatus);

	Complete(KErrDisconnected);

	}