// 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 "TESTENV.H"
#include <e32test.h>
#include <e32uid.h>

#include <msvruids.h>
#include <msvids.h>
#include <msvuids.h>

#include <mtmdef.h>

#include <txtrich.h>                            //      rich text stuff
#include <txtfmlyr.h>                           //      para format gubbins..

#include <bsp.h>
#include "biotestutils.h"



//
class TestScheduler : public CActiveScheduler
	{
	public:
	void Error (TInt aError) const;
	};

//
void TestScheduler::Error(TInt /*anError*/) const
	{
	CActiveScheduler::Stop();
	}


// local variables etc //

LOCAL_D RTest test(_L("BIOC.dll Testrig"));
LOCAL_D CTrapCleanup* theCleanup;
LOCAL_D RFs theFs;      
LOCAL_D TestScheduler* scheduler;

LOCAL_D TMsvSelectionOrdering   msvSelectionOrdering;

#define KPeriod 10000   // period of timer

//

//
class TestUiTimer : public CTimer
	{
public:
	static TestUiTimer* NewLC();
	~TestUiTimer();

	void RunL();
	void DoCancel();
	void ConstructL();
	void IssueRequest();
	void SetOperation(CMsvOperation*);
	TTimeIntervalMicroSeconds32 period;
protected:
	TestUiTimer();
	
	CMsvOperation*                          iOperation;
	};

//
TestUiTimer* TestUiTimer::NewLC()
	{
	TestUiTimer* self = new(ELeave) TestUiTimer();
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}

TestUiTimer::TestUiTimer()
	: CTimer(5)
	{
	period = KPeriod;
	}

TestUiTimer::~TestUiTimer()
	{
	delete iOperation;
	}

void TestUiTimer::ConstructL()
	{
	CTimer::ConstructL();
	CActiveScheduler::Add(this);
	}

void TestUiTimer::IssueRequest()
	{
	After(period);
	}

void TestUiTimer::SetOperation(CMsvOperation *aOperation)
	{
	if(iOperation)
		{
		delete iOperation;
		iOperation=NULL;
		}
	iOperation = aOperation;
	}

void TestUiTimer::DoCancel()
	{
	CTimer::DoCancel();
//      delete iOperation;
//      iOperation = NULL;
	}

void TestUiTimer::RunL()
	{
	// display the current progress
	if(iOperation!=NULL)
		{
		TBioProgress temp;      
		TPckgC<TBioProgress> paramPack(temp);

		const TDesC8& progBuf = iOperation->ProgressL();        
		paramPack.Set(progBuf);
		TBioProgress progress=paramPack();      

		test.Console()->SetPos(0, 13);
		test.Printf(TRefByValue<const TDesC>_L("   Operation: %d"),progress.iBioState);
		test.Printf(TRefByValue<const TDesC>_L("   Progress:  Error: %d\n"),
					progress.iErrorCode);

		}
	IssueRequest();
	};


//
class CNbscTester : public CBase
	{
public:
	  // Construction
	static CNbscTester* NewLC();

	  // Destruction
	~CNbscTester();

	  // Issue request
	void StartL();

	void TestFindBodyL(const TDesC& aText);
	void TestFindSubjectL(const TDesC& aText);

private:
	CNbscTester();
	void ConstructL();
	// functions
	void CreateParserL();
	void ReParseL();
	void ReProcessL();
	void ProcessError(TInt& aError);
	
	 // Data members defined by this class
	CMsvEntrySelection* iSelection;
	CMsvEntrySelection*     iMsvSelection;  // selection of test messages
	CBioTestUtils*          iBioTestUtils;
	CBIOClientMtm*          iBioClientMtm;

	TUint iMenuState;
	TUint iPrevState;

	TUint iParseState;
	TestUiTimer* iTimer;

	TInt            iNumMessages;
	TInt            iMsgCtr;
	TInt            iTestCtr;
	TBool           iAllTestsSuccessful;
	enum
		{
		EParserIdle,
		EParserCreate,
		EParserParse,
		EParserCommit
		};
	};

//
CNbscTester* CNbscTester::NewLC()
	{
	CNbscTester* self = new(ELeave) CNbscTester();
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}

CNbscTester::CNbscTester()
	{
	}

void CNbscTester::ConstructL()
	{
	// create test utilities
	iBioTestUtils = CBioTestUtils::NewL(test, ETuGoClientSide | ETuCleanMessageFolder);

	test.Printf(_L("Creating services"));
	iBioTestUtils->CreateServicesL();

	User::After(2500000);
	
	iBioTestUtils->TestStart(1,_L("Instant client"));
	TRAPD(error,iBioTestUtils->InstantiateClientMtmsL(););
	iBioTestUtils->TestFinish(1,error);
	if(error)
		User::Leave(error);

	iBioClientMtm = iBioTestUtils->iBioClientMtm;
	
	iSelection = new (ELeave) CMsvEntrySelection;
	CleanupStack::PushL(iSelection);
	CleanupStack::Pop();    //iSelection
	iTimer = TestUiTimer::NewLC();
	CleanupStack::Pop();    // iTimer
	iParseState = EParserCreate;
	iAllTestsSuccessful = ETrue;
	}

CNbscTester::~CNbscTester()
	{
	delete iSelection;
	delete iMsvSelection;
	delete iTimer;
	delete iBioTestUtils;
	}

void CNbscTester::StartL()
    {
	iBioTestUtils->TestStart(iTestCtr,_L("Generate Test Messages"));
	iMsvSelection = iBioTestUtils->GenerateMessagesL();
	iNumMessages = iMsvSelection->Count();
	iMsgCtr = 0;
	// 
	iTestCtr++;

	for(TInt i =0; i < iNumMessages; i++)
		{
		iSelection->Reset();

		iSelection->AppendL((*iMsvSelection)[i]);

		iBioTestUtils->TestStart(iTestCtr,_L("Parse and process"));
		TRAPD(error,CreateParserL());
		ProcessError(error);
		if(error == KErrNone)
			{
			iBioTestUtils->TestFinish(iTestCtr);
			iTestCtr++;
			iBioTestUtils->TestStart(iTestCtr,_L("Reparse"));
			TRAP(error,ReParseL());
			ProcessError(error);
			iBioTestUtils->TestFinish(iTestCtr,error);
			if(error == KErrNone)
				{
				iTestCtr++;
				iBioTestUtils->TestStart(iTestCtr,_L("Reprocess"));
				TRAP(error,ReProcessL());
				ProcessError(error);
				if(error==KErrNone)
					iBioTestUtils->TestFinish(iTestCtr);
				else
					{
					iBioTestUtils->TestFinish(iTestCtr,error);
					iAllTestsSuccessful = EFalse;
					}
				}
			}
		else
			{
			iBioTestUtils->TestFinish(iTestCtr,error);
			iAllTestsSuccessful = EFalse;
			}

		iTestCtr++;
		iBioTestUtils->TestStart(iTestCtr,_L("test find in body"));
		TRAP(error,TestFindBodyL(_L("yashar")));
		iBioTestUtils->TestFinish(iTestCtr,error);

		iTestCtr++;
		iBioTestUtils->TestStart(iTestCtr,_L("test find in subject"));
		TRAP(error,TestFindSubjectL(_L("Configuration")));
		iBioTestUtils->TestFinish(iTestCtr,error);
		}
	if(iAllTestsSuccessful)
		iBioTestUtils->TestHarnessCompleted();
    }

void CNbscTester::ProcessError(TInt& aError)
	{
	if(aError==KErrNotSupported)
		{
		aError = KErrNone;
		iBioTestUtils->WriteComment(_L("Unsupported operation"));
		}
	else if((aError <= -500 && aError >= -521) || (aError <= -600 && aError >= -614))
		{
		aError = KErrNone;
		iBioTestUtils->WriteComment(_L("Corrupt or missing Bio-data"));
		}
	}

//
// Try a get a parser
//
void CNbscTester::CreateParserL()
	{
	TBuf8<1> aParameter;
	CMsvOperationWait* wait = CMsvOperationWait::NewLC();
	wait->iStatus = KRequestPending;
	wait->Start();
	
	CMsvOperation* operation = iBioClientMtm->InvokeAsyncFunctionL( KBiosMtmParseThenProcess, *iSelection, aParameter, wait->iStatus);
	
	iTimer->SetOperation(operation);
	iTimer->IssueRequest();
	
	CActiveScheduler::Start();

	TInt error = operation->iStatus.Int();
	iTimer->Cancel();
	CleanupStack::PopAndDestroy();  // wait
	if(error !=KErrNone)
		User::Leave(error);
	}

//
// Interpret the message
//
void CNbscTester::ReParseL()
	{
	TBuf8<1> parameter;

	CMsvOperationWait* wait = CMsvOperationWait::NewLC();
	wait->iStatus = KRequestPending;
	wait->Start();
	
	CMsvOperation* operation = iBioClientMtm->InvokeAsyncFunctionL( KBiosMtmParse, *iSelection, parameter, wait->iStatus);

	iTimer->SetOperation(operation);
	iTimer->IssueRequest();

	CActiveScheduler::Start();
	iTimer->Cancel();
	TInt error = operation->iStatus.Int();
	
	CleanupStack::PopAndDestroy();  // wait
	if(error !=KErrNone)
		User::Leave(error);
	}

//
// Act on the changes
// 
void CNbscTester::ReProcessL()
	{
	TBuf8<1> aParameter;
	CMsvOperationWait* wait = CMsvOperationWait::NewLC();
	wait->iStatus = KRequestPending;
	wait->Start();

	CMsvOperation* operation = iBioClientMtm->InvokeAsyncFunctionL(KBiosMtmProcess, *iSelection, aParameter, wait->iStatus);
	
	iTimer->SetOperation(operation);
	iTimer->IssueRequest();
	
	CActiveScheduler::Start();

	TInt error = operation->iStatus.Int();
	iTimer->Cancel();
	
	CleanupStack::PopAndDestroy();  // wait
	if(error !=KErrNone)
		User::Leave(error);
	}

void CNbscTester::TestFindBodyL(const TDesC& aText)
	{
	iBioClientMtm->SwitchCurrentEntryL((*iSelection)[0]);
	iBioClientMtm->LoadMessageL();
	TMsvPartList retPart =  iBioClientMtm->Find(aText,KMsvMessagePartBody);
	if(retPart&KMsvMessagePartBody)
		iBioTestUtils->WriteComment(_L("Found in body text"));
	else
		iBioTestUtils->WriteComment(_L("Not found in body text"));
	
	TRAP_IGNORE(iBioClientMtm->SaveMessageL());
	TRequestStatus st;
	TMsvId s =0;
	TRAP_IGNORE(iBioClientMtm->ReplyL(s,retPart,st));
	TRAP_IGNORE(iBioClientMtm->ForwardL(s,retPart,st));
	iBioClientMtm->ValidateMessage(retPart);
	
	const TBufC<1> yy;
	TRAP_IGNORE(iBioClientMtm->AddAddresseeL(yy) );
	TRAP_IGNORE(iBioClientMtm->AddAddresseeL(yy ,yy) );
	TInt ii = 0;
	iBioClientMtm->RemoveAddressee(ii);
	TBuf8<1> yy1;
	const CMsvEntrySelection* selection1 = new(ELeave)CMsvEntrySelection();
	TRAP_IGNORE(iBioClientMtm->InvokeSyncFunctionL( ii,*selection1, yy1));
	
	TUid parserUid =TUid::Uid(10);
	iBioClientMtm->QueryCapability(parserUid,ii);
	delete selection1;
	}

void CNbscTester::TestFindSubjectL(const TDesC& aText)
	{
	iBioClientMtm->LoadMessageL();
	TMsvPartList retPart = iBioClientMtm->Find(aText,KMsvMessagePartDescription);
	if(retPart&KMsvMessagePartDescription)
		iBioTestUtils->WriteComment(_L("Found in Subject"));
	else
		iBioTestUtils->WriteComment(_L("Not found in sbject"));
	}

LOCAL_C void doMainL()
	{
	scheduler = new (ELeave) TestScheduler;
	CActiveScheduler::Install( scheduler );

	User::LeaveIfError(theFs.Connect());
	theFs.SetSessionPath(_L("C:\\"));

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

	CNbscTester* activeConsole = CNbscTester::NewLC();
	CleanupStack::Pop();
	activeConsole->StartL();        //Start the active console
	// Cleanup exit
	delete activeConsole;

	theFs.Close( );
	delete scheduler;       

	}


GLDEF_C TInt E32Main()
	{       
	__UHEAP_MARK;
	test.Start(_L("T_BIOC - Test Harness"));
	theCleanup=CTrapCleanup::New();
	TRAPD(ret,doMainL());           
	test(ret==KErrNone);
	delete theCleanup;      
	test.Console()->SetPos(0, 13);
	test.End();
	test.Close();
	__UHEAP_MARKEND;
	return(KErrNone);
	}