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

//

#include "commands.h"

#include <biodb.h>

#include <bitsids.h>

#include <biouids.h>

#include <miutset.h>

#include <pop3set.h>

#include <imapset.h>

#include <smtpset.h>

#include <smutset.h>

#include <mtmdef.h>

#include <regpsdll.h>

#include <cmsvattachment.h>

#include <mmsvattachmentmanager.h>

#include <cemailaccounts.h>

#ifdef SYMBIAN_BOOKMARK_DATABASE

#include <bookmarkdatabase.h>

#include <bookmark.h>

_LIT(KTxtBookmarkExtension, ".ebm");

#endif // SYMBIAN_BOOKMARK_DATABASE

#include <commsdat.h>

#include <utf.h>

#include <cdblen.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS 

#include "tmsvbioinfo.h"

#endif

//

// CDoCmdGeneral

// Handles the running of the genral commands

//

// For ECmdGeneralComment

CDoCmdGeneral* CDoCmdGeneral::NewL(CClientTestHarness& aTestHarness, const CDesCArrayFlat& aComment, TCmdGeneral aCmd)

{

	CDoCmdGeneral* self = NULL;

	switch(aCmd)

	{

		case(ECmdGeneralComment):

		{

			self = new (ELeave) CDoCmdGeneral(aTestHarness, ECmdGeneralComment);

			CleanupStack::PushL(self);

			self->ConstructL(aComment);

			CleanupStack::Pop(self);

		}

		break;

		case(ECmdGeneralCheckUsedBif):

		{

			self = new (ELeave) CDoCmdGeneral(aTestHarness, ECmdGeneralCheckUsedBif);

			CleanupStack::PushL(self);

			self->ConstructL(aComment);

			CleanupStack::Pop(self);

		}

		break;

		case(ECmdGeneralCheckFileWithExtExists):

		{

			self = new (ELeave) CDoCmdGeneral(aTestHarness, ECmdGeneralCheckFileWithExtExists);

		}

		break;

		case(ECmdGeneralPrettifyLog):

		{

			self = new (ELeave) CDoCmdGeneral(aTestHarness, ECmdGeneralPrettifyLog);

		}

		break;

		case(ECmdGeneralDumpMsg):

		{

			self = new (ELeave) CDoCmdGeneral(aTestHarness, ECmdGeneralDumpMsg);

		}

		break;

		case(ECmdGeneralGenerateFromFile):

		{

			self = new (ELeave) CDoCmdGeneral(aTestHarness, ECmdGeneralGenerateFromFile);

			CleanupStack::PushL(self);

			self->ConstructL(aComment);

			CleanupStack::Pop(self);

		}

		break;

		default:

			User::Leave(KErrNotFound);

	}

	return self;

}

//

// For ECmdGeneralComment

void CDoCmdGeneral::ConstructL(const CDesCArrayFlat& aComment)

{

	switch(iCmd)

	{

		case(ECmdGeneralComment):

		{

			TInt commentSize = 0;

			for(TInt i = 0; i < aComment.Count(); i++)

				commentSize += ((aComment[i]).Length() + _L(" ").Size());

			iComment = HBufC::NewL(commentSize);

			TPtr commentPtr = iComment->Des();

			for(TInt j = 0; j < aComment.Count(); j++)

			{

				commentPtr.Append((aComment)[j]);

				commentPtr.Append(_L(" "));

			}

		}

		break;

		case(ECmdGeneralGenerateFromFile):

		case(ECmdGeneralCheckUsedBif):

		{

			TBuf<KMaxFileName> mFilename;

			mFilename = aComment[0];

			iComment=mFilename.AllocL();

		}

		break;

		default:

			break;

	}

}

//

// For ECmdGenerateFromSection

CDoCmdGeneral* CDoCmdGeneral::NewL(CClientTestHarness& aTestHarness, const HBufC*& aBuffer, const TBIOMessageType& aMsgType, TCmdGeneral aCmd)

{

	CDoCmdGeneral* self = new (ELeave) CDoCmdGeneral(aTestHarness, aCmd);

	CleanupStack::PushL(self);

	self->ConstructL(aBuffer, aMsgType);

	CleanupStack::Pop(self);

	return self;

}

void CDoCmdGeneral::ConstructL(const HBufC*& aBuffer, const TBIOMessageType& aMsgType)

{

	//

	// Must make local copy of buffer;

	iBuffer = HBufC::NewMaxL(aBuffer->Length());

	*iBuffer = *aBuffer;

	iMsgType = aMsgType;

}

//

// For others

CDoCmdGeneral* CDoCmdGeneral::NewL(CClientTestHarness& aTestHarness, TCmdGeneral aCmd)

{

	CDoCmdGeneral* self = new (ELeave) CDoCmdGeneral(aTestHarness, aCmd);

	return self;

}

void CDoCmdGeneral::StartL(TRequestStatus& aStatus)

{

	switch(iCmd)

	{

		case ECmdGeneralPrettifyLog:

			PrettifyLogL();

			break;

		case ECmdGeneralDumpMsg:

			DumpCurrentMessageL();

			break;

		case ECmdGeneralClean:

			{

			iTestHarness.TestUtils().CleanMessageFolderL();

			}

			break;

		case ECmdGeneralComment:

		{

			//

			// Now we have to add the debugging line number which we only know at run time...

			TBuf<7> commentString;

			commentString.Format(_L("[%4d] "), iDebugInfo.LineNumber());

			//

			// Create a pointer to the HBufC, realloc size and then insert new data...

			iComment = iComment->ReAllocL(iComment->Size() + commentString.Size());

			TPtr commentPtr = iComment->Des();

			commentPtr.Insert(0, commentString);

			iTestHarness.TestUtils().WriteComment(*iComment);

			break;

		}

		case ECmdGeneralGenerateFromFile:

			{

			GenerateBIOMessageFromFileL(*iComment);

			}

			break;

		case ECmdGeneralGenerateFromSection:

			GenerateBIOMessageFromSectionL();

			break;

		case ECmdGeneralCheckUsedBif:

			CheckBifFileUsedL(*iComment);

			break;

		case ECmdGeneralCheckFileWithExtExists:

			CheckDataFileCreatedL();

			break;

		case ECmdGeneralCleanAllBioMsgs:

			CleanAllBioMsgsL();

			break;

		default:

			User::Leave(KErrNotFound);

	}

	//

	// We leave on error, so always say KErrNone

	TRequestStatus* req = &aStatus;

	User::RequestComplete(req, KErrNone);

}

CDoCmdGeneral::~CDoCmdGeneral()

{

	delete iBuffer;

	delete iComment;

}

void CDoCmdGeneral::PrettifyLogL()

{

	TParse loglocation;

	TFileName logfile;

	User::LeaveIfError(iTestHarness.TestUtils().ResolveLogFile(KNullDesC, loglocation));

	logfile.Copy(loglocation.FullName());

	logfile.Delete(logfile.Length()-1,1);

	iTestHarness.TestUtils().DoAppendVariantName(logfile);

	RFile Lfile;

	Lfile.Open(g_rfs,logfile,EFileRead|EFileShareAny);

	_LIT(KHTMLExtn,".html");

	logfile.Append(KHTMLExtn);

	RFile Hfile;

	User::LeaveIfError(Hfile.Replace(g_rfs,logfile,EFileWrite|EFileShareAny));

	_LIT8(KHTMLHeader,"<HTML><HEAD><TITLE>TBIO_T Test Logfile</TITLE></HEAD><BODY><PRE>\n\r");

	_LIT8(KHTMLFooter,"</PRE></BODY>");

	_LIT8(KHTMLRedLineStart,"<FONT COLOR=red>");

	_LIT8(KHTMLGreenLineStart,"<FONT COLOR=green>");

	_LIT8(KHTMLBlackLineStart,"<FONT COLOR=c0c0c0>");

	_LIT8(KHTMLBlueLineStart,"<FONT COLOR=blue>");

	_LIT8(KHTMLLineEnd,"</FONT><br>");

	Hfile.Write(KHTMLHeader);

	TBuf8<258> mReadBuf; //258 = KMaxLogLineLength + '\n\r'

	TInt p=0;

	Lfile.Read(mReadBuf);

	while(mReadBuf.Length()>0)

	{

		TInt eol = mReadBuf.Locate('\n');

		p+=eol+1;  //skip the \r

		Lfile.Seek(ESeekStart,p);

		if (eol>0)

		{

			mReadBuf.SetLength(eol); //skip the \n

			_LIT8(KDesOK,"ok");

			_LIT8(KDesError,"error");

			_LIT8(KDesFailed,"failed");

			_LIT8(KDesWarning,"warning");

			TBuf8<20> linestart;

			linestart = KHTMLBlackLineStart;		

			if (mReadBuf.FindF(KDesOK())>0)

			{

				linestart=KHTMLGreenLineStart;

			}

			else if (mReadBuf.FindF(KDesError())>0)

			{

				linestart=KHTMLRedLineStart;

			}

			else if (mReadBuf.FindF(KDesFailed())>0)

			{

				linestart=KHTMLRedLineStart;

			}

			else if (mReadBuf.FindF(KDesWarning())>0)

			{

				linestart=KHTMLBlueLineStart;

			}

			Hfile.Write(linestart);

			Hfile.Write(mReadBuf);

			Hfile.Write(KHTMLLineEnd);

		}

		Lfile.Read(mReadBuf);

	}

	Hfile.Write(KHTMLFooter);

	Hfile.Close();

	Lfile.Close();

}

void CDoCmdGeneral::CheckBifFileUsedL(TDesC& aExpectedName)

{

	// Checks that the Message Type Uid is correct

	// NB - this will change to check the BIF Name when the

	// base source code has been updated to support it.

	iTestHarness.InstantiateClientMtmL();

	const TMsvId& mMsg = iTestHarness.CurrentBioMsg();

	iTestHarness.TestUtils().iMsvEntry->SetEntryL(mMsg);

	TMsvEntry tm = iTestHarness.TestUtils().iMsvEntry->Entry();

	TInt mBioMsgInt = tm.iBioType;

	TUid mBioMsgUID = TUid::Uid(mBioMsgInt);

	TBuf<32> description;

	TUid mMessageTypeUid;

	TInt index;

	CBIODatabase* bioDB = CBIODatabase::NewLC(g_rfs);

	bioDB->GetBioIndexWithMsgIDL(mBioMsgUID, index);

	description.Copy(bioDB->BifReader(index).Description());

	mMessageTypeUid=bioDB->BifReader(index).MessageTypeUid();

	CleanupStack::PopAndDestroy();	// bioDB

	TBuf<32> mUidHexString;

	_LIT(KHexFormatString,"%x");

	mUidHexString.Format(KHexFormatString,mMessageTypeUid);

	if (mUidHexString.CompareF(aExpectedName)!=0)

	{

		_LIT(KTmp,"ERROR - checking BIF MessageTypeUID - expected \"%S\" read \"%S\"");

		HBufC* td = HBufC::NewLC(KTmp().Length()+105);

		td->Des().Format(KTmp,&aExpectedName,&mUidHexString);

		iTestHarness.TestUtils().WriteComment(*td);

		CleanupStack::PopAndDestroy(td);

		User::Leave(KErrGeneral); //Test framework requires us to leave if test fails

	}

	else

	{

		_LIT(KOK,"OK Checked BIF FileTypeUid - correct");

		iTestHarness.TestUtils().WriteComment(KOK);

	}

}

#ifdef SYMBIAN_BOOKMARK_DATABASE

void CDoCmdGeneral::CheckBookmarksDbL() const

	{

	iTestHarness.TestUtils().WriteComment(_L("-- BookmarkDb Details --"));

	RBkDatabase bookmarkDb;

	bookmarkDb.OpenL();

	CleanupClosePushL(bookmarkDb);

	RBkFolder rootFolder = bookmarkDb.OpenRootL();

	CleanupClosePushL(rootFolder);

	RBkNode bookmarkItem;

	TBool foundBookmark = EFalse;

	const TInt bookmarkCount = rootFolder.Count();

	for( TInt ii=0; ii<bookmarkCount; ++ii )

		{

		bookmarkItem = rootFolder.OpenItemL(ii);

		CleanupClosePushL(bookmarkItem);

		if( bookmarkItem.Type() == Bookmark::ETypeBookmark )

			{

			foundBookmark = ETrue;

			Bookmark::TItemId bookmarkId = bookmarkItem.Id();

			CleanupStack::PopAndDestroy(&bookmarkItem);

			// bookmark found, display bookmark infomation

			RBkBookmark bookmark = bookmarkDb.OpenBookmarkL(bookmarkId);

			CleanupClosePushL(bookmark);

			TBuf<Bookmark::KMaxUriLength> uri;

			uri.Copy(bookmark.Uri());

			iTestHarness.TestUtils().WriteComment(bookmark.Title());

			iTestHarness.TestUtils().WriteComment(uri);

			CleanupStack::PopAndDestroy(&bookmark);

			iTestHarness.TestUtils().WriteComment(_L("-----"));

			}

		else

			{

			CleanupStack::PopAndDestroy(&bookmarkItem);

			}

		}

	CleanupStack::PopAndDestroy(2, &bookmarkDb);	// rootFolder, bookmarkDb

	if( !foundBookmark )

		{

		_LIT(KError,"ERROR - No bookmarks found in root folder of BookmarkDb.");

		iTestHarness.TestUtils().WriteComment(KError);

		User::Leave(KErrNotFound);

		}

	}

#endif // SYMBIAN_BOOKMARK_DATABASE

void CDoCmdGeneral::CheckDataFileCreatedL()

{

	iTestHarness.InstantiateClientMtmL();

	const TMsvId& messageId = iTestHarness.CurrentBioMsg();

	iTestHarness.TestUtils().iMsvEntry->SetEntryL(messageId);

	TInt index;

	TMsvEntry tm = iTestHarness.TestUtils().iMsvEntry->Entry();

	TInt mBioMsgInt = tm.iBioType;

	TUid mBioMsgUID = TUid::Uid(mBioMsgInt);

	CBIODatabase* bioDB = CBIODatabase::NewLC(g_rfs);

	bioDB->GetBioIndexWithMsgIDL(mBioMsgUID, index);

	TBuf<KMaxFileName> mExtn = bioDB->BifReader(index).FileExtension();

	// The following section is necessary as semi-supported iacp functions

	// (e.g. WWWHotlist) just create a file, but the bif file doesn't have

	// a file extension field set.  DPS

	_LIT(KNullString,"");

	if (mExtn==KNullString)

	{

		_LIT(KNullExtensionWarning,"Warning: file extension read from BIF file is NULL!");

		iTestHarness.TestUtils().WriteComment(KNullExtensionWarning);

		_LIT(KWWWHotlistExtn,".eBM");

		if (bioDB->BifReader(index).MessageTypeUid().iUid==KUidBIOInternetAccessPointMsg)

		{

			mExtn = KWWWHotlistExtn;

			_LIT(KNullFixupWarning,"Warning: As MessageTypeUid indicates IACP msg, guessed .eBM");

			iTestHarness.TestUtils().WriteComment(KNullFixupWarning);

		}

		// The same if ture for WAPP bookmarks. See comment above.

		else if (bioDB->BifReader(index).MessageTypeUid().iUid == KUidBIOWAPAccessPointMsg)

		{

			mExtn = KWWWHotlistExtn;

			_LIT(KNullFixupWarning,"Warning: As MessageTypeUid indicates WAPP msg, guessed .eBM");

			iTestHarness.TestUtils().WriteComment(KNullFixupWarning);

		}

	}

	CleanupStack::PopAndDestroy(bioDB);

	// a <message id>.ebm attachment should exist

	CMsvStore* store = iTestHarness.TestUtils().iMsvEntry->ReadStoreL();

	CleanupStack::PushL(store);

	MMsvAttachmentManager& manager = store->AttachmentManagerL();

	TBool found = EFalse;

	TBuf<KMaxFileName> ebmFilename;

	ebmFilename.Format(_L("%x%S"), messageId,&mExtn);

	for( TInt ii=0; ii<manager.AttachmentCount(); ++ii )

		{

		CMsvAttachment* attachment = manager.GetAttachmentInfoL(ii);

		if( attachment->AttachmentName().CompareF(ebmFilename) == 0 )

			{

			found = ETrue;

			}

		delete attachment;

		if( found )

			{

			break;

			}

		}

	CleanupStack::PopAndDestroy(store);

	TBuf<KMaxFileName+40> mOut;

	if( found )

		{

		_LIT(KOK,"OK File Exists (%S)");

		mOut.Format(KOK, &ebmFilename);

		iTestHarness.TestUtils().WriteComment(mOut);

#ifdef SYMBIAN_BOOKMARK_DATABASE

		// File is found, ensure that bookmarks exists is database if it

		// is a bookmark file

		if( mExtn.CompareF(KTxtBookmarkExtension) == 0 )

			{

			CheckBookmarksDbL();

			}

#endif // SYMBIAN_BOOKMARK_DATABASE		

		}

	else

		{

		_LIT(KError,"ERROR: File [%S] not found!");

		mOut.Format(KError, &ebmFilename);

		iTestHarness.TestUtils().WriteComment(mOut);

		User::Leave(KErrNotFound);

		}

}

void CDoCmdGeneral::DumpCurrentMessageL()

{

	_LIT(KAboutToDump,"Dump of Parsed Fields:");

	iTestHarness.TestUtils().WriteComment(KAboutToDump);

	iTestHarness.InstantiateClientMtmL();

	const TMsvId& messageId = iTestHarness.CurrentBioMsg();

	iTestHarness.TestUtils().iMsvEntry->SetEntryL(messageId);