// Copyright (c) 2008-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 <imapset.h>

#include <mentact.h>

#include <miut_err.h>

#include "cimapprotocolcontroller.h"

#include "cimapsettings.h"

#include "cimapsessionmanager.h"

#include "cimapsession.h"

#include "cimapsessionconsts.h"

#include "cimapmailstore.h" 

#include "cimapofflinecontrol.h"

#include "cimapsyncmanager.h"

#include "cimapfolder.h"

#include "cimapcompoundcopyfromlocal.h"

#include "cimapcompoundcopytolocal.h"

#include "cimapcompoundcopywithinservice.h"

#include "cimapcompoundcreate.h"

#include "cimapcompounddelete.h"

#include "cimapcompounddeletefolder.h"

#include "cimapcompounddisconnect.h"

#include "cimapcompoundrename.h"

#include "cimapcompoundselect.h"

#include "cimapcompoundsyncfolder.h"

#include "cimapcompoundsynctree.h"

#include "cimapcompoundsyncservice.h"

#include "cimapopbackgroundsync.h"

#include "cimapidlecontroller.h"

#include "cimapupdateflagoperation.h"

#include "cimaplogger.h"

#include "mobilitytestmtmapi.h"

// at the moment we do not need more than 2 sessions

const TInt KImapSessionArrayGranularity = 2;

const TUid KUidImapServerMtm = {0x10003C4E};

CImapProtocolController::CImapProtocolController(CMsvServerEntry& aEntry,CImapOfflineControl& aImapOfflineControl):

	CMsgActive(EPriorityStandard),

	iEntry(aEntry),

	iImapSessionArray(KImapSessionArrayGranularity),

	iImapOfflineControl(aImapOfflineControl)

	{

	}

CImapProtocolController::~CImapProtocolController()

	{

	Cancel();

	// The mail store needs to be deleted before DisconnectAll() as its destructor

	// uses the session that DisconnectAll() destroys.

	delete iImapMailStore;	

	//serviceid indicates that we are online

	if(iServiceId!=0)

		{

		DisconnectAll();

		}

	delete iBackgroundSyncOp;

	delete iImapCompound;

	delete iMigrateCompound;

	delete iImapSyncManager;

	delete iImapIdleController;

	delete iImapSettings;

	delete iMobilityManager;

	// Need to destroy the sessions before the session manager is deleted.

	// This is because session manager will cleanup transport handler code,

	// and it is important to ensure that the sockets are not being used

	// by the session when that happens.

	iImapSessionArray.ResetAndDestroy();

	delete iImapSessionManager;

	}

EXPORT_C CImapProtocolController* CImapProtocolController::NewL(CMsvServerEntry& aEntry,CImapOfflineControl& aImapOfflineControl)

	{

	CImapProtocolController* self = new (ELeave) CImapProtocolController(aEntry,aImapOfflineControl);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

Part of two phase construction

Note that syncmanager is not constructed until a connection is made.

*/

void CImapProtocolController::ConstructL()

	{

	iImapSettings       = CImapSettings::NewL(iEntry);

	iImapMailStore 		= CImapMailStore::NewL(iEntry);

	iImapSessionManager = CImapSessionManager::NewL(*iImapSettings, *iImapMailStore);

	iFlushPrimary = EFalse;

	// We're an active object...

	CActiveScheduler::Add(this);

	}

/**

Query connection status - return true if at least one IMAP Session exists and is 

connected. Also return true if migrating.

This is not a compound operation.

@return 

*/

EXPORT_C TBool CImapProtocolController::Connected() const

	{

	if (iImapSessionArray.Count() > 0 || iMigrateState != ENotMigrating)

		{

		// Sessions are deleted if a disconnect is observed,

		// therefore the existance of any sessions indicates 

		// that the Protocol Controller is connected.

		return ETrue;

		}

	return EFalse;

	}

/**

If a connected session already exists, this API shall complete immediately with 

KErrServerBusy. Otherwise, this API uses the IMAP Session Manager to create and connect 

an IMAP Session object that can be used for subsequent commands.

On successful connection, the passed request status is completed. This API can not 

be used to instantiate further IMAP Session objects.

Sequence For Connect

	CreateSession

	SelectInboxRW

	Finished

@param aStatus

@param aSelection

@leave KErrServerBusy if a connected session already exists

*/

EXPORT_C void CImapProtocolController::ConnectL( TRequestStatus& aStatus,

												 CMsvEntrySelection& aSelection )

	{

	__LOG_TEXT(KDefaultLog, "CImapProtocolController::ConnectL()");

	ResetProgress();

	if (Connected())

		{

		// Do not call Complete() - this would result in the Protocol

		// Controller disconnecting all sessions.

		TRequestStatus* pStatus = &aStatus;

		User::RequestComplete(pStatus, KErrServerBusy);

		}

	else

		{

		// Load the Service Settings

		iServiceId = aSelection[0];

		iImapSettings->LoadSettingsL(iServiceId);

		// We're going online - create a session manager if none exists

		if (iImapSessionManager==NULL)

			{

			// session manage may have been deleted due to a mobility error

			iImapSessionManager = CImapSessionManager::NewL(*iImapSettings, *iImapMailStore);

			}

		// create a sync manager

		delete iImapSyncManager;

		iImapSyncManager = NULL;

		iImapSyncManager = CImapSyncManager::NewL( iEntry, *iImapSettings);

		// create the mobility manager if mobility supported

		delete iMobilityManager;

		iMobilityManager = NULL;

		if (iImapSettings->BearerMobility())

			{

			iMobilityManager = CImMobilityManager::NewL(KUidImapServerMtm, iServiceId, *this);

			}

		// Create the primary session pointer

		CImapSession* imapSession = NULL;

		iImapSessionArray.AppendL(imapSession);

		// Request the session manager to connect the session

		iImapSessionManager->GetSessionL(iStatus, iImapSessionArray[0]);

		iForegroundSession = 0;

		iRequestedOp = EConnect;

		iCurrentOp = iRequestedOp;

		Queue(aStatus);

		SetActive();

		}

	}

/**

This method allows the client to connect to an IMAP account and initialise a 

background synchronisation of the account once connection has completed. If a 

connected IMAP Session already exists, the API shall complete immdediately with 

KErrServerBusy. 

On successful connection, a background synchronisation is started and the passed 

request status is completed. The background synchronisation is processed by a 

CImapBackgroundSyncOp object, which will notify the Protocol Controller that 

the process has completed via a callback function void 

BackgroundSyncCompleted( TInt aError )

Sequence For ConnectAndSynchronise

	CreateSession

	StartBackgroundSyncOp

	Finished

@param aStatus

@param aSelection

@leave KErrServerBusy if a connected session already exists

*/

EXPORT_C void CImapProtocolController::ConnectAndSynchroniseL( TRequestStatus& aStatus, 

															   CMsvEntrySelection& aSelection )

	{

	__LOG_TEXT(KDefaultLog, "CImapProtocolController::ConnectAndSynchroniseL()");

	// Issue the connect request (this will cause ResetProgress() to be called)

	ConnectL(aStatus, aSelection);

	// Create the Background Sync Operation object

	if (IsActive())

		{

		__ASSERT_DEBUG(iBackgroundSyncOp==NULL, TImapServerPanic::ImapPanic(TImapServerPanic::EConnectAndSyncBgSyncOpIsNotNull));

		iBackgroundSyncOp = CImapOpBackgroundSync::NewL(*this, iEntry, *iImapSyncManager, *iImapSettings, *iImapMailStore, iImapOfflineControl);

		}

	}

/**

Logs out and disconnects all connected sessions with the remote server.

Disconnect request is handled and acted upon during migration, unlike other 

client-requested operations which are rejected (with KErrServerBusy).

The Bearer Mobility Manager is deleted prior to acting on this request,

effectively de-registering the server MTM from the mobility framework

@param aStatus

*/

EXPORT_C void CImapProtocolController::DisconnectL(TRequestStatus& aStatus)

	{

	__LOG_TEXT(KDefaultLog, "CImapProtocolController::DisconnectL()");

	__ASSERT_DEBUG(iImapCompound==NULL, TImapServerPanic::ImapPanic(TImapServerPanic::EDisconnectCompoundIsNotNull));

	// de-register for mobility notifications

	delete iMobilityManager;

	iMobilityManager = NULL;

	// Disconnect allowed to happen even if we are migrating...

	switch (iMigrateState)

		{

		case ENotMigrating:

		case EHandlingConnectError:

			{

			// normal behaviour...

			DoDisconnectL(aStatus);

			break;

			}

		case EConnectingAfterMigrate: // Cancel connecting of new session

		case EStartingReconnect:	  // already disconnected. Cancel dummy request

		case EWaitingForNewCarrier:   // already disconnected. Cancel dummy request

		case EWaitingInitialCarrierRejected: // already disconnected. Cancel dummy request

			{

			Cancel();

			// mark offline and complete

			DisconnectAll();

			Queue(aStatus);

			Complete(KErrNone);

			break;

			}

		case EDisconnectingForMigrate:

			{

			// already doing a graceful disconnect, switch to main state machine.

			iMigrateState = ENotMigrating;

			iRequestedOp  = EDisconnect;

			iCurrentOp    = EDisconnect;

			// however, using the iMigrateCompound pointer...

			iImapCompound = iMigrateCompound;

			iMigrateCompound = NULL;

			Queue(aStatus);

			break;

			}

		case EWaitingForOpToComplete:

		case EWaitingForOpToStop:

		default:

			{

			__ASSERT_DEBUG(iBackgroundSyncOp==NULL, TImapServerPanic::ImapPanic(TImapServerPanic::EDisconnectUnexpectedMigrateState));

			break;

			}

		}

	}

void CImapProtocolController::DoDisconnectL(TRequestStatus& aStatus)

	{

	// Unlike the other async methods, DisconnectL() will wait for any flush operation to finish

	// and then initiate the disconnect.

	// Consequently there is no need to call CompleteIfBackgroundOpInProgress()	

	ResetProgress();

	iImapCompound = CImapCompoundDisconnect::NewL( *iImapSyncManager, 

												   iEntry, 

												   *iImapSettings,

												   *iImapSessionManager,

												   *iImapMailStore,

												   iImapSessionArray,

												   iImapOfflineControl,

												   ETrue );

	iRequestedOp = EDisconnect;

	if (iCurrentOp != ECancelRecoverPrimary)

		{

		// Cancel any outstanding background sync												   

		if (iBackgroundSyncOp!=NULL)

			{

			iBackgroundSyncOp->Cancel();

			delete iBackgroundSyncOp;

			iBackgroundSyncOp=NULL;

			// Flush the session, now that it has been cancelled

			iCurrentOp = ECancelRecoverPrimary;

			CImapSession* session = iImapSessionArray[0];

			session->FlushCancelledCommand(iStatus);

			SetActive();

			}

		else

			{

			StartPrimaryOperation();	

			SetActive();	

			}

		}

	// NOTE: In the case of iCurrentOp == ECancelRecoverPrimary, DoRunL() will start the async 

	// iImapCompound operation after the flush has completed.

	// The iImapCompound will expect aStatus to have been queued so that it can be Completed later.

	Queue(aStatus);

	}

/**

Checks the status of the CImapSessions

@return ETrue if a backgroundsync is in progress and the second session is busy,

		EFalse otherwise.

*/

EXPORT_C TBool CImapProtocolController::Busy() const

	{

	// second session is busy if a compound operation exists.

	if (BackgroundSyncInProgress() && iImapCompound!=NULL)

		{

		return ETrue;

		}

	return EFalse;	

	}

/**

Gets the access point ID in use for the connection to the server

@param aIap On return stores the access point ID value

@return KErrNone if successful, or a system wide error code

*/

EXPORT_C TInt CImapProtocolController::GetAccessPointIdForConnection(TUint32& aAccessPointId) const

	{

	if (iImapSessionManager)

		{

		return iImapSessionManager->GetAccessPointIdForConnection(aAccessPointId);

		}

	return KErrNotFound;

	}

/**

Returns whether a Background synchronisation is in progress

@return ETrue if a Background synchronisation is in progress, EFalse otherwise

*/

EXPORT_C TBool CImapProtocolController::BackgroundSyncInProgress() const

	{

	return (iBackgroundSyncOp != NULL);

	}

/**

Cancels an outstanding background synchronise operation. Calls 

CImapOpBackgroundSync::Cancel() to propagate the cancel and kicks off

an asynchronous cleanup operation.

The cancel request is completed immediately with KErrNone if no background

sync was in operation, otherwise it is completed with KErrCancel when

the cleanup process is complete.

*/	

EXPORT_C void CImapProtocolController::CancelBackgroundSync(TRequestStatus& aStatus)

	{

	__LOG_TEXT(KDefaultLog, "CImapProtocolController::CancelBackgroundSync()");

	ResetProgress();

	Queue(aStatus);

	if (BackgroundSyncInProgress())

		{

		if (iMigrateState != ENotMigrating && iBackgroundSyncOp->IsSuspendedForMigrate())

			{

			delete iBackgroundSyncOp;

			iBackgroundSyncOp = NULL;

			Complete(KErrCancel);

			}

		else

			{

			iBackgroundSyncOp->CancelAndCleanup();

			iWaitForBackgroundSync = ETrue;

			}

		}

	else

		{

		Complete(KErrNone);

		}

	}

/**

Wait for background sync operation to complete. This effectively makes a background 

synchronise a foreground operation blocking subsequent Server MTM requests until the 

synchonise is completed.

@param aStatus

*/

EXPORT_C void CImapProtocolController::WaitForBackground(TRequestStatus& aStatus)

	{

	__LOG_TEXT(KDefaultLog, "CImapProtocolController::WaitForBackground()");

	ResetProgress();

	Queue(aStatus);

	// Wait for background operation to complete: is one running?

	if (!BackgroundSyncInProgress())

		{

		// No, complete immediately

		Complete(KErrNone);

		}

	else

		{

		// Otherwise, wait for completion

		iWaitForBackgroundSync = ETrue;

		}

	}

/**

Completes the passed request status if a background operation is in progress,

or if the primary session is being recovered following a cancel operation.

This should be called prior to starting a compound operation that requires the

primary session to be performed.

This method must be called before assigning iRequestedOp, 

for any operation that requires the primary session.

@return ETrue if the user request has been completed

		EFalse otherwise.

*/

TBool CImapProtocolController::CompleteIfBackgroundOpInProgress(TRequestStatus& aStatus)

	{

	__LOG_TEXT(KDefaultLog, "CImapProtocolController::CompleteIfBackgroundOpInProgress()");

	if (BackgroundSyncInProgress() || iCurrentOp==ECancelRecoverPrimary || iMigrateState!=ENotMigrating)

		{

		// Complete the user request

		// Do not call Complete() - this would result in the Protocol

		// Controller disconnecting all sessions.

		TRequestStatus* status = &aStatus;

		User::RequestComplete(status, KErrServerBusy);

		return ETrue;

		}

	return EFalse;

	}

/**

Synchronise Folder Tree - calls CImapSyncManager::SynchroniseTreeL()

Sequence For SynchroniseTree

	StopIdle

	SynchroniseTree // CImapSyncManager Operation

@param aStatus

@leave

*/	

EXPORT_C void CImapProtocolController::SynchroniseTreeL(TRequestStatus& aStatus)

	{

	__LOG_TEXT(KDefaultLog, "CImapProtocolController::SynchroniseTreeL()");

	__ASSERT_DEBUG(iImapCompound==NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ESynchroniseTreeCompoundIsNotNull));

	ResetProgress();

	if (!CompleteIfBackgroundOpInProgress(aStatus))	

		{

		iImapCompound = CImapCompoundSyncTree::NewL( *iImapSyncManager, 

													 iEntry, 

													 *iImapSettings );

		iRequestedOp = ESync;

		StartPrimaryOperation();	

		Queue(aStatus);

		SetActive();

		}

	}

/**

Perform a full account synchronisation - calls CImapSyncManager::SynchroniseL()

Sequence For SynchroniseAll

	StopIdle

	SynchroniseL  // CImapSyncManager Operation

@param aStatus