// Copyright (c) 2000-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:

// This test harness processes an Internet Access Configuration Message

// and uses the resulting database entry to perform a connection to 

// the POP3 and SMTP servers.

// The parser creates the service entries from the files iacp*.txt

// placed into the data directory c:\biomsg\iacpcomm. If more

// than one entry is placed into the directory the harness uses the

// first instance as the target POP3/SMTP provider.

// The harness contructs and sends any files of the form rfc*.txt

// with the data directory to the SMTP service, before connecting to 

// the POP3 service to download mail.

// The test harness does not support heap fail testing

// Based on t_iacp.cpp amd t_pops.cpp

// 

//

#include "biotestutils.h"

#include "emailtestutils.h"

//

#include "IACPERR.H"

#include "IACPDEF.H"

#include <commdb.h>

#include <popsmtm.h>

#include <etel.h>

#include "tmsvbioinfo.h"

//

//SMS configuration files path

_LIT(IACP_TEST_MSG_PATH,	"c:\\test\\bio\\iacpcomm\\");

#define BIO_MSG_ENTRY_PARSED	 1 // Set entry .iMtmData3 to 1 to indicate that the entry has store i.e parsed,externalised

// forward references

class CExampleScheduler;

class CTestIacp;

//global declarations

LOCAL_D CExampleScheduler *exampleScheduler;

LOCAL_D RTest test(_L("IACPCOMM Test Harness"));

// Uncommment the following to provide prompting on the Windows platform

// #if defined(_DEBUG)

// #define PROMPTUSER test.Printf(_L("\nPress any key: ")); test.Getch();

// #else

// #define PROMPTUSER

// #endif

#define PROMPTUSER

//

//-- CExampleScheduler --

//

class CExampleScheduler : public CActiveScheduler 

	{

	public:

	void Error (TInt aError) const;

	};

void CExampleScheduler::Error(TInt anError) const

	{

	CActiveScheduler::Stop();

	test.Printf(_L("\nLeave signalled, reason=%d\n"),anError);

	PROMPTUSER

	}

//--------------------------------------

//

//-- CTestIacp --

//

enum TSessionState

	{

	EParse,			// parsing is done at ParseL() stage. and data are externalised.

	EProcess,		// parsed data are internalised, then commited

	EInitSMTPMTM,	// initialise the send test utils for SMTP

	ESendSMTP,		// prep outgoing message and connect to the SMTP service

					// and send them

	EInitPOP3MTM,	// initialise the send test utils for SMTP

	EConnectPOP3,	// connect to the access point setup by the IACP entry

	EReceivePOP3,	// pull back any messages on the service

	EDisconnectPOP3,// and disconnect 

	EFinished		// Time to pack up

	};

class CTestIacp : public CActive 

	{

	public:

		~CTestIacp();

		static  CTestIacp * NewL(CBioTestUtils* aBioTestUtils);

		void StartL(TSessionState aCmd);

		CTestIacp(CBioTestUtils* aBioTestUtils);

		void DoCancel();

		void RunL();

		TBool DisplaySummary();

		TInt  Error();

	private:

		void RequestComplete(TRequestStatus& aStatus,TInt aCompletion);

		void ConstructL();

		void CreateParserL(); //sets 'iParser' to point to the created iacp parser

		void GetMessageBodyL();

		void DisplayEntryDataL();

		void ParseMsgL();

		void ProcessMsgL();

		void InitSMTPMTML();

		void InitPOP3MTML();

		void SendSMTPL();

		void ConnectPOP3L();

		void DisconnectPOP3L();

		void DoRunL();

		void SetIAPL(TMsvId aService);

		void deleteParser();

		void CheckSendStatus();

		TBool CheckRecvStatus();

		void LogCommsError(TInt aError);

		void LogParseError(TInt& aReason);

		void GetDefaultConnectionL();

		void ReceivePOP3L();

	private:

		TSessionState		iState;

		TInt				iError;

		// for managing the connections to the pop3 and smtp servers

		CEmailTestUtils*	iSendUtils;

		TMsvId				iPop3service;	// IACP added entry

		TMsvId				iSmtpservice;	// as above

		CMsvEntrySelection* iMsvSelection;

		TUint32				iIap;		// what commdb record we use for connecting out

		// for managing the input IACP data

		CBioTestUtils*		iBioTestUtils;

		CBaseScriptParser2*	iParser;

		HBufC*				iSmsMsg;		//sms body build dependent		

		TMsvId				iEntryId;       //ID of sms entry

		CMsvEntrySelection*	iIacpSelection;	//the collection of iacp*.txt entries

		// status

		TBool				iParsedMsg;

		TBool				iConnectedToSMTP;

		TInt				iMsgsSent;

		TBool				iConnectedToPOP3;

		TInt				iMsgsReceived;

	};

//

CTestIacp::CTestIacp(CBioTestUtils* aBioTestUtils)

:CActive(EPriorityStandard),iBioTestUtils(aBioTestUtils)

	{

	}

CTestIacp* CTestIacp::NewL(CBioTestUtils* aBioTestUtils)

	{

	CTestIacp* self = new(ELeave) CTestIacp(aBioTestUtils);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();  //self 

	return self;

	}

void CTestIacp::ConstructL()

	{

	iBioTestUtils->WriteComment(_L("CTestIacp::ConstructL()."));

	CreateParserL();

	// for selecting message store items

	iMsvSelection = new (ELeave) CMsvEntrySelection;

	iIacpSelection=	iBioTestUtils->GenerateMessagesL(IACP_TEST_MSG_PATH);

	CActiveScheduler::Add(this);

	}

CTestIacp::~CTestIacp()

	{

	Cancel();

	deleteParser();

	delete iIacpSelection;

	delete iSmsMsg;

	delete iSendUtils;

	delete iMsvSelection;

	}

void CTestIacp::CreateParserL()

	{

	TRAPD(error,(iParser = iBioTestUtils->CreateParserTypeL(KUidBIOInternetAccessPointMsg)));

	if (error == KErrNone)

		{

		iBioTestUtils->WriteComment(_L("Created IACP Parser object"));

		}

	else

		{

		LogParseError(error);

		User::Leave(error);

		}	

	}

void CTestIacp::GetMessageBodyL()

	{

	// get a memory version of the message created by the test utils

	delete iSmsMsg;

	iSmsMsg = NULL;

	iSmsMsg = iBioTestUtils->MessageBodyL(iEntryId).AllocL();

	}

TInt CTestIacp::Error()

	{

	return iError;

	}

void CTestIacp::StartL(TSessionState aCmd)

	{

	iState=aCmd;

	iEntryId = (*iIacpSelection)[0];

	switch (iState)

		{

		case EParse:

			test.Printf(_L("Parsing...\n"));

			iBioTestUtils->SetEntryL(iEntryId); //clients have to set the right context before calling ParseL() 

			GetMessageBodyL();

			ParseMsgL();

			break;

		case EProcess:

			test.Printf(_L("Processing...\n"));

			iBioTestUtils->SetEntryL(iEntryId); //clients have to set the right context before calling CommitL() 

			ProcessMsgL();

			break;

		case EInitSMTPMTM:

			InitSMTPMTML();

			RequestComplete(iStatus,KErrNone);

            SetActive();

			break;

		case EInitPOP3MTM:

			InitPOP3MTML();

			RequestComplete(iStatus,KErrNone);

            SetActive();

			break;

		case ESendSMTP:

			SendSMTPL();

			break;

		case EConnectPOP3:

			ConnectPOP3L();

			break;

		case EReceivePOP3:

			ReceivePOP3L();

			break;

		case EDisconnectPOP3:

			DisconnectPOP3L();

			break;

		default:

			break;

		}

	}

void CTestIacp::RunL()

	{

	TRAP(iError, DoRunL());

	if (iError != KErrNone || iState == EFinished)

		{

		CActiveScheduler::Stop();

		}

	}

void CTestIacp::DoRunL()

	{

	TInt result=iStatus.Int();

	switch (iState)

		{

		case EParse:

			if(result==KErrNone)

				{

				iBioTestUtils->WriteComment(_L("Parsed Ok"));

				StartL(EProcess);

				}

			else

				{

				LogParseError(result);

				iParser->Cancel();

				iState=EFinished;

				}

			break;

		case EProcess:

			if(result==KErrNone)

				{

				iBioTestUtils->WriteComment(_L("Processed IACP Ok"));

				iParsedMsg = ETrue;

				//StartL(EInitSMTPMTM);

				StartL(EInitPOP3MTM);

				}

			else

				{

				LogParseError(result);

				iParser->Cancel();

				iState=EFinished;

				}

			break;

		case EInitSMTPMTM:

			iSendUtils->WriteComment(_L("Initialised SMTP MTM Ok"));

			StartL(ESendSMTP);	

			break;

		case ESendSMTP:

			CheckSendStatus();

			if (iConnectedToSMTP)

				{

				StartL(EInitPOP3MTM);

				}

			else

				{

				iState=EFinished;

				}

			break;

		case EInitPOP3MTM:

			iSendUtils->WriteComment(_L("Initialised POP3 MTM Ok"));

			StartL(EConnectPOP3);

			break;

		case EConnectPOP3:

			if (CheckRecvStatus())

				{

				iConnectedToPOP3 = ETrue;

				iSendUtils->WriteComment(_L("Connected POP3 server Ok"));

				// count number or entries in remote service

				User::LeaveIfError(iSendUtils->iServerEntry->SetEntry(iPop3service));

				User::LeaveIfError(iSendUtils->iServerEntry->GetChildren(*iMsvSelection));

				if (iMsvSelection->Count() > 0)

					{

					StartL(EReceivePOP3);

					}

				else

					{

					StartL(EDisconnectPOP3);

					}

				}

			else

				{

				iState=EFinished;

				}

			break;

		case EReceivePOP3:

			if (CheckRecvStatus())

				{

				iSendUtils->WriteComment(_L("Retrieved from POP3 Ok"));

				iMsgsReceived = iMsvSelection->Count();

				}

			StartL(EDisconnectPOP3);

			break;

		case EDisconnectPOP3:

			iSendUtils->WriteComment(_L("Disconnected POP3 server Ok"));

			iState = EFinished;

			break;

		default:

			break;

		}

	}

void CTestIacp::ParseMsgL()

	{

	iBioTestUtils->WriteComment(_L("Creating IACP Parser object"));

	TRAPD(error, iParser->ParseL(iStatus,iSmsMsg->Des())); 

	if (error == KErrNone)

		{

		iBioTestUtils->WriteComment(_L("Created IACP Parser object"));

		SetActive();

		}

	else

		{

		LogParseError(error);

		User::Leave(error);

		}	

	}

void CTestIacp::ProcessMsgL()

	{

	iBioTestUtils->WriteComment(_L("Starting processing..."));

	DisplayEntryDataL();

	TRAPD(error, iParser->ProcessL(iStatus)); //internalise and process

	if (error == KErrNone)

		{

		iBioTestUtils->WriteComment(_L("Process started ok"));

		SetActive();

		}

	else

		{

		LogParseError(error);

		User::Leave(error);

		}	

	}

void CTestIacp::deleteParser()

	{

	delete iParser;

	iParser = 0;

	delete iBioTestUtils;

	iBioTestUtils = 0;

	}

// setup the objects for connecting to the POP3 server

void CTestIacp::InitPOP3MTML()

	{

	// close down iBioTestUtils instance since it shares a single message server

	// which causes iSendUtils creation to fail

	// first delete the parser to allow iBioTestUtils to be deleted

	// without panicking

	deleteParser();

	delete iSendUtils;

	iSendUtils = 0;

	// now setup the send utils

	iSendUtils = CEmailTestUtils::NewL(test);

	iSendUtils->WriteComment(_L("Initialised POP3 Send Utils"));

	iSendUtils->GoServerSideL();

	iSendUtils->CreatePopServerMtmRegL();

	// Load the DLLs

	iSendUtils->CreateRegistryObjectAndControlL();

	iSendUtils->InstallPopMtmGroupL();

	iSendUtils->FindExistingServicesL();

	iSendUtils->InstantiatePopServerMtmL();

	// processing of message should have added these entries

	TRAPD(error, (iPop3service = iSendUtils->FindPopServiceL()));

	if (error != KErrNone)

		{

		iSendUtils->WriteComment(_L("Could not locate POP3 service entry"));

		User::Leave(error);

		}

	GetDefaultConnectionL();

	SetIAPL(iPop3service);

	}

// setup the objects for connecting to the SMTP server

void CTestIacp::InitSMTPMTML()

	{

	deleteParser();

	// now setup the send utils

	iSendUtils = CEmailTestUtils::NewL(test);

	iSendUtils->WriteComment(_L("Initialised SMTP Send Utils"));

	iSendUtils->GoServerSideL();

	iSendUtils->CreateSmtpServerMtmRegL();

	// Load the DLLs

	iSendUtils->CreateRegistryObjectAndControlL();

	iSendUtils->InstallSmtpMtmGroupL();

	iSendUtils->FindExistingServicesL();

	iSendUtils->InstantiateSmtpServerMtmL();

	// processing of message should have added these entries

	TRAPD(error, (iSmtpservice = iSendUtils->FindSmtpServiceL()));

	if (error != KErrNone)

		{

		iSendUtils->WriteComment(_L("Could not locate SMTP service entry"));

		User::Leave(error);

		}

	GetDefaultConnectionL();

	SetIAPL(iSmtpservice);

	}

void CTestIacp::ConnectPOP3L()

	{

	iMsvSelection->ResizeL(0);

	iMsvSelection->AppendL(iPop3service);

	iSendUtils->WriteComment(_L("Connecting to POP3 server..."));

	test.Printf(_L("Connecting to POP3 server...\n"));

	TBuf8<1> aParameter;

	iSendUtils->iPopServerMtm->StartCommandL(*iMsvSelection, KPOP3MTMConnect, aParameter, iStatus);

	SetActive();

	}

void CTestIacp::ReceivePOP3L()

	{

	TBuf<60> outputBuf;

	outputBuf.Format(_L("%d messages in the inbox"), iMsvSelection->Count());

	iSendUtils->WriteComment(outputBuf);

	outputBuf.Format(_L("%d messages in the inbox\n"), iMsvSelection->Count());

	test.Printf(outputBuf);

	iSendUtils->WriteComment(_L("Retrieving messages..."));