// Copyright (c) 1999-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 "imaptests.h"

#include <imapconnectionobserver.h>

#include <cemailaccounts.h>

#include <iapprefs.h>

//Provides access to Settings flag for seen flag tests 

LOCAL_D CImImap4Settings* isaveSettings;

_LIT(KImapAccountName, "IMAP");

// Strings....

_LIT(KErrUseService, "[%4d] Error! you have to select a service for use before you can access it!");

//

//

// CImapClientTest

//

CImapClientTest* CImapClientTest::NewL(CEmailTestUtils& aTestUtils, RTest& aTest)

	{

	CImapClientTest* self = new (ELeave) CImapClientTest(aTestUtils, aTest);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CImapClientTest::~CImapClientTest()

	{

	}

void CImapClientTest::ConstructL()

	{

	CEmailClientTest::ConstructL();

	}

CImapClientTest::CImapClientTest(CEmailTestUtils& aTestUtils, RTest& aTest) : CEmailClientTest(aTestUtils, aTest)

	{

	}

//

//

// CCreateImapService

//

void CCreateImapService::StartL(TRequestStatus& aStatus)

	{

	// create imap account

	CEmailAccounts* account = CEmailAccounts::NewLC();

	CImIAPPreferences* imapIAP = CImIAPPreferences::NewLC();

	iSettings->SetDisconnectedUserMode(ETrue);

	iSettings->SetSynchronise(EUseLocal);

	iSettings->SetSubscribe(EUpdateNeither);	

	TImapAccount accountId = account->CreateImapAccountL(*iDetails, *iSettings, *imapIAP,EFalse);

	//save settings address

	isaveSettings = iSettings;

	// get imap service for the account

	TMsvId service = accountId.iImapService;

	// select this service

	CMsvEntry& msvEntry = *(iTestHarness.EmailTestUtils().iMsvEntry);

	msvEntry.SetEntryL(service);

	iEntry = msvEntry.Entry();

	iTestHarness.iCurrentServiceId = service;

	iTestHarness.EmailTestUtils().iImapServiceId = service;

	CleanupStack::PopAndDestroy(2, account); // imapIAP, account

	if(iTestHarness.EmailTestUtils().iImapClientMtm == NULL)

		iTestHarness.EmailTestUtils().InstantiateImapClientMtmL();

	else // no need to create a new one, reuse the existing one

		iTestHarness.EmailTestUtils().iImapClientMtm->SwitchCurrentEntryL(iTestHarness.iCurrentServiceId);

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, KErrNone);

	}

CCreateImapService* CCreateImapService::NewL(CEmailClientTest& aTestHarness)

	{

	CCreateImapService* self = new (ELeave) CCreateImapService(aTestHarness);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CCreateImapService::CCreateImapService(CEmailClientTest& aTestHarness) : CCreateEmailService(aTestHarness), iTestHarness(aTestHarness)

	{

	}

void CCreateImapService::ConstructL()

	{

	iSettings = new(ELeave) CImImap4Settings();

	}

CCreateImapService::~CCreateImapService()

	{

	delete iSettings;

	}

CImImap4Settings& CCreateImapService::Settings()

	{

	return *iSettings;

	}

//

//

// CImapUseService

//

CImapUseService::CImapUseService(CImapClientTest& aTestHarness) : iTestHarness(aTestHarness)

	{

	}

void CImapUseService::StartL(TRequestStatus& aStatus)

	{

	TInt err = KErrNone;

	// Select current folder

	CMsvEntry& entry = *(iTestHarness.EmailTestUtils().iMsvEntry);

	entry.SetEntryL(iTestHarness.iSelectedFolder);

	// first make sure it is a service which is selected

	//  then change the test utils service id

	if(entry.Entry().iType == KUidMsvServiceEntry)

		{

		iTestHarness.EmailTestUtils().iImapServiceId = entry.Entry().Id();

		if(iTestHarness.EmailTestUtils().iImapClientMtm == NULL)

			iTestHarness.EmailTestUtils().InstantiateImapClientMtmL();

		else // no need to create a new one, reuse the existing one

			iTestHarness.EmailTestUtils().iImapClientMtm->SwitchCurrentEntryL(entry.Entry().Id());

		}

	else

		{

		TBuf<100> logString;

		logString.Format(KErrUseService, iDebugInfo.LineNumber());

		iTestHarness.LogComment(logString);

		err = KErrUnknown;

		}

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	}

//

//

// CCreateImapClientMtm

//

CCreateImapClientMtm::CCreateImapClientMtm(CEmailClientTest& aTest) : iTest(aTest)

	{

	}

void CCreateImapClientMtm::StartL(TRequestStatus& aStatus)

	{

	iTest.EmailTestUtils().InstantiatePopClientMtmL();

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, KErrNone);

	}

//

//

// CImapConnect

//

ImapConnectionObserver::ImapConnectionObserver(CImapConnect* aImapConnect) : iImapConnect(aImapConnect), iCount(0)

	{

	}

void ImapConnectionObserver::HandleImapConnectionEvent(TImapConnectionEvent)

	{

//	if (aConnectionState == ESynchronisationComplete)

//		if (++iCount == 2)

		if (++iCount == 1)

			iImapConnect->DummyRun();

	}

CImapConnect::CImapConnect(CEmailClientTest& aParentTestHarness, TSyncStatus aSynchronise) : CActive(EPriorityNormal), iParentTestHarness(aParentTestHarness), iSynchronise(aSynchronise)

	{

	CActiveScheduler::Add(this);

	}

void CImapConnect::StartL(TRequestStatus& aStatus)

	{

	TMsvId serviceId = iParentTestHarness.iSelectedFolder;

	CMsvEntry& msvEntry = *(iParentTestHarness.MsvTestUtils().iMsvEntry);

	msvEntry.SetEntryL(serviceId);

	iReportStatus = &aStatus;

	// check that current entry is a service

	CImap4ClientMtm& imapMtm = *(iParentTestHarness.EmailTestUtils().iImapClientMtm);

	TBuf8<1> param;

	CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;

	CleanupStack::PushL(selection);

	selection->AppendL(serviceId);

	if(iSynchronise == EConnectAndSync) 

		iParentTestHarness.SetCurrentOperation(imapMtm.InvokeAsyncFunctionL(KIMAP4MTMConnectAndSynchronise, *selection, param, iStatus));

	else if (iSynchronise == EConnectAndPeriodicSync) 

		{

		iObserver = new(ELeave) ImapConnectionObserver(this);

		TPckg<MMsvImapConnectionObserver*> paramPeriodic(iObserver);

		iParentTestHarness.SetCurrentOperation(imapMtm.

		InvokeAsyncFunctionL(KIMAP4MTMConnectAndSyncCompleteAfterDisconnect, *selection, paramPeriodic, iStatus));

		}

//	KIMAP4MTMConnectAndSyncCompleteAfterConnect,

//	KIMAP4MTMConnectAndSyncCompleteAfterFullSync,

//	KIMAP4MTMConnectAndSyncCompleteAfterDisconnect,

	else

		iParentTestHarness.SetCurrentOperation(imapMtm.InvokeAsyncFunctionL(KIMAP4MTMConnect, *selection, param, iStatus));

	CleanupStack::PopAndDestroy(selection);

	aStatus = KRequestPending;

	SetActive();

	}

void CImapConnect::RunL()

	{

	if (iDummyComplete == EFalse)

		User::RequestComplete(iReportStatus, iStatus.Int());

	}

void CImapConnect::DummyRun()

	{

	User::RequestComplete(iReportStatus, KErrNone);

	iDummyComplete = ETrue;

	}

void CImapConnect::DoCancel()

	{

	iParentTestHarness.CurrentOperation().Cancel();

	}

CImapConnect::~CImapConnect()

	{

	if (iObserver)

		delete iObserver;

	iObserver=0; 

	}

//

//

// CImapConnect

//

// Connect an monitor connection progress.

//

CImapConnectAndMonitor::CImapConnectAndMonitor(CEmailClientTest& aParentTestHarness, TBool aSynchronise) : CActive(EPriorityNormal), iParentTestHarness(aParentTestHarness), iSynchronise(aSynchronise)

	{

	CActiveScheduler::Add(this);

	}

void CImapConnectAndMonitor::LogCommentFormat(TRefByValue<const TDesC> format,...)

	{

	// Build parameter list.

	VA_LIST list;

	VA_START(list, format);

	TBuf<0x100> buf;

	buf.FormatList(format, list);

	// Log the debug buffer.

	iParentTestHarness.EmailTestUtils().WriteComment(buf);

	}

void CImapConnectAndMonitor::StartL(TRequestStatus& aStatus)

	{

	TMsvId serviceId = iParentTestHarness.iSelectedFolder;

	CMsvEntry& msvEntry = *(iParentTestHarness.MsvTestUtils().iMsvEntry);

	msvEntry.SetEntryL(serviceId);

	iReportStatus = &aStatus;

	// Check that current entry is a service

	CImap4ClientMtm& imapMtm = *(iParentTestHarness.EmailTestUtils().iImapClientMtm);

	CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;

	CleanupStack::PushL(selection);

	selection->AppendL(serviceId);

	TPckg<MMsvImapConnectionObserver*> parameter(this);

	if (iSynchronise)

		{

		iParentTestHarness.SetCurrentOperation(imapMtm.InvokeAsyncFunctionL(KIMAP4MTMConnectAndSyncCompleteAfterFullSync, *selection, parameter, iStatus));

		}

	else

		{

		iParentTestHarness.SetCurrentOperation(imapMtm.InvokeAsyncFunctionL(KIMAP4MTMConnect, *selection, parameter, iStatus));

		}

	CleanupStack::PopAndDestroy(selection);

	*iReportStatus = KRequestPending;

	SetActive();

	MonitorConnectionL();

	}

void CImapConnectAndMonitor::MonitorConnectionL()

	{

	//Initialise to unused values

	TInt progressState = KInvalidState;

	TInt connectState = KInvalidState;

	TInt iap = KInvalidIAP;

	TInt connection_progress_state = 0;

	RTimer timer; 

	TRequestStatus timerStatus; // Request status associated with timer

	timer.CreateLocal(); // Create for this thread

	do

		{	

		// Call funtion to return IAP and Poll to find connection state 

		TImap4GenericProgress temp;	

		TPckgC<TImap4GenericProgress> paramPack(temp);

		paramPack.Set(iParentTestHarness.CurrentOperation().ProgressL());

		TImap4GenericProgress progress = paramPack();	

		progressState = progress.iState;

		if((connectState != progress.ConnectionState()) || (iap != progress.ConnectionIAP()) )

			{

			connectState = progress.ConnectionState();

			iap = progress.ConnectionIAP();

			LogCommentFormat(_L("[%4d] Progress state =  %d, Connect State = %d, IAP = %d"), iDebugInfo.LineNumber(), progressState, connectState, iap);

			//Check that the relevant states are reached in the correct order

			if ((connectState == ECsdStartingDialling) || (connectState == ECsdStartingConnect))

					connection_progress_state = 1;

			if (connectState == ECsdConnectionOpen && connection_progress_state == 1)

					connection_progress_state = 2;

			if (connectState == KLinkLayerOpen && connection_progress_state == 2)

					connection_progress_state = 3;

			}

		// wait 50 microseconds and then re-test progress!

		timer.After(timerStatus,50);

		User::WaitForRequest(timerStatus); 

		} while (progressState == TImap4GenericProgress::EConnecting);

	timer.Close();

	if (connection_progress_state != 3)

		{

		LogCommentFormat(_L("[%4d] Local Connection Progress state =  %d, Connect State = %d, IAP = %d"), iDebugInfo.LineNumber(), connection_progress_state, connectState, iap);

		iConnectionError = ETrue;

		}

	}

void CImapConnectAndMonitor::RunL()

	{

	if (iConnectionError)

		User::RequestComplete(iReportStatus, KErrUnknown);	

	else

		User::RequestComplete(iReportStatus, iStatus.Int());

	}

// HandleImapConnectionEvent Callback (from MMsvImapConnectionObserver)

void CImapConnectAndMonitor::HandleImapConnectionEvent(TImapConnectionEvent)

	{

	}

void CImapConnectAndMonitor::DoCancel()

	{

	iParentTestHarness.CurrentOperation().Cancel();

	}

CImapConnectAndMonitor::~CImapConnectAndMonitor()

	{

	}

//

//

// CImapConnectAndCancel

//

// Connect then disconnect before sync completes

//

CImapConnectAndCancel::CImapConnectAndCancel(CEmailClientTest& aParentTestHarness, TUint aCancelDelay) : CActive(EPriorityNormal),iParentTestHarness(aParentTestHarness), iCancelDelay(aCancelDelay)

	{

	CActiveScheduler::Add(this);

	}

void CImapConnectAndCancel::LogCommentFormat(TRefByValue<const TDesC> format,...)

	{

	// Build parameter list.

	VA_LIST list;

	VA_START(list, format);

	TBuf<0x100> buf;

	buf.FormatList(format, list);

	// Log the debug buffer.

	iParentTestHarness.EmailTestUtils().WriteComment(buf);

	}

void CImapConnectAndCancel::StartL(TRequestStatus& aStatus)

	{

	iReportStatus = &aStatus;

	TMsvId serviceId = iParentTestHarness.iSelectedFolder;

	TBuf8<1> param;

	iSelection = new (ELeave) CMsvEntrySelection;

	iSelection->AppendL(serviceId);

	// Call the Async Connect & Sync funtion

	iParentTestHarness.SetCurrentOperation(iParentTestHarness.EmailTestUtils().iImapClientMtm->InvokeAsyncFunctionL(KIMAP4MTMConnect, 

											*iSelection, param, iStatus));

	iCommandState=EFirstConnect;

	aStatus = KRequestPending;

	SetActive();

	LogCommentFormat(_L("First connect started"));

	}

void CImapConnectAndCancel::RunL()

	{

	TBuf8<1> param;

	//LogCommentFormat(_L("CImapConnectAndCancel::RunL().  State = %d"), iCommandState);	

	switch (iCommandState)

		{

		case EFirstConnect:

			{

			// The first connect has completed.  Now Disconnect.

			iParentTestHarness.SetCurrentOperation(iParentTestHarness.EmailTestUtils().iImapClientMtm->InvokeAsyncFunctionL(KIMAP4MTMDisconnect,  

													*iSelection, param, iStatus));

			iCommandState = EDisconnect;

			*iReportStatus = KRequestPending;

			SetActive();

			LogCommentFormat(_L("Disconnecting"));

			break;

			}

		case EDisconnect:

			{

			// We have now disconnected after the first sync. 

			// Start a new connect and sync which we will cancel after 

			//  the specified interval

			iParentTestHarness.SetCurrentOperation(iParentTestHarness.EmailTestUtils().iImapClientMtm->InvokeAsyncFunctionL(KIMAP4MTMConnectAndSynchronise, 

													*iSelection, param, iStatus));

			iCommandState=ESecondSyncCancelled;		// This sync is about to be cancelled

			*iReportStatus = KRequestPending;

			SetActive();

			LogCommentFormat(_L("Second Connect and Sync started"));

			// This is where is gets a bit messy...

			// Define a timer so we can cancel after a specified period.

			// We can't wait for the connect to complete because it's too late by then.

			// We need to cancel during the stage when the IMAP server Capabilities 

			//  are being returned

			RTimer timer; 

			TRequestStatus timerStatus; // Request status associated with timer

			timer.CreateLocal(); // Create for this thread

			LogCommentFormat(_L("Waiting for %d msecs"), iCancelDelay);

			// Wait for the defined interval

			// OK, so this suspends the current thread which isn't great but the

			//  server is running in a different thread, so that continues as normal

			timer.After(timerStatus, iCancelDelay * 1000);

			User::WaitForRequest(timerStatus); 

			timer.Close();

			// Cancel the connect & sync

			DoCancel();

			LogCommentFormat(_L("Second connect & sync cancelled"));

			break;

			}

		case ESecondSyncCancelled: 

			// The second sync should have completed when the connect occured, but

			// we cancelled it before it had chance to complete.

			// Now start the final sync to check that all is still OK

			{

			iParentTestHarness.SetCurrentOperation(iParentTestHarness.EmailTestUtils().iImapClientMtm->InvokeAsyncFunctionL(KIMAP4MTMConnectAndSynchronise, 

													*iSelection, param, iStatus));

			iCommandState=EThirdSync;

			*iReportStatus = KRequestPending;

			SetActive();

			LogCommentFormat(_L("Third Connect and Sync started"));

			break;

			}

		case EThirdSync:

			{

			// At this point the third ConnectAndSync reports that it is completed, but actually 

			//  only the connect has.  The sync continues in background, so create an operation

			//  to wait for it to complete.

			iParentTestHarness.SetCurrentOperation(iParentTestHarness.EmailTestUtils().iImapClientMtm->InvokeAsyncFunctionL(KIMAP4MTMWaitForBackground,  

													*iSelection, param, iStatus));

			iCommandState = EComplete;

			*iReportStatus = KRequestPending;

			SetActive();

			LogCommentFormat(_L("Waiting for third sync to complete"));

			break;

			}

		case EComplete:

			{

			// Everything has completed.  Success!

			LogCommentFormat(_L("Completed"));

			User::RequestComplete(iReportStatus, KErrNone);

			break;

			}