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

#include <c32comm.h>

#include <e32test.h>

#include <f32fsys.h>

#include <s32file.h>

#include <e32uid.h>

#include <txtrich.h>

#include <txtfmlyr.h>

#include <msvids.h>

#include <msvuids.h>

#include <msvruids.h>

#include <e32std.h>

#include <mtclbase.h>

#include <mtclreg.h>

#include <msvapi.h>

#include <mtmuids.h>

#include <smuthdr.h>

#include <miutset.h>

#include <es_sock.h>

#include <in_sock.h>

#include <commdbconnpref.h>

#include <cemailaccounts.h>

#include <iapprefs.h>

#include <mmsvattachmentmanager.h>

#include <cmsvattachment.h>

#include <centralrepository.h>

_LIT(KComputerNamePath, "c:\\msgtest\\MachineName.txt");

EXPORT_C CEmailTestUtils* CEmailTestUtils::NewL(RTest& aRTest, TUint aCreationFlags)

	{

	CEmailTestUtils* self = NewLC(aRTest, aCreationFlags);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CEmailTestUtils* CEmailTestUtils::NewLC(RTest& aRTest, TUint aCreationFlags)

	{

	CEmailTestUtils* self = new (ELeave) CEmailTestUtils(aRTest);

	CleanupStack::PushL(self);

	self->ConstructL(aCreationFlags);

	return self;

	}

EXPORT_C void CEmailTestUtils::InstantiateImapClientMtmL()

	{

	// client side

	iImapClientMtm = (CImap4ClientMtm*) InstantiateClientMtmL(KUidMsgTypeIMAP4, iImapServiceId);

	}

EXPORT_C void CEmailTestUtils::InstantiatePopClientMtmL()

	{

	iPopClientMtm = (CPop3ClientMtm*) InstantiateClientMtmL(KUidMsgTypePOP3, iPopServiceId);

	}

EXPORT_C void CEmailTestUtils::InstantiateSmtpClientMtmL()

	{

	iSmtpClientMtm = (CSmtpClientMtm*) InstantiateClientMtmL(KUidMsgTypeSMTP, iSmtpServiceId);

	}

EXPORT_C void CEmailTestUtils::InstantiateImapServerMtmL()

	{

	iImapServerMtm = (CBaseServerMtm*) InstantiateServerMtmL(KUidMsgTypeIMAP4, iImapServiceId);

	}

EXPORT_C void CEmailTestUtils::InstantiatePopServerMtmL()

	{

	iPopServerMtm = (CBaseServerMtm*) InstantiateServerMtmL(KUidMsgTypePOP3, iPopServiceId);

	}

EXPORT_C void CEmailTestUtils::InstantiateSmtpServerMtmL()

	{

	iSmtpServerMtm = (CBaseServerMtm*) InstantiateServerMtmL(KUidMsgTypeSMTP, iSmtpServiceId);

	}

EXPORT_C void CEmailTestUtils::CreateImapServerMtmRegL()

	{

	CreateServerMtmRegL(KUidMsgTypeIMAP4, _L("IMAP4"), KImap4ServerMtmFileName(), TMsvTestDllInfo(KImap4ClientMtmFileName, 3), KImap4DataLayerFileName(), KImap4DataLayerFileName(), KUidMsvTechnologyGroupEmail, imap4DatFile);

	}

EXPORT_C void CEmailTestUtils::CreateSmtpServerMtmRegL()

	{

	CreateServerMtmRegL(KUidMsgTypeSMTP, _L("SMTP"), KSmtpServerMtmFileName(), TMsvTestDllInfo(KSmtpClientMtmFileName,2), KSmtpDataLayerFileName(), KSmtpDataLayerFileName(), KUidMsvTechnologyGroupEmail, smtpDatFile);

	}

EXPORT_C void CEmailTestUtils::CreatePopServerMtmRegL()

	{

	CreateServerMtmRegL(KUidMsgTypePOP3, _L("POP3"), KPop3ServerMtmFileName(), KPop3ClientMtmFileName(), KPop3DataLayerFileName(), KPop3DataLayerFileName(), KUidMsvTechnologyGroupEmail, pop3DatFile);

	}

EXPORT_C TMsvId CEmailTestUtils::CreateImapServiceL()

	{

	TInt err = KErrNone;

	iImapServiceId = 0;

	TRAP(err, ServiceIdL(KUidMsgTypeIMAP4, iImapServiceId));

	if (err)

		{

		CEmailAccounts* account = CEmailAccounts::NewLC();

		CImImap4Settings* imapSettings = new(ELeave) CImImap4Settings();

		CleanupStack::PushL(imapSettings);

		CImIAPPreferences* imapIAP = CImIAPPreferences::NewLC();

		account->PopulateDefaultImapSettingsL(*imapSettings, *imapIAP);

		_LIT(KImapServer, "imap.dial.pipex.com");

		imapSettings->SetServerAddressL(KImapServer);

		_LIT8(KImapLoginName, "abf75");

		imapSettings->SetLoginNameL(KImapLoginName);

		_LIT8(KImapPassword, "oodifama");

		imapSettings->SetPasswordL(KImapPassword);

		imapSettings->SetPort(143);

		_LIT(KTxtAccountName, "ImapAccount");

		TImapAccount imapAccount = account->CreateImapAccountL(KTxtAccountName, *imapSettings, *imapIAP, EFalse);

		CleanupStack::PopAndDestroy(3, account); // imapIAP, imapSettings, account

		ServiceIdL(KUidMsgTypeIMAP4, iImapServiceId);

		}

	else

		{

		Printf(_L("Imap Service Already Exists. You should delete the existing service first!\n"));

		}

	return iImapServiceId;

	}

EXPORT_C TMsvId CEmailTestUtils::CreateSmtpServiceL()

	{

	TInt err = KErrNone;

	iSmtpServiceId = 0;

	TRAP(err, ServiceIdL(KUidMsgTypeSMTP, iSmtpServiceId));

	if (err)

		{

		CEmailAccounts* account = CEmailAccounts::NewLC();

		CImSmtpSettings* smtpSettings = new(ELeave) CImSmtpSettings();

		CleanupStack::PushL(smtpSettings);

		CImIAPPreferences* smtpIAP = CImIAPPreferences::NewLC();

		account->PopulateDefaultSmtpSettingsL(*smtpSettings, *smtpIAP);

		_LIT(KSmtpServer, "smtp.dial.pipex.com");

		smtpSettings->SetServerAddressL(KSmtpServer);

		smtpSettings->SetEmailAliasL(_L("Messaging Test1"));

		_LIT(KSmtpEmailAddress, "msgtest1@internet-test.plc.psion.com");

		smtpSettings->SetEmailAddressL(KSmtpEmailAddress);

		smtpSettings->SetReplyToAddressL(KSmtpEmailAddress);

		smtpSettings->SetBodyEncoding(EMsgOutboxMIME);

		smtpSettings->SetReceiptAddressL(KSmtpEmailAddress);

		smtpSettings->SetPort(25);

		_LIT(KTxtAccountName, "SmtpAccount");

		TSmtpAccount smtpAccount = account->CreateSmtpAccountL(KTxtAccountName, *smtpSettings, *smtpIAP, EFalse);

		CleanupStack::PopAndDestroy(3, account); // smtpIAP, smtpSettings, account

		ServiceIdL(KUidMsgTypeSMTP, iSmtpServiceId);

		}

	else

		{

		Printf(_L("Smtp Service Already Exists\n"));	

		}

	return iSmtpServiceId;

	}

EXPORT_C TMsvId CEmailTestUtils::CreatePopServiceL()

	{

	TInt err = KErrNone;

	iPopServiceId = 0;

	TRAP(err, ServiceIdL(KUidMsgTypePOP3, iPopServiceId));

	if (err)

		{

		CEmailAccounts* account = CEmailAccounts::NewLC();

		CImPop3Settings* popSettings = new(ELeave) CImPop3Settings();

		CleanupStack::PushL(popSettings);

		CImIAPPreferences* popIAP = CImIAPPreferences::NewLC();

		account->PopulateDefaultPopSettingsL(*popSettings, *popIAP);

		_LIT(KTxtAccountName, "PopAccount");

		TPopAccount popAccount = account->CreatePopAccountL(KTxtAccountName, *popSettings, *popIAP, EFalse);

		CleanupStack::PopAndDestroy(3, account); // popIAP,popSettings, account

		ServiceIdL(KUidMsgTypePOP3, iPopServiceId);

		}

	else

		{

		Printf(_L("Pop Service Already Exists. You should delete the existing service first!\n"));

		}

	return iPopServiceId;

	}

EXPORT_C void CEmailTestUtils::DeleteImapServiceL()

	{

	DeleteServiceL(KUidMsgTypeIMAP4);

	}

EXPORT_C void CEmailTestUtils::DeleteSmtpServiceL()

	{

	DeleteServiceL(KUidMsgTypeSMTP);

	}

EXPORT_C void CEmailTestUtils::DeleteScriptFilesFromLogsDirL()

	{

	// Deletes any *.scr file from C:\logs\email directory 

	// to enable dialup connection

	TBuf<5> buf(_L("*.scr"));

	TFileName deleteFile; 

	deleteFile.Append(KEmailDataDir);

	deleteFile.Append(buf);

	TFindFile finder(iFs);

	CDir* dirs = NULL;

	TInt err = finder.FindWildByDir(deleteFile, KEmailDataDir, dirs);

	__ASSERT_ALWAYS((err == KErrNone) || (err == KErrNotFound), Panic(KErrGeneral));

	CFileMan* fileMan = CFileMan::NewL(iFs);

	CleanupStack::PushL(fileMan);

	fileMan->Delete(deleteFile);

	CleanupStack::PopAndDestroy(); // fileMan

	delete dirs;

	}

EXPORT_C void CEmailTestUtils::DeletePopServiceL()

	{

	DeleteServiceL(KUidMsgTypePOP3);

	}

EXPORT_C TMsvId CEmailTestUtils::FindImapServiceL()

	{

	TMsvId firstId = 0;

	ServiceIdL(KUidMsgTypeIMAP4, firstId);

	return firstId;

	}

EXPORT_C TMsvId CEmailTestUtils::FindSmtpServiceL()

	{

	TMsvId firstId = 0;

	ServiceIdL(KUidMsgTypeSMTP, firstId);

	return firstId;

	}

EXPORT_C TMsvId CEmailTestUtils::FindPopServiceL()

	{

	TMsvId firstId = 0;

	ServiceIdL(KUidMsgTypePOP3, firstId);

	return firstId;

	}

EXPORT_C void CEmailTestUtils::Reset()

	{

	DeleteCurrentMtm();

	CMsvTestUtils::Reset();

	}

EXPORT_C void CEmailTestUtils::ClearEmailAccountsL()

	{

	TBool isServerSide = EFalse;

	if( iClientServer == EServerSide )

		{

		isServerSide = ETrue;

		GoClientSideL();

		}

	CRepository* popRepository = CRepository::NewL(KUidMsgTypePOP3);

	popRepository->Reset();

	delete popRepository;

	CRepository* imapRepository = CRepository::NewL(KUidMsgTypeIMAP4);

	imapRepository->Reset();

	delete imapRepository;

	CRepository* smtpRepository = CRepository::NewL(KUidMsgTypeSMTP);

	smtpRepository->Reset();

	delete smtpRepository;

	if( isServerSide )

		{

		GoServerSideL();

		}

	}

void CEmailTestUtils::DeleteCurrentMtm()

	{

	if (iImapClientMtm)

		{

		delete iImapClientMtm;

		iImapClientMtm = NULL;

		}

	if (iPopClientMtm)

		{

		delete iPopClientMtm;

		iPopClientMtm = NULL;

		}

	if (iSmtpClientMtm)

		{

		delete iSmtpClientMtm;

		iSmtpClientMtm = NULL;

		}

	if (iImapServerMtm)

		{

		delete iImapServerMtm;

		iImapServerMtm = NULL;

		iServerEntry=NULL;

		}

	if (iPopServerMtm)

		{

		delete iPopServerMtm;

		iPopServerMtm = NULL;

		iServerEntry=NULL;

		}

	if (iSmtpServerMtm)

		{

		delete iSmtpServerMtm;

		iSmtpServerMtm = NULL;

		iServerEntry=NULL;

		}

	}

EXPORT_C const TDesC8& CEmailTestUtils::MachineName()

    {

    return *iMachineName;

    }

EXPORT_C CEmailTestUtils::~CEmailTestUtils()

	{

	Reset();

	delete iMachineName;

	}

CEmailTestUtils::CEmailTestUtils(RTest& aRTest)

: CMsvTestUtils(aRTest), iSmtpServiceId(KMsvNullIndexEntryId)

	{

	StartC32();

	}

void CEmailTestUtils::ConstructL(TUint aCreationFlags)

	{

	CMsvTestUtils::ConstructL(aCreationFlags);

	CMsvTestUtils::SpecifyLogsDir(KEmailDataDir);

    // Read the machine name and assign to iMachineName.	

	RFile file;

	User::LeaveIfError(file.Open(iFs, KComputerNamePath, EFileRead));

	CleanupClosePushL(file);

    TInt  fileSize;

	User::LeaveIfError(file.Size(fileSize));

	iMachineName = HBufC8::NewL(fileSize);

	TPtr8 bufferPtr = iMachineName->Des();

	User::LeaveIfError(file.Read(bufferPtr));

	CleanupStack::PopAndDestroy(&file);

	}

void CEmailTestUtils::Panic(TInt aPanic)

	{

	User::Panic(EmailTEST_PANIC, aPanic);

	}

void CEmailTestUtils::Panic(TEmailTestUtilsPanic aPanic)

	{

	Panic((TInt) aPanic);

	}

EXPORT_C void CEmailTestUtils::InstallSmtpMtmGroupL()

	{

	InstallMtmGroupL(smtpDatFile);

	}

EXPORT_C void CEmailTestUtils::InstallPopMtmGroupL()

	{

	InstallMtmGroupL(pop3DatFile);

	}

EXPORT_C void CEmailTestUtils::InstallImapMtmGroupL()

	{

	InstallMtmGroupL(imap4DatFile);

	}

void CEmailTestUtils::SetFolderType(TMsvEntry& aMsvEntry, TPtrC& type)

	{

	TMsvEmailEntry& entry = (TMsvEmailEntry&)aMsvEntry;

	if(entry.iType == KUidMsvRootEntry)

		type.Set(_L("ROOT"));

	else if(entry.iType == KUidMsvServiceEntry)

		type.Set(_L("SERVICE"));

	else if(entry.iType == KUidMsvFolderEntry)

		{

		if (entry.MessageFolderType() == EFolderTypeAlternative)

			type.Set(_L("FOLDER_ALT"));

		else if (entry.MessageFolderType() == EFolderTypeMixed)

			type.Set(_L("FOLDER_MIX"));

		else if (entry.MessageFolderType() == EFolderTypeRelated)

			type.Set(_L("FOLDER_REL"));

		else if (entry.MessageFolderType() == EFolderTypeRFC822)

			type.Set(_L("FOLDER_RFC"));

		else if (entry.MessageFolderType() == EFolderTypeUnknown)

			type.Set(_L("FOLDER_UNKWN"));

		else if (entry.MessageFolderType() == EFolderTypeParallel)

			type.Set(_L("FOLDER_PLL"));

		else if (entry.MessageFolderType() == EFolderTypeDigest)

			type.Set(_L("FOLDER_DGST"));

		else if (entry.MessageFolderType() == EFolderTypePartial)

			type.Set(_L("FOLDER_PARTL"));

		else if (entry.MessageFolderType() == EFolderTypeDirectory)

			type.Set(_L("FOLDER_DIR"));

		else if (entry.MessageFolderType() == EFolderTypeExternal)

			type.Set(_L("FOLDER_EXT"));

		else

			type.Set(_L("FOLDER"));

		}

	else if(entry.iType == KUidMsvMessageEntry)

		type.Set(_L("MESSAGE"));

	else if(entry.iType == KUidMsvEmailTextEntry)

		type.Set(_L("TEXT"));

	else if(entry.iType == KUidMsvEmailHtmlEntry)

		type.Set(_L("HTML"));

	else if(entry.iType == KUidMsvAttachmentEntry)

		type.Set(_L("ATTACHMENT"));

	else

		type.Set(_L("UNKNOWN"));

	}

EXPORT_C void CEmailTestUtils::ListChildrenL(RFile& aFile, CDir& rfcFileList, TInt& aCount, TInt& aEntryCount, TBool aReplace, TBool aOtherFiles)

	{

	// Check details of attachments on current context entry

	CMsvEntrySelection* msvSelection = NULL;

	TMsvEmailEntry entry;

	if (iClientServer==EClientSide)

		{

		entry = (TMsvEmailEntry&) iMsvEntry->Entry(); 

		msvSelection = iMsvEntry->ChildrenL();

		}

	else

		{

		entry = (TMsvEmailEntry&) iServerEntry->Entry(); 

		msvSelection = new (ELeave) CMsvEntrySelection;

		iServerEntry->GetChildren(*msvSelection);

		}

	CleanupStack::PushL(msvSelection);

	TInt attachCount = msvSelection->Count(); 	// For each child ..

	TInt bodySize=0;

	TPtrC type;

	SetFolderType(entry, type);

	TPtrC priority;

	TMsvPriority temp=entry.Priority();

	if(temp==EMsvHighPriority)

		priority.Set(_L("High  "));

	else if(temp==EMsvMediumPriority)

		priority.Set(_L("Medium"));

	else if(temp==EMsvLowPriority)

		priority.Set(_L("Low   "));

	else

		priority.Set(_L("None  "));

	TBuf<6> streams=_L("------");

	if ((iClientServer==EClientSide && iMsvEntry->HasStoreL()) ||

		(iClientServer==EServerSide && iServerEntry->HasStoreL()))

		{

		CMsvStore* fileStore;

		fileStore = (iClientServer==EClientSide) ? iMsvEntry->ReadStoreL() : iServerEntry->ReadStoreL();

		if(fileStore->IsPresentL(KUidMsgFileIMailHeader))

			{

			if (aOtherFiles)

				DisplayHeaderL(entry.Id(), *fileStore, iLogsDir, aReplace);

			streams.Replace(0, 1, _L("H"));

			}

		if(fileStore->IsPresentL(KUidMsgFileMimeHeader))

			{

			if (aOtherFiles)

				DisplayMimeHeaderL(entry.Id(), *fileStore, iLogsDir, aReplace);

			streams.Replace(1, 1, _L("M"));

			}

		if(fileStore->HasBodyTextL())

			{

			if (aOtherFiles)

				WriteBodyDataL(entry.Id(), iLogsDir, *fileStore, aReplace);

			streams.Replace(2, 1, _L("B"));

			CParaFormatLayer* paraLayer = CParaFormatLayer::NewL();

			CCharFormatLayer* charLayer = CCharFormatLayer::NewL();

			CRichText* body = CRichText::NewL(paraLayer,charLayer);

			fileStore->RestoreBodyTextL(*body);