// 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:

//	Test harness for CBioClientSideTestUtilities. 

//

//  BIO messages are created by synchronous calls....

#pragma warning( disable : 4100 )

//  Includes...

#include <e32test.h>

#include <e32hal.h>

#include <e32uid.h>

#include <msvapi.h>

#include <msvuids.h>

#include <msvids.h>

#include <f32fsys.h>

#include <s32file.h>

#include <barsc.h>

#include <msvreg.h>

#include <txtrich.h>				//	rich text stuff

#include <txtfmlyr.h>				//	para format gubbins..

#include <biouids.h>   // Important defines for use in the BIO messaging project

#include <bitsids.h>	//Message uids defines for the Test harnesses

#include "biotestutils.h"

// Uncomment following define to print the details to screen

// Difficult to view as there's so much information

//  Constants ids.

//  Classes defined/used

class CTestScheduler;

class CObserverTester;

class CDummySessionObserver;

//  Global functions..

//  functions()

GLDEF_C void doMainL();

GLDEF_C TInt E32Main();

//  Resources..

GLDEF_C RTest test(_L("BIO Message Generator Test Rig"));

LOCAL_D CTrapCleanup*       theCleanup;

LOCAL_D CTestScheduler*		theScheduler;

LOCAL_D RFs                 rFs;

// States for the tester

typedef enum

    {

    EStart,

	EReadingFiles,

	ECreatingMessages,

	EGeneratingResults,

    EStop

    } TTesterState;

//

//  CTestScheduler - test active scheduler..

//

class CTestScheduler : public CActiveScheduler

    { 

    public:

        //  inline

        void Error(TInt aError) const;

    };

void CTestScheduler::Error(TInt anError) const

    {

    CActiveScheduler::Stop();

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

    }

//

//

//																				//

//			CClientSideMessGeneratorTester - class definition					//

//																				//

//

class CClientSideMessGeneratorTester : public CActive

    {

    //  public API

    public:

        static CClientSideMessGeneratorTester * NewL(TTimeIntervalMicroSeconds32 aTime);

        static CClientSideMessGeneratorTester * NewLC(TTimeIntervalMicroSeconds32 aTime);

        ~CClientSideMessGeneratorTester ();

		//	Starts everything off

		void StartL();

		//  Sets the active scheduler going

        void QueueOperationAsync(TInt aErr);

		//  Asks Message server to enumerate the results..

        TInt GenerateResults(); 

        void DoGenerateResultsL();   

    protected:

        CClientSideMessGeneratorTester (TTimeIntervalMicroSeconds32 aTime);

        void ConstructL();

        void CreateFilenameArrayL();

		void GenerateNextMessageL();

		TInt DoGenerateMessages();

		void InitialiseTesterL();

		void SetMessageType(const TDesC& aFileName);

#ifdef _TBIOTEST_LOGGING_

		//  Additional Logging functionality

		void LogNewMessageDetails(TMsvId amessageId);

		void ChangeELineBreaksToLF(const TDesC& aDesIn,  TBuf<1024>& aBuffer);

		TBool IsEOL( TChar ch); // TUint8 ch );	    

#endif  //_TBIOTEST_LOGGING_

    private:    // Active Object functions

        void DoCancel();

        void RunL();

    private:

        //  Resources

		CBioTestUtils*				iBIOGenerator;

        RTimer						iTimer;

		CDir*						iDir;		

		TInt						iNumFiles;

		TInt						iFilesProcessed;

		TInt						iMessagesCreated;

		TBIOMessageType				iCurrentMessageType;

		//  States   

		TTesterState				iState;

        //  Service Ids

        TMsvId                      iBIOServiceId;

        TMsvId                      iNewEntryId;

        //  General.

        TTimeIntervalMicroSeconds32 iNotificationPeriod;

        TBool                       iReleaseContextOnCreate;

        TMsvLocalOperationProgress              iProgress;

        TPckgBuf<TMsvLocalOperationProgress>    iLocProgressBuf;

    };

//

//																				//

//			Implementation The tester class..									//

//																				//

//

CClientSideMessGeneratorTester * CClientSideMessGeneratorTester ::NewL(TTimeIntervalMicroSeconds32 aTime)

    {

    CClientSideMessGeneratorTester * self = 

						CClientSideMessGeneratorTester ::NewLC(aTime);

    CleanupStack::Pop();

    return self;

    }

CClientSideMessGeneratorTester * CClientSideMessGeneratorTester ::NewLC(TTimeIntervalMicroSeconds32 aTime)

    {

    CClientSideMessGeneratorTester * self = 

					new (ELeave) CClientSideMessGeneratorTester (aTime);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

CClientSideMessGeneratorTester ::CClientSideMessGeneratorTester (TTimeIntervalMicroSeconds32 aTime)

: CActive(EPriorityNormal),

iNotificationPeriod(aTime)

    {

    }

CClientSideMessGeneratorTester ::~CClientSideMessGeneratorTester ()

    {

	// NB don't delete the Logger or Printer objects because this object doesn't own them

	Cancel();

    delete iDir;

	//

	delete iBIOGenerator;

    }

void CClientSideMessGeneratorTester ::ConstructL()

	{

	// Create the SMS Test Message Utility object

	iBIOGenerator = CBioTestUtils::NewL(test);

	iBIOGenerator->GoClientSideL();

	iNumFiles = 0;

	iFilesProcessed = 0;

	iMessagesCreated = 0;

	//	Add ourselves to the active scheduler

    User::LeaveIfError(iTimer.CreateLocal());

    CActiveScheduler::Add(this);

    }

//

//																				//

//						Start the tester off									//

//																				//

//

void CClientSideMessGeneratorTester ::StartL()

	{

    // Set the Scheduler going so we go to our RunL().

	iState=EStart;

    QueueOperationAsync(KErrNone);

	}

//

//																				//

//							Active Object Stuff									//

//																				//

//

void CClientSideMessGeneratorTester ::RunL()

    {

    TInt err = iStatus.Int();

    if(err != KErrNone)

        {

		iBIOGenerator->TestHarnessFailed(err);

        CActiveScheduler::Stop();

        }

    switch(iState)

        {

		case EStart:   

			iState = EReadingFiles;

			iBIOGenerator->TestStart(1,_L("Initialise tester"));

			InitialiseTesterL();

			iBIOGenerator->TestFinish(1);

            break;

		case EReadingFiles:

			iState = ECreatingMessages;

			test.Printf(_L("Reading Text Filenames \n"));

			iBIOGenerator->TestStart(2,_L("Create filename array"));

			CreateFilenameArrayL();

			iBIOGenerator->TestFinish(2);

			QueueOperationAsync(KErrNone);	

			break;

		case ECreatingMessages:   // don't set the next state here

			if (iFilesProcessed ==0)

				iBIOGenerator->TestStart(3,_L("Generating messages"));

			iBIOGenerator->SetSessionPath(KBIOTxtFilePath);

		    GenerateNextMessageL();  // state gets set here when we processed all the messages

			QueueOperationAsync(KErrNone);

			break;

        // 1st time in start the notifications.

		case EGeneratingResults:

			iState = EStop;

			iBIOGenerator->TestFinish(3);

			iBIOGenerator->TestStart(4,_L("Do some results"));

            QueueOperationAsync(KErrNone);

			break;

		case EStop:

			iBIOGenerator->FindChildrenL(KMsvGlobalInBoxIndexEntryId);

			iBIOGenerator->TestHarnessCompleted();

			CActiveScheduler::Stop();

            break;

        }

    }

void CClientSideMessGeneratorTester ::DoCancel()

    {

    }

void CClientSideMessGeneratorTester ::QueueOperationAsync(TInt aErr)

    {

    TRequestStatus*  pS = &iStatus;

	iStatus = KRequestPending;

    User::RequestComplete(pS, aErr);

	SetActive();

    }

void CClientSideMessGeneratorTester ::InitialiseTesterL()

	{

	// Get the NB if we don't need this two step process, use SetSmsServiceL().

	//iBIOGenerator->SetSmsServiceIdL();

	iBIOGenerator->SetBIOServiceIdL();

	// Empty the Inbox

	iBIOGenerator->EmptyInboxMessagesL();

	QueueOperationAsync(KErrNone);

	}

void CClientSideMessGeneratorTester ::CreateFilenameArrayL()

    {

	// Creates an array of descriptors for the body parts of our messages

	//Check that the source directory exists, if not warn the user and create one

	TInt err;

	if (iDir)

		delete iDir;

	err = rFs.GetDir(KBIOTxtFilePath, KEntryAttMatchMask, ESortByName, iDir);

	if (err == KErrPathNotFound)

		{

		test.Printf(_L("Error - source file directory not found\n\n"));

		TInt makeDirErr = rFs.MkDirAll(KBIOTxtFilePath);

		if (makeDirErr==KErrNone)

			{

			test.Printf(_L("Creating directory for files\nPlease add files to %S\n"), KBIOTxtFilePath);

			User::After(1000000);

 			User::Leave(KErrNotFound);

			}

		else 

			{

			test.Printf(_L("Error %d occurred when making directory %S"),makeDirErr, &KBIOTxtFilePath);	

			User::Leave(makeDirErr);

			}

		}

	else if (err!=KErrNone)

		{

		test.Printf(_L("Error %d occurred"),err );

		User::After(100000);

		User::Leave(err);

		}

	// Set the session path for the RF

	rFs.SetSessionPath(KBIOTxtFilePath);

	test.Printf(_L("Set Session path to %S \n"), &KBIOTxtFilePath);

	//  Get a directory listing for the textfiles...

	if (iDir) 

		delete iDir;

	User::LeaveIfError(rFs.GetDir(_L("*.txt"), KEntryAttNormal, ESortByName, iDir));

    TInt count = iDir->Count();

    if(count == 0)

        {

		test.Printf(_L("No files in the source directory %S !!"), &KBIOTxtFilePath);

        User::Leave(KErrNotFound);   // No files to process

        }

	iNumFiles = count;

	iCurrentMessageType = ENoMessage;  // Set to error condition

	// Display some info for the user

	test.Printf(_L("Have %d text files in directory \n"), count);		

	test.Printf(_L("\n")); //move down one line 

    }

//

//																					//

//						Creating one message stuff.									//

//																					//

//

void CClientSideMessGeneratorTester ::GenerateNextMessageL()

	{

	TBufC<KMaxFileName> currentFile;

	TEntry tempEntry;

	HBufC* tempDesc;

	// Check if there are any more files of the current type

	if (iFilesProcessed < iNumFiles)

		{

		tempEntry = (*iDir)[iFilesProcessed];

		currentFile=( tempEntry.iName );

		// Not processed all the messages - so keep the current state

		SetMessageType(currentFile);

		iFilesProcessed++;   // Here because need to update the counter promptly

		if (iCurrentMessageType!=ENoMessage) // skip any dodgy filenames

			{

			tempDesc = currentFile.AllocL();

			CleanupStack::PushL(tempDesc);

			test.Console()->SetPos(0, 8);

			test.Printf(_L("Reading file %S"), tempDesc);

			iBIOGenerator->CreateBIOEntryFromFileL(currentFile, iCurrentMessageType);

			iMessagesCreated++;

			test.Console()->SetPos(0, 10);

			test.Printf(_L("Created entry No. %d\n"), (iMessagesCreated));

			test.Printf(_L("So far have discarded %d files out of a total of %d\n"), (iFilesProcessed-iMessagesCreated), iNumFiles);

			CleanupStack::PopAndDestroy(); // tempDesc;

			}

		}

	else if (iFilesProcessed == iNumFiles) // Completed everything

		{

		iState =EGeneratingResults;  // Done creating messages

		}

	else // shouldn't be anything else as iMessagesProcessed

		{

		User::Leave(KErrUnknown);  // Have an error but don't know how

		}

	}

void CClientSideMessGeneratorTester ::SetMessageType(const TDesC& aFileName)

	{

	// Check each file prefix in turn with the filename passed as a parameter. 

	// If cannot find the correct type set to ENoMessage to indicate an error. 

	// GenerateNextMessage will then skip the file!

	if (aFileName.MatchF(KBIOIapPrefix)==0)  // File starts with "iap"

		{

		iCurrentMessageType = EBioIapSettingsMessage; 

		return;

		}

	if(aFileName.MatchF(KBIOEnpPrefix)==0) // File name starts "enp"

		{

		iCurrentMessageType = EBioEnpMessage;

		return;

		}

	if (aFileName.MatchF(KBIORingTonePrefix)==0)//Filename begins "rtone"

		{

		iCurrentMessageType = EBioRingTonesMessage;

		return;

		}

	if (aFileName.MatchF(KBIOOpLogoPrefix)==0)	// Filename begins "oplogo"

		{

		iCurrentMessageType = EBioOpLogoMessage;

		return;

		}

	if (aFileName.MatchF(KBIOcBusinessCardPrefix)==0)// Filename begins "cbc"

		{

		iCurrentMessageType = EBioCompBusCardMessage;

		return;

		}

	if (aFileName.MatchF(KBIOvCardPrefix)==0)

		{

		iCurrentMessageType = EBiovCardMessage;

		return;

		}

	if (aFileName.MatchF(KBIOvCalenderPrefix)==0)

		{

		iCurrentMessageType = EBiovCalenderMessage; 

		return;

		}

	// if we've reached this point it's an unknown filename 

	iCurrentMessageType = ENoMessage;

	}

TInt CClientSideMessGeneratorTester ::GenerateResults()

    {

    TInt err = KErrNone;

    TRAP(err, DoGenerateResultsL());

    return err;

    }

void CClientSideMessGeneratorTester ::DoGenerateResultsL()

    {

	}

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

//

//  Implementation; global stuff

//

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

GLDEF_C TInt E32Main()

    {

	__UHEAP_MARK;

	theCleanup = CTrapCleanup::New();

	TRAPD(err,doMainL());		

	test(err==KErrNone);

	delete theCleanup;	

	test.End();

	test.Close();

	__UHEAP_MARKEND;

	return(KErrNone);

    }

GLDEF_C void doMainL()

    {

	// Create an active scheduler for the program session

    theScheduler = new (ELeave) CTestScheduler();

    CleanupStack::PushL(theScheduler);

    CActiveScheduler::Install(theScheduler);

    test.Title();

    test.Start(_L("Starting test harness"));

    rFs.Connect();

    //  Can't actually lock a message client side

    CClientSideMessGeneratorTester * theTester = 

						CClientSideMessGeneratorTester ::NewLC(100000); //  release context on create 

	theTester->StartL();

	CActiveScheduler::Start();

    CleanupStack::PopAndDestroy(); //theTester

    CleanupStack::PopAndDestroy(); //theScheduler

	rFs.Close();

    }