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

//

#include <logcli.h>

#include <logview.h>

#include <logwrap.h>

#include <txtetext.h>

#include <msventry.h>

#include <msvapi.h>

#include <msvids.h>

#include <barsc.h>

#include "msvtestutilsbase.h"

#include <cntdb.h>

#include <cntitem.h>

#include <cntfldst.h>

#include <bautils.h>

#include <e32property.h>

#include "msvtestutils.h"

#include <simtsy.h>

_LIT(KMsvTestFileInputBase,"MsgTest");

_LIT(KMsvTestFileOutputBase,"MsgLogs");

// this is used if we can't find MsgLogs anywhere

_LIT(KMsvTestFileDefaultOutputBase,"\\MsgLogs\\");

_LIT(KMsvPathSep,"\\");

#define KMaxLogLineLength 256

//

//

// CTestActive

//

//

EXPORT_C CTestActive::CTestActive()

: CActive(0)

	{

	CActiveScheduler::Add(this);

	}

EXPORT_C CTestActive::~CTestActive()

	{

	Cancel();

	}

EXPORT_C void CTestActive::DoCancel()

	{

	TRequestStatus* s=&iStatus;

	User::RequestComplete(s, KErrNone);

	}

EXPORT_C void CTestActive::StartL()

	{

	SetActive();

	}

EXPORT_C void CTestActive::RunL() 

	{

	CActiveScheduler::Stop();

	}

//

//

// CTestTimer

//

//

EXPORT_C CTestTimer::CTestTimer()

: CTimer(EPriorityLow)

	{}

EXPORT_C void CTestTimer::RunL()

	{

	if (!iReport)

		{

		CActiveScheduler::Stop();

		}

	else

		{

		User::RequestComplete(iReport, iStatus.Int());

		iReport = NULL;

		}

	}

EXPORT_C CTestTimer* CTestTimer::NewL()

	{

	CTestTimer* self = new(ELeave) CTestTimer();

	CleanupStack::PushL(self);

	self->ConstructL(); // CTimer

	CActiveScheduler::Add(self);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C void CTestTimer::AfterReq(TTimeIntervalMicroSeconds32 aSec, TRequestStatus& aStatus)

	{

	iReport = &aStatus;

	aStatus = KRequestPending;

	After(aSec);

	}

//

//

// CTestUtils

//

//

EXPORT_C CTestUtils::CTestUtils(RTest& aRTest)

: iRTest(aRTest), iLogToConsole(ETrue), iLogToFile(ETrue)

	{

	TBuf<256> command;

		User::CommandLine(command);

	command.Trim();

	SetRunAuto(command.FindF(KTestShowMenu) == KErrNotFound);

	if (!RunAuto())

		iRTest.Printf(_L("Not Run Auto. Command line: %S\n"), &command);

	}

EXPORT_C CTestUtils::~CTestUtils()

	{

	ResetMenu();

	delete iMenu;

	CloseMainLog();

	iFs.Close();

	}

EXPORT_C void CTestUtils::ConstructL()

	{

	User::LeaveIfError(iFs.Connect());

	OpenMainLogL();

	WriteToLog(KTestHeader);

	iMenu = new (ELeave) CArrayPtrFlat<HBufC>(10);

	}

TBool CTestUtils::CheckLogStatus(const TBool aEventViewRet, const TRequestStatus& aStatus)

	{

	TBool ret = ETrue;

	TBufC<256> txtBuf;

	TPtr txt = txtBuf.Des();

	if (!aEventViewRet)

		{

		txt.Zero();

		txt.Append(_L("No more events in the LogView!"));

		AppendEol(txt, EFalse);

		Printf(txt);

		ret = EFalse;

		}

	else if (aStatus.Int() != KErrNone)

		{

		Printf(_L("\nError: CLogViewEvent async request completed with error %d.\n"), aStatus.Int());

		ret = EFalse;

		}

	return ret;

	}

EXPORT_C void CTestUtils::DoBuf(TDes8& buf, const TDesC& label, const TDesC& data)

	{

	buf.Zero();

	buf.Copy(label); 

	buf.Append(data);

	buf.Append(_L("\r\n"));

	}

EXPORT_C void CTestUtils::DoBuf(TDes8& buf, const TDesC& label, const TDesC8& data)

	{

	buf.Zero();

	buf.Copy(label); 

	buf.Append(data);

	buf.Append(_L("\r\n"));

	}

EXPORT_C void CTestUtils::WriteToFileL(RFile& aFile, TDesC8& aInputLine)

	{

	User::LeaveIfError(aFile.Write(aInputLine));

	}

EXPORT_C void CTestUtils::WriteToFileL(RFile& aFile, const TDesC& aInputLine)

	{

	HBufC8* pOutputLine = HBufC8::NewLC(aInputLine.Length()*2);

	TPtr8 pOutput = pOutputLine->Des();

	pOutput.Zero();

	TUint lowChar;

	TUint highChar;

	TInt i=0;

	while(i<aInputLine.Length())

		{

		lowChar=((TUint)aInputLine[i])&0x00FF;

		pOutput.Append(lowChar);

		highChar=((TUint)aInputLine[i++])&0xFF00;

		pOutput.Append(highChar);

		}

	aFile.Write(pOutput);

	CleanupStack::PopAndDestroy(); // pBodyText

	}

EXPORT_C void CTestUtils::RemoveRichtextFormating(TDes& aSourceLine)

	{

	TUint8* ptr = (TUint8*)aSourceLine.Ptr();

	TUint8* start = ptr;

	TInt totalLength = aSourceLine.Length()*2;

	do {

		if(*ptr==CEditableText::EParagraphDelimiter || *ptr==CEditableText::ELineBreak || *ptr==CEditableText::EPageBreak)

			*ptr=0x0A;

		} while((++ptr-start)<totalLength);

	}

EXPORT_C TInt CTestUtils::DisplayFile(const TDesC& aFileName)

	{

	RFile file;

	TInt err = file.Open(iFs, aFileName, EFileShareAny | EFileRead | EFileStreamText);

	if (err != KErrNone)

		return err;

	TBuf8<256> text8;

	TBuf<512> text16;

	while (file.Read(text8) == KErrNone && text8.Length())

		{

		text16.Copy(text8);

		Printf(text16);

		}

	file.Close();

	return KErrNone;

	}

EXPORT_C TInt CTestUtils::DisplayMenu(const TDesC& aTitle, TInt aMaxAttempts, TBool aAllowExit, TBool aClearScreenBefore, TBool aClearScreenAfter)

	{

	TBool logToFile = SetLogToFile(EFalse);

	TInt ret = DoDisplayMenu(aTitle, aMaxAttempts, aAllowExit, aClearScreenBefore, aClearScreenAfter);

	SetLogToFile(logToFile);

	return ret;

	}

TInt CTestUtils::DoDisplayMenu(const TDesC& aTitle, TInt& aMaxAttempts, TBool aAllowExit, TBool aClearScreenBefore, TBool aClearScreenAfter)

	{

	if (aMaxAttempts < 1)

		{

		ClearScreen(aClearScreenAfter);

		return 0;

		}

	aMaxAttempts--;

	TInt count = MenuCount();

	__ASSERT_ALWAYS(count > 0 && count < 10, Panic(KErrArgument));

	ClearScreen(aClearScreenBefore);

	TBuf<256> buf = aTitle;

	AppendEol(buf, EFalse);

	AppendEol(buf, EFalse);

	Printf(buf);

	for (TInt curOption = 0; curOption < count; curOption++)

		{

		buf.Zero();

		buf.Append(_L("%d : "));

		buf.Append(*(iMenu->At(curOption)));

		AppendEol(buf, EFalse);

		Printf(buf, curOption + 1); 

		}

	if (aAllowExit)

		{

		Printf(_L("\nX : Exit\n"));

		}

	Printf(_L("\nEnter your selection from 1 to %d\n"), count);

	TInt result = iRTest.Getch();

	if (aAllowExit && (result == 'x' || result == 'X'))

		{

		ClearScreen(aClearScreenAfter);

		return 0;

		}

	else

		{

		result = result - '0';

		if (result > 0 && result <= count)

			{

			ClearScreen(aClearScreenAfter);

			return result;

			}

		else

			{

			return DoDisplayMenu(aTitle, aMaxAttempts, aAllowExit, aClearScreenBefore, aClearScreenAfter);

			}

		}

	}

EXPORT_C void CTestUtils::Printf(TRefByValue<const TDesC> aFmt,...)

	{

	// Print to the log file.

	TTestOverflow overflow(*this);

	VA_LIST list;

	VA_START(list, aFmt);

	TBuf<0x100> aBuf;

	aBuf.AppendFormatList(aFmt, list, &overflow);

	if (iLogToConsole)

		{

		iRTest.Printf(aBuf);

		}

	if (iLogToFile)

		{

		WriteComment(aBuf);

		}

	}

EXPORT_C void CTestUtils::AppendText(const TDesC& aToken, TDes& aTxt, TInt aMaxTokenLength)

	{

	TInt totalLen = aTxt.Length() + aMaxTokenLength;

	aTxt.Append(aToken);

	aTxt.TrimRight();

	if (aTxt.Length() < totalLen)

		{

		aTxt.AppendFill(' ', totalLen - aTxt.Length());

		}

	aTxt.SetLength(totalLen);

	}

EXPORT_C void CTestUtils::ClearLogL(const CLogFilter& aFilter)

	{

	CLogClient* client = CLogClient::NewL(iFs);

	CleanupStack::PushL(client);

	CLogViewEvent* eventView = CLogViewEvent::NewL(*client);

	CleanupStack::PushL(eventView);

	CTestActive* testAct = new (ELeave) CTestActive();

	CleanupStack::PushL(testAct);

	CLogClient* logCli = CLogClient::NewL(iFs);

	CleanupStack::PushL(logCli);

	TBool found = eventView->SetFilterL(aFilter, testAct->iStatus);

	if (found)

		{

		testAct->StartL();

		CActiveScheduler::Start();	

		}

	if (!CheckLogStatus(found, testAct->iStatus))

		{

		CleanupStack::PopAndDestroy(4);

		return;

		}

	found = eventView->FirstL(testAct->iStatus);

	if (found)

		{

		testAct->StartL();

		CActiveScheduler::Start();	

		}

	if (!CheckLogStatus(found, testAct->iStatus))

		{

		CleanupStack::PopAndDestroy(4);

		return;

		}

	const CLogEvent& event = eventView->Event();

	Printf(_L("Clearing System Log\n"));

	do

		{

		iRTest.Printf(_L("."));

		logCli->DeleteEvent(event.Id(), testAct->iStatus);

		testAct->StartL();

		CActiveScheduler::Start();	

		found = eventView->FirstL(testAct->iStatus);

		if (found)

			{

			testAct->StartL();

			CActiveScheduler::Start();	

			}

		found = CheckLogStatus(found, testAct->iStatus);

		}

	while (found);

	CleanupStack::PopAndDestroy(4);

	}

EXPORT_C void CTestUtils::DisplayLogL(const CLogFilter& aFilter, TBool aForward)

	{

	TBuf<256> header;

	TBuf<256> txt;

	TBuf<64> temp;

	CLogClient* client = CLogClient::NewL(iFs);

	CleanupStack::PushL(client);

	CLogViewEvent* eventView = CLogViewEvent::NewL(*client);

	CleanupStack::PushL(eventView);

	CTestActive* testAct = new (ELeave) CTestActive();

	CleanupStack::PushL(testAct);

	TBool found = eventView->SetFilterL(aFilter, testAct->iStatus);

	if (found)

		{

		testAct->StartL();

		CActiveScheduler::Start();	

		}

	if (!CheckLogStatus(found, testAct->iStatus))

		{

		CleanupStack::PopAndDestroy(3);

		return;

		}

	TInt totalCount = eventView->CountL();

	txt.Zero();

	txt.Append(_L("Total Log Events: "));

	temp.Num(totalCount);

	txt.Append(temp);

	AppendEol(txt, EFalse);

	Printf(txt);

	const TInt numLen		= 3;

	const TInt timeLen		= 11;

	const TInt dateLen		= 10;

	const TInt statusLen	= 7;

	const TInt subjLen		= 20;

	const TInt dirLen		= 3;

	const TInt typeLen		= 10;

	header.Zero();

	AppendText(_L("Num"), header, numLen);

	header.Append('|');

	AppendText(_L("Date"), header, dateLen);

	header.Append('|');

	AppendText(_L("Time"), header, timeLen);

	header.Append('|');

	AppendText(_L("Status"), header, statusLen);

	header.Append('|');

	AppendText(_L("Subject"), header, subjLen);

	header.Append('|');

	AppendText(_L("Dir"), header, dirLen);

	header.Append('|');

	AppendText(_L("Type"), header, typeLen);

	AppendEol(header, EFalse);

	Printf(header);

	found = aForward ? eventView->FirstL(testAct->iStatus) : eventView->LastL(testAct->iStatus);

	if (found)

		{

		testAct->StartL();

		CActiveScheduler::Start();	

		}

	if (!CheckLogStatus(found, testAct->iStatus))

		{

		CleanupStack::PopAndDestroy(3);

		return;

		}

	TInt counter = 0;

	do

		{

		const CLogEvent& event = eventView->Event();

		counter++;

		if (!RunAuto() && (counter % 6 == 0))

			{

			iRTest.Printf(_L("\nPress any key for more...\n"));

			iRTest.Getch();

			Printf(header);

			}

		txt.Zero();

		if (aForward)

			{

			temp.Num(totalCount - counter + 1);

			}

		else

			{