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

#include "cimapopfetchbody.h"

#include "cimapsessionconsts.h"

#include "cimapsession.h"

#include "cimapsyncmanager.h"

#include "cimapfolder.h"

#include "cimaplogger.h"

#include "cimapcompoundcopytolocal.h"

#include "cimapmailstore.h" 

#include <imapset.h>

CImapIdleController::CImapIdleController(MImapIdleControllerObserver& aObserver, CImapSession*& aSession, CImapSyncManager& aSyncManager, CMsvServerEntry& aServerEntry, CImapSettings& aImapSettings, CImapMailStore& aImapMailStore)

 : CActive(EPriorityStandard), iObserver(aObserver), iSession(aSession), iSyncManager(aSyncManager), iServerEntry(aServerEntry), iImapSettings(aImapSettings), iImapMailStore(aImapMailStore)

	{

	}

CImapIdleController::~CImapIdleController()

	{

	// This is should be the only place where CImapIdleController should Cancel() on itself

	// instead of calling InternalCancelAndSetState()

	Cancel();

	delete iReissueTimer;

	delete iCopyToLocal;

	}

CImapIdleController* CImapIdleController::NewL(MImapIdleControllerObserver& aObserver, CImapSession*& aSession, CImapSyncManager& aSyncManager, CMsvServerEntry& aServerEntry, CImapSettings& aImapSettings, CImapMailStore& aImapMailStore)

	{

	CImapIdleController* self = new (ELeave) CImapIdleController(aObserver, aSession, aSyncManager, aServerEntry, aImapSettings, aImapMailStore);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

Secondary construction

*/	

void CImapIdleController::ConstructL()

	{

	iReissueTimer = CImapObservableTimer::NewL(*this);

	// Add to the active scheduler

	CActiveScheduler::Add(this);

	}

/**

Requests idle in the inbox, using the imap session object

passed at construction.

Completes synchronously. The IDLE state is entered 

asynchronously in the background.

*/

void CImapIdleController::StartIdle()

	{

	__ASSERT_DEBUG(iSession!=NULL, TImapServerPanic::ImapPanic(TImapServerPanic::EIdleSessionIsNull));

	__LOG_TEXT(iSession->LogId(), "CImapIdleController::StartIdle()");

	__ASSERT_DEBUG(iState==EFinished, TImapServerPanic::ImapPanic(TImapServerPanic::EIdleControllerUnexpectedStateAtStart));

	__ASSERT_DEBUG(!IsActive(), TImapServerPanic::ImapPanic(TImapServerPanic::EIdleControllerIsActiveAtStart));

	// Check whether we are going to use IDLE or issue a "dummy read"

	TBool idleSupported=iSession->ImapIdleSupported();

	TBool idleEnabled=iImapSettings.ImapIdle();

	iUsingIdle = idleSupported && idleEnabled;

	iState = EStartingIdle;

	iStoppingIdle = EFalse;

	// Complete self to enter state machine

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

	SetActive();

	}

/**

Asynchronously stops the outstanding idle request.

@param aStatus - Signals completion of the request

*/

void CImapIdleController::StopIdle(TRequestStatus& aStatus)

	{

	__LOG_FORMAT((iSession->LogId(), "CImapIdleController::StopIdle() State = %d", iState));

	iStoppingIdle = ETrue;

	Queue(aStatus);

	switch (iState)

		{

	case EFinished:

		{

		// not in IDLE state, complete immediately

		Complete(KErrNone);

		break;

		}

	case EIdling:

		{

		// currently idling - cancel the outstanding request

		// then issue the DONE command to the remote server.

		InternalCancelAndSetState(EWaitingForDone);

		iSession->DoneIdle(iStatus);

		SetActive();

		break;

		}

	case EWaitingForServerEvent:

		{

		// "Dummy Read" previously issued. This needs to be

		// cancelled and flushed before continuing.

		InternalCancelAndSetState(EWaitingForFlush);

		iSession->FlushCancelledCommand(iStatus);

		SetActive();

		break;

		}

	case ESyncFetching:

		{

		// bring the download-rules controlled fetch to a

		// premature halt... The message currently being fetched

		// will not be resumed on next rules-based sync

		__LOG_TEXT(iSession->LogId(), "CImapIdleController: Stopping a rules-based fetch to allow requested operation");

		InternalCancelAndSetState(EWaitingForFlush);

		iSession->FlushCancelledCommand(iStatus);

		SetActive();

		break;

		}

	case EStartingIdle:

	case ESelectingInbox:

	case EWaitingForContinuation:

	case EWaitingForFlush:

	case EWaitingForDone:

	case ESynchronising:

	default:

		{

		// no action required, stop request will be completed

		// when the appropriate state reached.

		break;

		}

		} // end switch (iState)

	}

/**

Called when an asynchronous service request completes.

*/

void CImapIdleController::RunL()

	{

	// RunL() should never be called while doing an internal cancel

	__ASSERT_DEBUG(iInternalCancel==EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::EIdleControllerRunLCalledDuringInternalCancel));

	TInt status = iStatus.Int();

	if (status!=KErrNone)

		{

		// Something has gone wrong.

		// Tell the Protocol Controller about it.

		if (iReport==NULL)

			{

			// error must have occurred while in IDLE. Inform the idle

			// observer. Otherwise errors are reported via Complete().

			iObserver.OnIdleError(status);

			// We need to exit immediately because reporting the error to the

			// protocol controller will mean that it deletes us.

			return;

			}

		}

	else

		{

		TRAPD(error, DoRunL());

		__ASSERT_DEBUG(error==KErrNone || !IsActive(), TImapServerPanic::ImapPanic(TImapServerPanic::EIdleControllerLeaveInDoRunL));

		if (IsActive())

			{

			// requeued

			return;

			}

		status=error;

		}

	Complete(status);

	}

void CImapIdleController::DoRunL()

	{

	if (!iStoppingIdle)

		{

		RunContinueL();

		}

	else

		{

		// Stop request has been received

		RunStopL();

		}

	}

/**

Continue the idle state machine

*/

void CImapIdleController::RunContinueL()

	{

	__LOG_FORMAT((iSession->LogId(), "CImapIdleController::RunContinueL() State = %d", iState));

	switch (iState)

		{

		case EStartingIdle:

			{

			// state machine entry point - select the inbox.

			iSyncManager.Inbox()->SelectL(iStatus, *iSession);

			iState = ESelectingInbox;

			break;

			}

		case ESelectingInbox:

			{

			// inbox selected

			if (SyncRequired())

				{

				// inbox has changed since last sync, kick off sync

				iSyncManager.Inbox()->SynchroniseL(iStatus, *iSession, EFalse, ETrue);

				iState = ESynchronising;

				}

			// resume any fetch operation if there is anything to do...

			else if (!DoBodyDownloadL())

				{

				// otherwise, issue the idle command

				GoIdleL();

				}

			break;

			}

		case EWaitingForContinuation:

			{

			// idle continuation response received

			if (SyncRequired())

				{

				// if the folder wants to sync, call DONE first then sync

				iSession->DoneIdle(iStatus);

				iState = EWaitingForDone;

				}

			else

				{

				EnterIdlingState();

				}

			break;

			}

		case EIdling:

			{

			// idling event has occurred

			if (SyncRequired())

				{

				// if the folder wants to sync, call DONE first then sync

				iSession->DoneIdle(iStatus);

				iState = EWaitingForDone;

				iReissueTimer->Cancel();

				}

			else

				{

				// otherwise, re-issue WaitForIdleEvent

				iSession->WaitForIdleEvent(iStatus);

				iState = EIdling;

				}

			break;

			}

		case EWaitingForServerEvent:

			{

			// an unsolicited event has occurred

			if (SyncRequired())

				{

				// idling event has occurred

				iSyncManager.Inbox()->SynchroniseL(iStatus, *iSession, EFalse, ETrue);

				iState = ESynchronising;

				iReissueTimer->Cancel();

				}

			else

				{

				// otherwise, return to dummy read

				GoIdleL();

				}

			break;

			}

		case EWaitingForFlush:

		case EWaitingForDone:

			{

			// waiting for done/flush but not stopping: either an event has

			// occurred in IDLE or the reissue timer must have expired.

			if (SyncRequired())

				{

				// idling event has occurred

				iSyncManager.Inbox()->SynchroniseL(iStatus, *iSession, EFalse, ETrue);

				iState = ESynchronising;

				}

			else

				{

				// No change - re-issue idle. 

				// This will occur if the idle timer has expired.

				GoIdleL();			

				}

			break;

			}

		case ESynchronising:

			{

			// 1st phase (header) synchronise has completed, do content fetch if configured.

			if (!DoBodyDownloadL())

				{

				// content fetch not configured or nothing to fetch

				// Sync any changes, or go idle.

				if (SyncRequired())

					{

					// an event seems to have happened during the sync - sync again

					iSyncManager.Inbox()->SynchroniseL(iStatus, *iSession, EFalse, ETrue);

					iState = ESynchronising;

					}

				else

					{

					// otherwise, re-issue the idle command

					GoIdleL();

					}

				}

			break;

			}

		case ESyncFetching:

			{

			// 2nd phase synchronise has completed,

			delete iCopyToLocal;

			iCopyToLocal = NULL;

			if (SyncRequired())

				{

				// an event seems to have happened during the sync - sync again

				iSyncManager.Inbox()->SynchroniseL(iStatus, *iSession, EFalse, ETrue);

				iState = ESynchronising;

				}

			else

				{

				// otherwise, re-issue the idle command

				GoIdleL();

				}

			break;

			}

		case EFinished:

		default:

			{

			// these are unexpected states.

			return;

			}

		} // end switch (iState)

	SetActive();

	}

/**

Starts second-phase download of body content according to provisioned

download rules, if enabled, rules defined and any messages to fetch.

Otherwise, causes the CImapIdleController object to self-complete.

@return ETrue if body content download has been started. 

        SetActive() must be called following an ETrue return

*/

TBool CImapIdleController::DoBodyDownloadL()

	{

	TBool fetchStarted = EFalse;

	// are download rules being used? otherwise, self complete.

	if (iImapSettings.UseSyncDownloadRules())

		{

		// are rules defined for the inbox? otherwise, self complete

		TImImap4GetPartialMailInfo mailInfo;

		if (KErrNotFound != iImapSettings.GetSyncDownloadRuleL(CImapSyncDownloadRules::EInboxRulesType, mailInfo))

			{

			// build a selection of messages to fetch

			CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;

			CleanupStack::PushL(selection);

			// anything to fetch? otherwise, self complete

			TInt msgsToFetch = iSyncManager.Inbox()->GetFetchMessageChildrenL(*selection);

			if (msgsToFetch>0)

				{

				__LOG_FORMAT((iSession->LogId(), "CImapIdleController: Starting rules-based Fetch of %d messages", msgsToFetch));

				delete iCopyToLocal;

				iCopyToLocal = NULL;

				// Create the compound operation object

				iCopyToLocal = CImapCompoundCopyToLocal::NewL(iSyncManager, 

				                    			               iServerEntry, 

				                                			   iImapSettings,

				                                			   iImapMailStore, 

				                                               EFalse,

				                                               *selection,

				                                               KMsvNullIndexEntryId,

				                                               mailInfo);

				iCopyToLocal->StartOperation(iStatus, *iSession);

				iState = ESyncFetching;

				fetchStarted = ETrue;

				}

			CleanupStack::PopAndDestroy(selection);

			}

		}

	return fetchStarted;

	}

/**

If IDLE is supported and configured for use, then the IDLE command is

issued to the server. Otherwise the session is configured to perform

a read of any information that arrives at the server. 

SetActive() must be called after calling this method.

*/

void CImapIdleController::GoIdleL()

	{

	if (iUsingIdle)

		{

		__LOG_TEXT(iSession->LogId(), "CImapIdleController: Using IDLE");

		// issue the idle command

		iSession->EnterIdleL(iStatus);

		iState = EWaitingForContinuation;

		}

	else

		{

		// Otherwise, request notification of unsolicited server events

		// This is referred to as a "dummy read".

		__LOG_TEXT(iSession->LogId(), "CImapIdleController: Using Dummy Read");

		iSession->WaitForServerEventL(iStatus);

		iState = EWaitingForServerEvent;

		}

	}

/**

Stop the idle state machine

*/

void CImapIdleController::RunStopL()

	{

	__LOG_FORMAT((iSession->LogId(), "CImapIdleController::RunStopL() State = %d", iState));

	switch (iState)

		{

	case EWaitingForContinuation:

		{

		// StopIdle() was called after the IDLE was issued, but before

		// the continuation response had been received.

		// Need to cancel the IDLE state and issue the DONE command;

		InternalCancelAndSetState(EWaitingForDone);

		iSession->DoneIdle(iStatus);

		SetActive();

		break;

		}

	case EWaitingForServerEvent:

		{

		// Cancel the "dummy read" request and flush any data in the pipes

		InternalCancelAndSetState(EWaitingForFlush);

		iSession->FlushCancelledCommand(iStatus);

		SetActive();

		break;

		}

	case EFinished:			// unexpected

	case EStartingIdle:		// almost possible

	case ESelectingInbox:	// possible (StopIdle() called in ESelectingInbox)

	case EWaitingForFlush:	// expected (StopIdle() called in EWaitingForServerEvent)

	case EWaitingForDone:	// expected (StopIdle() called in EIdling)

	case EIdling:			// unexpected (state exited in StopIdle())

	case ESynchronising:	// possible (StopIdle() called in ESynchronising)

	case ESyncFetching:     // possible StopIdle() while doing bg fetch

	default:

		{

		// Nothing more needs to be done in these states - the session is

		// now ready to be used.

		__LOG_TEXT(iSession->LogId(), "CImapIdleController::Idle stopped OK");

		iState=EFinished;

		Complete(KErrNone);

		break;

		}

		} // end switch (iState)

	}

/**

Called by Cancel() to cancel asynchronous service requests

*/

void CImapIdleController::DoCancel()

	{

	iReissueTimer->Cancel();

	switch (iState)

		{

		case EIdling:

		case ESelectingInbox:

		case EWaitingForContinuation:

		case EWaitingForServerEvent:

		case EWaitingForFlush:

		case EWaitingForDone:

			{

			// outstanding request is on the imap session

			iSession->Cancel();

			break;

			}

		case ESynchronising:

			{

			// outstanding request is on the folder

			iSyncManager.Inbox()->Cancel();

			break;

			}

		case ESyncFetching:

			{

			if (iCopyToLocal)

				{

				iCopyToLocal->CancelEnableResume();

				delete iCopyToLocal;

				iCopyToLocal = NULL;

				break;

				}

			}

		case EStartingIdle:

		case EFinished:

		default: