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

#include "cimapfolder.h"
#include "cimapsession.h"
#include "cimaplogger.h"
#include "imappaniccodes.h"

#include "mobilitytestmtmapi.h"

CImapCompoundSyncTree::CImapCompoundSyncTree(CImapSyncManager& aSyncManager, CMsvServerEntry& aServerEntry, CImapSettings& aImapSettings)
 : CImapCompoundBase(aSyncManager, aServerEntry, aImapSettings)
	{
	// Set default progress values here so that any progress request before
	// the operation is started returns valid information.
	iProgressState = TImap4GenericProgress::ESyncing;	
	iSyncProgressState = TImap4SyncProgress::ESyncFolderTree;
	}

CImapCompoundSyncTree::~CImapCompoundSyncTree()
	{
	}
	
CImapCompoundSyncTree* CImapCompoundSyncTree::NewL(CImapSyncManager& aSyncManager, CMsvServerEntry& aServerEntry, CImapSettings& aImapSettings)
	{
	CImapCompoundSyncTree* self = new (ELeave) CImapCompoundSyncTree(aSyncManager, aServerEntry, aImapSettings);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

void CImapCompoundSyncTree::ConstructL()
	{
	CActiveScheduler::Add(this);
	}

void CImapCompoundSyncTree::StartOperation(TRequestStatus& aStatus, CImapSession& aSession)
	{
	iSession = &aSession;
	__LOG_TEXT(iSession->LogId(), "CImapCompoundSyncTree::StartOperation()");
	iNextStep = ESyncTree;
	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 CImapCompoundSyncTree::DoRunLoopL()
	{
	SetCurrentStep();
	switch (iCurrentStep)
		{
		case ESyncTree:
			{
			MOBILITY_TEST_MTM_STATE(iImapSettings.ServiceId(), KMobilityTestMtmStateImapSyncFolderTree);
			
			// SyncManager does the tree synchronisation.
			iSyncManager.SynchroniseFolderTreeL(iStatus, *iSession);
			iNextStep = EFinished;
			SetActive();
			break;
			}
			
		case EFinished:
			{
			__LOG_TEXT(iSession->LogId(), "CImapCompoundSyncTree::Completing OK");
			iProgressState = TImap4GenericProgress::EIdle;
			iSyncProgressState = TImap4SyncProgress::EIdle;
			Complete(KErrNone);
			return ETrue;
			}
			
		default:
			{
			__ASSERT_DEBUG(EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::ESyncTreeCompoundUnexpectedState));
			// unexpected state - complete the request
			iProgressState = TImap4GenericProgress::EIdle;
			iSyncProgressState = TImap4SyncProgress::EIdle;
			return ETrue;
			}
		} // end of 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 CImapCompoundSyncTree::DoCancel()
	{
	switch (iCurrentStep)
		{
		case ESyncTree:
			{
			// outstanding request on syncmanager
			iSyncManager.Cancel();
			iNextStep=ESyncTree;
			break;
			}
		case EFinished:
			{
			// self-completed or no outstanding request.
			break;
			}
		case ESuspendedForMigrate:
		default:
			{
			__ASSERT_DEBUG(EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::ESyncTreeCompoundCancelUnexpectedState));
			break;		
			}
		} // end of switch (iCurrentStep)

	// always re-start after migration		
	iNextStep=ESelectSourceMailboxRW;

	if (!iCancelForMigrate)
		{
		// genuine cancel - update progress
		iProgressErrorCode = KErrCancel;
		}
	CMsgActive::DoCancel();	
	}
	
void CImapCompoundSyncTree::Progress(TImap4CompoundProgress& aCompoundProgress)
	{
	aCompoundProgress.iGenericProgress.iOperation = TImap4GenericProgress::ESync;
	aCompoundProgress.iGenericProgress.iState = iProgressState;

	iSyncManager.Progress(aCompoundProgress.iSyncProgress);
	aCompoundProgress.iSyncProgress.iState = iSyncProgressState;

	// 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 not fatal - the error is saved in
the message currently being operated on and the state machine pushed
on to process the next message in the requested selection.

@return KErrNone if the error has been handled
		Completion error code otherwise.
*/
TInt CImapCompoundSyncTree::ProcessNegativeServerResponse()
	{
	TInt err = iStatus.Int();
	switch (iCurrentStep)
		{
		case ESyncTree:
			{
			// Just store the error code in the progress response.
			break;
			}
		case ESuspendedForMigrate:
		case EFinished:
		default:
			{
			// positive error code not expected,
			// self-completed states or no outstanding request.
			TImapServerPanic::ImapPanic(TImapServerPanic::ESyncTreeCompoundUnexpectedState);
			break;
			}
		} // end of switch (iCurrentStep)
	iProgressErrorCode = err;
	return KErrNone;
	}


/**
Resume the operation following a bearer migration.
*/
void CImapCompoundSyncTree::ResumeOperationL(TRequestStatus& aStatus, CImapSession& aSession)
	{
	iSession = &aSession;
	__LOG_TEXT(iSession->LogId(), "CImapCompoundSyncTree::Resuming");
	__ASSERT_DEBUG(iCurrentStep==ESuspendedForMigrate, TImapServerPanic::ImapPanic(TImapServerPanic::ESyncTreeCompoundUnexpectedState));
	iStopForMigrate = EFalse;
	iNextStep = ESyncTree;
	Queue(aStatus);
	CompleteSelf();
	}