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

// BioTestUtils.h

//

#include "biotestutils.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 <e32math.h>

#include <mtclbase.h>

#include <mtclreg.h>

#include <msvapi.h>

#include <mtmuids.h>

#include <smuthdr.h>

#include <biouids.h>

#include <biodb.h>

#include <biouids.h>

#include <regpsdll.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS 

#include <tmsvsmsentry.h>

#include <bifchangeobserver.h>

#include <biomessageuids.h>

#include "tmsvbioinfo.h"

#endif

#define KCharSpace          ' '

EXPORT_C CBioTestUtils::~CBioTestUtils()

	{

	Reset();

	delete iBioDb;

	}

EXPORT_C CBioTestUtils* CBioTestUtils::NewL(RTest& aRTest)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CBioTestUtils* CBioTestUtils::NewLC(RTest& aRTest)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

EXPORT_C CBioTestUtils* CBioTestUtils::NewL(RTest& aRTest, TInt aCreationFlags)

	{

	CBioTestUtils* self = NewLC(aRTest, aCreationFlags);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CBioTestUtils* CBioTestUtils::NewLC(RTest& aRTest, TInt aCreationFlags)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aCreationFlags);

	return self;

	}

void CBioTestUtils::Reset()

	{

	if(iTestParsedFieldArray)

		{

		iTestParsedFieldArray->ResetAndDestroy();

		delete iTestParsedFieldArray;

		iTestParsedFieldArray=NULL;

		}

	if(iMessageBody)

		{

		delete iMessageBody;

		iMessageBody = NULL;

		}

	if(iDir)

		{

		delete iDir;

		iDir = NULL;

		}

	if(iRegisteredParserDll)

		{

		delete iRegisteredParserDll;

		iRegisteredParserDll = NULL;

		}

	if (iBioClientMtm)

		{

		delete iBioClientMtm;

		iBioClientMtm=NULL;

		}

	if (iBioServerMtm)

		{

		delete iBioServerMtm;

		iBioServerMtm = NULL;

		iServerEntry = NULL;

		}

	iNumFiles = 0;

	iFilesProcessed = 0;

	iMessagesCreated = 0;

	CMsvTestUtils::Reset();

	}

//

// Register a Sms Mtm server DLL

//

EXPORT_C void CBioTestUtils::CreateBioServerMtmRegL()

	{

	CreateServerMtmRegL(KUidMsgTypeSmartMessage, _L("BIO MTM"),KBioServerMtmFileName(), KBioClientMtmFileName(), TMsvTestDllInfo(KBioUiMtmFileName,2), TMsvTestDllInfo(KBioUiMtmFileName,1), KUidMsgTypeSmartMessage, KDataComponentFileName);

	}

CBioTestUtils::CBioTestUtils(RTest& aRTest)

: CMsvTestUtils(aRTest)

	{

	iBioServiceId = KMsvNullIndexEntryId;

	}

void CBioTestUtils::ConstructL()

	{

	TInt flags=NULL; // Settings flags for the base ConstructL() function

	//	Loading the DLLs

	iRTest.Next(_L("Create Data Component FileStores"));

	CMsvTestUtils::ConstructL(flags);

	iBioDb = CBIODatabase::NewL(iFs);

	FileSession().SetSessionPath(_L("c:\\"));

	}

// Overloaded constructor - allows developer to decide what components to create

void CBioTestUtils::ConstructL(TInt aCreationFlags)

	{

	iRTest.Next(_L("Initialising Data Components"));

	// 

	CMsvTestUtils::ConstructL(aCreationFlags);

	iBioDb = CBIODatabase::NewL(iFs);

	FileSession().SetSessionPath(_L("c:\\"));

	}

void CBioTestUtils::Panic(TBioTestUtilsPanic aPanic)

	{

	Panic((TInt) aPanic);

	}

void CBioTestUtils::Panic(TInt aPanic)

	{

	User::Panic(BIOTEST_PANIC, aPanic);

	}

EXPORT_C TMsvId CBioTestUtils::CreateBIOEntryL(TDesC& aText, TBIOMessageType aMessageType )

	{

	// Ensure that we have a valid service ID to work with:

	if (iBioServiceId==0)

		iBioServiceId = SetBIOServiceIdL();

	// First take the descriptor reference and create a new descriptor to manipulate.

	// Then convert '\n' to the paragraph delimiters used in proper SMS.

	HBufC* localBuffer = aText.AllocL();

	CleanupStack::PushL(localBuffer);

	TPtr messDes = localBuffer->Des();

	if (aMessageType != EBiovCardMessage && aMessageType != EBiovCalenderMessage)

		{

		// convert \r\n to \n since this is what is expected from SMS when not vCard data

		for (TInt i=0; i<messDes.Length(); i++)

			{

			if (messDes[i]==(TText)'\r' && i<messDes.Length()-1 && messDes[i+1]==(TText)'\n')

				messDes.Delete(i,1); 

			} 

		}

	//	Create and fill a CRichText object for the jobbie:

	CParaFormatLayer* paraFormatLayer = CParaFormatLayer::NewL();

	CleanupStack::PushL(paraFormatLayer);

	CCharFormatLayer* charFormatLayer = CCharFormatLayer::NewL();

	CleanupStack::PushL(charFormatLayer);

	CRichText* richText = CRichText::NewL(paraFormatLayer,charFormatLayer);

	CleanupStack::PushL(richText);

	TInt pos = richText->DocumentLength();	// Ought to be 0.

	richText->InsertL(pos, messDes);

	TMsvEntry newBioEntry;

	newBioEntry.SetNew(ETrue);

	newBioEntry.SetComplete(EFalse);

	newBioEntry.SetUnread(ETrue);

	newBioEntry.SetVisible(ETrue);

	newBioEntry.SetReadOnly(EFalse);

	newBioEntry.SetFailed(EFalse);

	newBioEntry.SetOperation(EFalse);

	newBioEntry.SetMultipleRecipients(EFalse);

	newBioEntry.SetAttachment(EFalse);

	newBioEntry.iMtm= KUidBIOMessageTypeMtm;

	newBioEntry.iType=KUidMsvMessageEntry;

	newBioEntry.iServiceId=iBioServiceId;

	TTime now;

	now.UniversalTime();

	newBioEntry.iDate = now;

	newBioEntry.iDescription.Set(richText->Read(0, richText->DocumentLength()));

	TBufC<KTelephoneNumberMaxLength> telNumber;

	HBufC* tempNumber = CreateDummyPhoneNumberL();

	telNumber = tempNumber->Des();

	newBioEntry.iDetails.Set(telNumber);

	// Finished with telNumber, so free up the memory:

	delete tempNumber; 

	// Change the iServiceId, iMtm, iBioType  for message:

	SetForMtmTypeL(newBioEntry, aMessageType);

	// Update the size to that of the attachment length  - correct? 

	// Otherwise just get 68

	newBioEntry.iSize = richText->DocumentLength();// msgSize;

	iClientServer == EServerSide ? CreateBioEntryServerSideL(newBioEntry,*richText) : CreateBioEntryClientSideL(newBioEntry,*richText);

	CleanupStack::PopAndDestroy(4); // richText, charFormatLayer, paraFormatLayer, localBuffer

	return newBioEntry.Id(); 

	}

void CBioTestUtils::SetForMtmTypeL(TMsvEntry& aEntry, TBIOMessageType aType)

	{

	TInt index;

	// Should have a match for the Message Type as the message is created with the SMS id's.

	switch(aType)

		{

		case ENoMessage:

			// Just to keep compiler happy!

			break;

		case EBioIapSettingsMessage:

			aEntry.iBioType  = KUidBIOInternetAccessPointMsg;

			break;

		case EBioEnpMessage:

			aEntry.iBioType =KUidBIOEmailNotificationMsg;

			break;

		case EBioRingTonesMessage:

			aEntry.iBioType =KUidBIORingingTonesMsg;

			break;

		case EBioOpLogoMessage:

			aEntry.iBioType =KUidBIOOperatorLogoMsg;

			break;

		case EBioCompBusCardMessage:

			aEntry.iBioType =KUidBIOBusinessCardMsg;

			break;

		case EBiovCardMessage:

			aEntry.iBioType =KUidBIOVCardMsg;

			break;

		case EBiovCalenderMessage:

			aEntry.iBioType =KUidBIOVCalenderMsg;

			break;

		case EBioWAPSettingsMessage:

			aEntry.iBioType =KUidBIOWAPAccessPointMsg;

			break;

		case EBioWPRVSettingsMessage:

			aEntry.iBioType =KUidBIOWPRVMsg;

			break;

		}

	// Set other TMsvEntry fields if we have a BIO message type

	if (aType != ENoMessage)

		{

		aEntry.SetMtmData2(0);

		aEntry.SetMtmData3(0);

		}

	// set description from BIF file

	iBioDb->GetBioIndexWithMsgIDL(TUid::Uid(aEntry.iBioType),index);

	if(index==KErrNotFound)

		User::Leave(KErrNotFound);

	aEntry.iDescription.Set(iBioDb->BifReader(index).Description());

	}

EXPORT_C void CBioTestUtils::LogCurrentMessageTypeL(TMsvId aMsvId)

	{

	// assume we're already pointing at a BIO message

	TMsvEntry entry;

	TMsvId oldId;

	if(iClientServer == EServerSide)

		{

		oldId = iServerEntry->Entry().Id();

		User::LeaveIfError(iServerEntry->SetEntry(aMsvId));

		entry = iServerEntry->Entry();

		}

	else

		{

		oldId = iMsvEntry->Entry().Id();

		iMsvEntry->SetEntryL(aMsvId);

		entry = iMsvEntry->Entry();

		}

	TInt biotype = entry.iBioType;

	if(biotype == KUidBIOInternetAccessPointMsg)

		{

		switch(entry.MtmData1())

			{

		case 1:

			WriteComment(_L("IACP basic IAP message"));

			break;

		case 2:

			WriteComment(_L("IACP basic mail message"));

			break;

		case 3:

			WriteComment(_L("IACP basic IAP & mail message"));

			break;

		case 7:

			WriteComment(_L("IACP Internet script message"));

			break;

		case 8:

			WriteComment(_L("IACP SMS settings message"));

			break;

		case 15:

			WriteComment(_L("Telephone settings message"));

			break;

		default:

			WriteComment(_L("Unsupported IACP type"));

			break;

			}

		}

	else if(biotype == KUidBIOEmailNotificationMsg)

			WriteComment(_L("Email notification message"));

	else if(biotype == KUidBIORingingTonesMsg)

			WriteComment(_L("Ringing tones message"));

	else if(biotype == KUidBIOOperatorLogoMsg)

			WriteComment(_L("Operator logo message"));

	else if(biotype == KUidBIOBusinessCardMsg)

			WriteComment(_L("Compact Business Card message"));

	else if(biotype == KUidBIOVCardMsg)

			WriteComment(_L("vCard message"));

	else if(biotype == KUidBIOVCalenderMsg)

			WriteComment(_L("vCalendar"));

	else if(biotype == KUidBIOWAPAccessPointMsg)

			WriteComment(_L("WAP settings message"));

	else

		WriteComment(_L("Unknown type"));

	if(iClientServer == EServerSide)

		{

		User::LeaveIfError(iServerEntry->SetEntry(oldId));

		}

	else

		{

		iMsvEntry->SetEntryL(oldId);

		}

	}

EXPORT_C TMsvId CBioTestUtils::CreateBIOEntryFromFileL(const TDesC& aFilename, TBIOMessageType aMessageType)

	{

	//First use the filename to get the message body, 

	// then convert '\n' to the paragraph delimiters used in proper SMS	

	HBufC* tempBuffer;

	TMsvId newEntryId;

	tempBuffer = ReadFromFileL(aFilename);

	CleanupStack::PushL(tempBuffer);

	newEntryId = CreateBIOEntryL(*tempBuffer, aMessageType );

	// Finished with our local descriptors - free up some memory

	CleanupStack::PopAndDestroy();  

	return newEntryId;

	}

EXPORT_C void CBioTestUtils::EmptyInboxMessagesL()

	{

	// Function gets the Inbox Entry, and then all the children of this entry.

	// Then we iterate through the selection deleting each entry.

	CMsvEntrySelection* inboxMessageSel;

	if(iClientServer == EServerSide)

		{

		inboxMessageSel = new (ELeave) CMsvEntrySelection;

		CleanupStack::PushL(inboxMessageSel);

		// Create a local Server entry, and get the children of the Global Inbox:

		User::LeaveIfError(iServerEntry->SetEntry(KMsvGlobalInBoxIndexEntryId));	

		iServerEntry->GetChildren(*inboxMessageSel ); // children of parent, ie global inbox

		if (inboxMessageSel->Count() != 0)

			{

			iServerEntry->DeleteEntries(*inboxMessageSel);

    		}

		//	Point back at something safe before we return:

		User::LeaveIfError(iServerEntry->SetEntry(KMsvRootIndexEntryId));

		}

	else

		{

		iMsvEntry->SetEntryL(KMsvGlobalInBoxIndexEntryId);

		inboxMessageSel = iMsvEntry->ChildrenL();

		CleanupStack::PushL(inboxMessageSel);

		if (inboxMessageSel->Count() != 0)

			{

			TInt count;

			TMsvId currentMsgId;

			for (count = 0; count < inboxMessageSel->Count(); count++)

				{

				currentMsgId= inboxMessageSel->At(count);

				// Delete this entry

				DeleteLocalEntrySynchronouslyL(*iMsvEntry, currentMsgId);

				}

    		}

		iMsvEntry->SetEntryL(KMsvRootIndexEntryId);

		}

	CleanupStack::PopAndDestroy();	// inboxMessageSel

	}

void CBioTestUtils::DeleteLocalEntrySynchronouslyL(CMsvEntry& aParentEntry, TMsvId anId)

	{ 

	//  Creates an entry synchronously by handling the asynchrous parts locally

	const TMsvSelectionOrdering& originalSort=aParentEntry.SortType();

	TMsvSelectionOrdering sort(originalSort);

	sort.SetShowInvisibleEntries(ETrue);

	aParentEntry.SetSortTypeL(sort);

	CMsvOperationWait* myDog=CMsvOperationWait::NewLC();

	CMsvOperation* op=aParentEntry.DeleteL(anId, myDog->iStatus);

	myDog->Start();

	CActiveScheduler::Start();

	const TInt err=op->iStatus.Int();

	TMsvLocalOperationProgress progress=McliUtils::GetLocalProgressL(*op);

	delete op;

	User::LeaveIfError(err);

	User::LeaveIfError(progress.iError);

	CleanupStack::PopAndDestroy();

	aParentEntry.SetSortTypeL(originalSort);

	}

//*************************************************************************

//

//		Getting BIO service ID

//

//*************************************************************************

// Get,or create, the default BIO service:

EXPORT_C TMsvId CBioTestUtils::SetBIOServiceIdL()

	{

	// If Bio service Id is none zero its already been set - just return the value:

	if (iBioServiceId)

		return iBioServiceId;

	if(iClientServer == EServerSide)

		SetBioServiceServerSideL();

	else

		SetBioServiceClientSideL();

	return iBioServiceId;

	}

void CBioTestUtils::SetBioServiceServerSideL()

	{

	// Set up the RootEntry sort order first:

	TMsvSelectionOrdering oldSortType = iServerEntry->Sort();

	TMsvSelectionOrdering sortType(KMsvGroupByType, EMsvSortByNone, ETrue);	

	iServerEntry->SetSort(sortType);

	// Search the root folder for any entries which are BIO Message services.

	// If none are found then create one.

	TMsvId localServiceId=KMsvNullIndexEntryId;

	localServiceId = DefaultServiceForMTML(KUidBIOMessageTypeMtm, ETrue);

	// Check that the Service id is valid, i.e. set iCurrentEntry context to service entry:

	TRAPD( error, iServerEntry->SetEntry(localServiceId) );

	if ( (localServiceId == KMsvUnknownServiceIndexEntryId)  || (error == KErrNotFound) )

		{

		// Id isn't a valid BIO service, so try and get the first BIO service:

		CMsvEntrySelection* sel = GetListOfAccountsWithMTMServerL(KUidBIOMessageTypeMtm);

		CleanupStack::PushL(sel);

		if (sel->Count())

			iBioServiceId=(*sel)[0];	// Select the first available service.

		CleanupStack::PopAndDestroy();	// sel

		if (localServiceId == KMsvUnknownServiceIndexEntryId || localServiceId == KMsvNullIndexEntryId)

			// Haven't found any valid BIO service, so try and create a BIO service:

			localServiceId=CreateDefaultBIOServiceL();

		}

		else

			User::LeaveIfError(error);  // An error other than no service occurred.

	__ASSERT_DEBUG( localServiceId != KMsvNullIndexEntryId, User::Panic(_L("BioGen"), KErrNotFound));

	//	Point back at something safe:

	User::LeaveIfError(iServerEntry->SetEntry(KMsvRootIndexEntryId));

	iServerEntry->SetSort(oldSortType);

	iBioServiceId = localServiceId;

	}

void CBioTestUtils::SetBioServiceClientSideL()

	{

	iMsvEntry->SetSortTypeL(TMsvSelectionOrdering(KMsvGroupByType, EMsvSortByNone, ETrue));

#if defined (_DEBUG)

	if (iMsvEntry->EntryId() != KMsvRootIndexEntryId)  //iMsvEntry should be set to root

		User::Leave(KErrNotFound);	//replaces a panic - ENotAServiceEntry

#endif

	TMsvId localServiceId=KMsvNullIndexEntryId;

	localServiceId=DefaultServiceForMTML(KUidBIOMessageTypeMtm, ETrue);

	//Check if there is a valid entry for this ID

	TRAPD(ret, /*const TMsvEntry& ent=*/iMsvEntry->ChildDataL(localServiceId));

	if (localServiceId == KMsvUnknownServiceIndexEntryId || ret==KErrNotFound)

		{

		// Our Id isn't a valid BIO service, possibly because there isn't a default 

		// BIO service.  So try and get the first BIO service.

		CMsvEntrySelection* sel=GetListOfAccountsWithMTMClientL(KUidBIOMessageTypeMtm);

		if (sel->Count())

			localServiceId=(*sel)[0]; // select the first available service