// Copyright (c) 1998-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 <e32test.h>

#include <f32fsys.h>

#include <s32file.h>

#include <e32base.h>

#include <txtetext.h>

#include <txtrich.h>

#include <bautils.h>

#include <miuthdr.h>

#include <miutmsg.h>

#include <miutset.h>  //KUidMsgTypePOP3

#include <imutdll.h>	

#include <imcvtext.h>

#include <imcvrecv.h>

#include <imcvsend.h>

#include <imapset.h>

//Oyster includes

#include <msvstd.h>

#include <msvids.h>

#include <msvuids.h>

#include <msvruids.h>

#include <msvreg.h>

#include <msventry.h> 

#include <msvapi.h>

#include <mtclbase.h>

#include <cemailaccounts.h>

#include <pop3set.h>

#include <offop.h>

#include "t_log.h"

//----------------------------------------------------------------------------------------

_LIT( KFileNameCombined, "Entry_All.txt");

_LIT( KFileNameBody, "Entry_Bodys.txt");

_LIT( KFileNameHeader, "Entry_Header.txt");

_LIT( KFileNameMimeHeader, "Entry_MimeHeader.txt");

_LIT( KFileNameSettings, "Entry_Settings.txt");

_LIT( KFileNameEntryStruct, "Entry_Zac.txt");

//----------------------------------------------------------------------------------------

_LIT(KPerCentS, "%S");

_LIT(KCRLF, "\r\n");

//----------------------------------------------------------------------------------------

// nicked from IMCM::OFFOP.CPP

LOCAL_D const TUid KUidImQueuedOperationList = {0x10001794};	// 2648441492 dec.

//----------------------------------------------------------------------------------------

// Handy conversion routines between 8 and 16bit worlds

#define Ptr8From16( aText ) TPtrC8( (const TUint8 *)(aText).Ptr(), (aText).Size() )

#define Ptr16From8( aText ) TPtrC16( (const TUint16 *)(aText).Ptr(), (aText).Size()/2 )

LOCAL_C HBufC16* HBuf16From8LC( const TDesC8& aText )

	{

	HBufC16* pOutputLine = HBufC16::NewLC( aText.Length() );

	TPtr16 pOutput = pOutputLine->Des();

	pOutput.Zero();

	TUint8 theChar;

	TInt i=0;

	while(i<aText.Length())

		{

		theChar=aText[i++];

		pOutput.Append( (TUint16)theChar );

		}

	return pOutputLine;

	}

// Note this function will lose data if fed text other than ISO-8859-1

LOCAL_C HBufC8* HBuf8From16LC( const TDesC16& aText )

	{

	HBufC8* pOutputLine = HBufC8::NewLC( aText.Length() );

	TPtr8 pOutput = pOutputLine->Des();

	pOutput.Zero();

	TUint16 theChar;

	TInt i=0;

	while(i<aText.Length())

		{

		theChar=aText[i++];

		pOutput.Append( (TUint8)theChar );

		}

	return pOutputLine;

	}

//----------------------------------------------------------------------------------------

class COutputterOverflow: public TDes16Overflow

	{

public:

	COutputterOverflow( COutputter* aPutter );

	void Overflow(TDes16& aDes);

private:

	COutputter* iPutter;

	};

//----------------------------------------------------------------------------------------

//----------------------------------------------------------------------------------------

COutputterOverflow::COutputterOverflow( COutputter* aPutter )

	{

	iPutter = aPutter;

	}

void COutputterOverflow::Overflow(TDes16 &aDes)

	{

	TRAPD(ret,iPutter->PrintL( _L("\r\n\r\n\r\n") ));

	TRAP(ret,iPutter->PrintL( _L("Overflow when outputting data")));

	TRAP(ret,iPutter->PrintL( aDes ));

	TRAP(ret,iPutter->PrintL( _L("\r\n\r\n\r\n")));

	}

//----------------------------------------------------------------------------------------

COutputter* COutputter::NewL(RTest* aTest)

	{

	COutputter* putter = new (ELeave) COutputter;

	CleanupStack::PushL(putter);

	putter->iTest = aTest;

	putter->iUseFiles = ETrue;

	putter->ConstructL();

	CleanupStack::Pop();

	return putter;

	}

void COutputter::ConstructL()

	{

	iOverflow = new(ELeave) COutputterOverflow( this );

	iPrefix.FillZ();

	}

COutputter::~COutputter()

	{

	while ( iFilesOpen > 0 )

		UnSetFile();

	delete iOverflow;

	}

void COutputter::SetRFs(RFs* aFs)

	{

	iFs = aFs;

	}

void COutputter::UnSetFile()

	{

	if ( iFilesOpen > 0 )

		iFile[--iFilesOpen].Close();

	}

void COutputter::SetFilePrefix( TUint aNum )

	{

	iPrefix.Format( _L("%08x_"), aNum);

	}

void COutputter::SetFileL( const TDesC& aLeafName, TBool aUnicode )

	{

	if ( iUseFiles )

		{

		if (iFilesOpen >= 4)

			iTest->Panic( _L("Too many open files") );

		RFile& file = iFile[iFilesOpen++];

		TFileName name = iPrefix;

		name += aLeafName;

		TInt err = file.Open( *iFs, name, EFileShareAny | EFileStreamText | EFileWrite);

		if (err == KErrNotFound) // file does not exist - create it

			err = file.Create( *iFs, name, EFileShareAny | EFileStreamText | EFileWrite);

		User::LeaveIfError(err);

		// not sure what this is for - but it was in originally

		TInt offset=0;

		(*iTest)(file.Seek(ESeekEnd, offset)==KErrNone);

		iUnicode=aUnicode;

		}

	iPrefix.FillZ();

	}

void COutputter::PrintL( const TDesC8& aText ) // should be L

 	{

	if ( iFilesOpen > 0 )

		{

		if (iUnicode)

			{

			HBufC16 *buf = HBuf16From8LC( aText );

			iFile[iFilesOpen-1].Write( Ptr8From16(*buf) );

			CleanupStack::PopAndDestroy(); // buf

			}

		else

			iFile[iFilesOpen-1].Write( aText );

		}

	else

		{

#if _UNICODE

		HBufC16 *buf = HBuf16From8LC( aText );

		PrintL( *buf );

		CleanupStack::PopAndDestroy(); // buf

#else

		TInt len = aText.Length();

		for ( TInt pos = 0; pos < len; pos += 256 )

			{

			TPtrC ptr = aText.Mid( pos, len-pos<256?len-pos:256 );

			iTest->Printf( KPerCentS, &ptr );

			}

#endif

		}

	}

void COutputter::PrintL( const TDesC16& aText ) // should be L

	{

	if ( iFilesOpen > 0 )

		{

		if (iUnicode)

			iFile[iFilesOpen-1].Write( Ptr8From16( aText ) );

		else

			{

			HBufC8 *buf = HBuf8From16LC( aText );

			iFile[iFilesOpen-1].Write( *buf );

			CleanupStack::PopAndDestroy(); // buf

			}

		}

	else

		{

#if _UNICODE

		// write data in chunks to ensure no overrun of underlying

		// Printf function

		TInt len = aText.Length();

		for ( TInt pos = 0; pos < len; pos += 256 )

			{

			TPtrC ptr = aText.Mid( pos, len-pos<256?len-pos:256 );

			iTest->Printf( KPerCentS, &ptr );

			}

#else

		HBufC8 *buf = HBuf8From16LC( aText );

		PrintL( *buf );

		CleanupStack::PopAndDestroy(); // buf

#endif

		}

	}

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

	{

	TBuf<1024> buf;

	VA_LIST list;

	VA_START( list, aFmt );

	buf.AppendFormatList( aFmt, list, iOverflow );

	VA_END( list );

	TRAP_IGNORE(PrintL( buf ));

	}

void COutputter::PrintIfNotNullL( const TDesC& aLabel, const TDesC8& aValue )

	{

	if ( aValue.Length() )

		{

		PrintL( aLabel );

		PrintL( aValue );

		PrintL( KCRLF );

		}	

	}

void COutputter::PrintIfNotNullL( const TDesC& aLabel, const TDesC16& aValue )

	{

	if ( aValue.Length() )

		{

		PrintL( aLabel );

		PrintL( aValue );

		PrintL( KCRLF );

		}	

	}

void COutputter::PrintListL( const TDesC& aLabel, CDesC8Array& aList )

	{

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

		{

		PrintL(aLabel);

		PrintL(aList[i]);

		PrintL(KCRLF);

		}

	}

void COutputter::PrintListL( const TDesC& aLabel, CDesC16Array& aList )

	{

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

		{

		PrintL(aLabel);

		PrintL(aList[i]);

		PrintL(KCRLF);

		}

	}

void COutputter::PrintDataL( const TDesC8& aData )

	{

	TInt i;

	for(i=0; i < aData.Length(); i++)

		{

		Printf(_L("%02x "), aData[i]);

		if ((i&7)==7)

			PrintL(KCRLF);

		}

	if ((i&7)!=0)

		PrintL(KCRLF);

	}

void CMsgOutputter::RemoveRichtextFormatting(TDes& aSourceLine)

	{

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

	TUint16* start = ptr;

	TInt totalLength = aSourceLine.Length();

	do {

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

			*ptr=0x0A;

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

	}

//----------------------------------------------------------------------------------------

void CMsgOutputter::BodyDataL( CMsvStore& aFileStore )

//----------------------------------------------------------------------------------------

	{

	CParaFormatLayer* paraLayer = CParaFormatLayer::NewL();

	CleanupStack::PushL(paraLayer);

	CCharFormatLayer* charLayer = CCharFormatLayer::NewL();

	CleanupStack::PushL(charLayer);

	CRichText* body = CRichText::NewL(paraLayer,charLayer);

	CleanupStack::PushL(body);

	aFileStore.RestoreBodyTextL(*body);

	HBufC* pBodyText = HBufC::NewLC(body->DocumentLength()+(body->DocumentLength()/70)+1);

	if ( iParts==EToMultipleFiles )

		iPutter->SetFileL( KFileNameBody );

	iPutter->Printf( _L("*** %08x *************** RichText Data ***************\r\n"), iMsgId);

	iPutter->Printf( _L("Size >>> %d\r\n"), body->DocumentLength());

	TPtr pBody = pBodyText->Des();

	body->Extract(pBody, 0);

	RemoveRichtextFormatting(pBody);

	iPutter->PrintL( pBody );

	iPutter->PrintL(_L("\r\n********************* end of Body ***********************\r\n"));

	CleanupStack::PopAndDestroy(4); // pBodyText, paraLayer, charLayer, body

	if ( iParts==EToMultipleFiles )

		iPutter->UnSetFile();

	}

//----------------------------------------------------------------------------------------

void CMsgOutputter::MimeHeaderL( CMsvStore& aFileStore )

//----------------------------------------------------------------------------------------

	{

	if ( iParts==EToMultipleFiles )

		iPutter->SetFileL( KFileNameMimeHeader );

	iPutter->Printf(_L("*** %08x ************* Mime Header ******************\r\n"), iMsgId);

	CImMimeHeader* mimeHeader = CImMimeHeader::NewLC();

	mimeHeader->RestoreL(aFileStore);

	iPutter->Printf(_L("Version: %d\r\n"),mimeHeader->Version());

	iPutter->PrintIfNotNullL( _L("Content-Type: "), mimeHeader->ContentType() );

	iPutter->PrintIfNotNullL( _L("Content-Type,SubType: "), mimeHeader->ContentSubType() );

	iPutter->PrintIfNotNullL( _L("Content-Disposition: "), mimeHeader->ContentDisposition() );

	iPutter->PrintIfNotNullL( _L("Content-Description: "), mimeHeader->ContentDescription() );

	iPutter->PrintIfNotNullL( _L("Content-Base: "), mimeHeader->ContentBase() );

	iPutter->PrintIfNotNullL( _L("Content-ID: "), mimeHeader->ContentID() );

	iPutter->PrintIfNotNullL( _L("Content-Location: "), mimeHeader->ContentLocation() );

	if ( mimeHeader->ContentTransferEncoding() )

		iPutter->Printf( _L("Content-Transfer-Encoding: %d\r\n"), mimeHeader->ContentTransferEncoding() );

	iPutter->PrintListL( _L("ContentTypeParams: "), mimeHeader->ContentTypeParams() );

	iPutter->PrintListL( _L("ContentDispositionParams: "), mimeHeader->ContentDispositionParams() );

	iPutter->PrintL(_L("******************** end of MIME Header ****************\r\n"));

	if ( iParts==EToMultipleFiles )

		iPutter->UnSetFile();

	CleanupStack::PopAndDestroy(); // mimeHeader

	}

//----------------------------------------------------------------------------------------

void CMsgOutputter::HeaderL( CMsvStore& aFileStore )

//----------------------------------------------------------------------------------------

	{

	if ( iParts==EToMultipleFiles )

		iPutter->SetFileL( KFileNameHeader );

	iPutter->Printf( _L("*** %08x ************* Rfc822 Header ****************\r\n"), iMsgId);

	CImHeader* header = CImHeader::NewLC();

	TUint emptySize = header->DataSize();

	header->RestoreL(aFileStore);

	TUint size = header->DataSize()-emptySize;

	iPutter->Printf(_L("Size >>> %d\r\n"), size);

	iPutter->PrintIfNotNullL(_L("Subject: "), header->Subject());

	iPutter->PrintIfNotNullL(_L("ID: "), header->ImMsgId());

	iPutter->PrintIfNotNullL(_L("From: "), header->From());

	iPutter->PrintIfNotNullL(_L("Reply-To: "), header->ReplyTo());

	iPutter->PrintIfNotNullL(_L("Return-Receipt-To: "), header->ReceiptAddress());

	iPutter->PrintListL(_L("To: "), header->ToRecipients());

	iPutter->PrintListL(_L("Cc: "), header->CcRecipients());

	iPutter->PrintListL(_L("Bcc: "), header->BccRecipients());

	iPutter->PrintL(_L("******************** end of RFC822 header **************\r\n"));

	if ( iParts==EToMultipleFiles )

		iPutter->UnSetFile();

	CleanupStack::PopAndDestroy(); // header

	}

TPtrC CMsgOutputter::SyncTypeString( TFolderSyncType aType )

	{

	switch (aType)

		{

	case EUseCombination:

		return _L("UseCombination");

	case EUseLocal:

		return _L("UseLocal");

	case EUseRemote:

		return _L("UseRemote");

		}

	return _L("");

	}

TPtrC CMsgOutputter::SubscribeTypeString( TFolderSubscribeType aType )

	{

	switch (aType)

		{

	case EUpdateNeither:

		return _L("UpdateNeither");

	case EUpdateLocal:

		return _L("UpdateLocal");

	case EUpdateRemote:

		return _L("UpdateRemote");

	case EUpdateBoth:

		return _L("UpdateBoth");

		}

	return _L("");

	}

TPtrC CMsgOutputter::GetMailOptionsString( TImap4GetMailOptions aOpts )

	{

	switch (aOpts)

		{

	case EGetImap4EmailHeaders:

		return _L("GetImap4EmailHeaders");

	case EGetImap4EmailBodyText:

		return _L("GetImap4EmailBodyText");

	case EGetImap4EmailBodyTextAndAttachments:

		return _L("GetImap4EmailBodyTextAndAttachments");

	case EGetImap4EmailAttachments:

		return _L("GetImap4EmailAttachments");

		}

	return _L("");

	}

//----------------------------------------------------------------------------------------

void CMsgOutputter::Imap4SettingsL(const TMsvEntry& aEntry)

//----------------------------------------------------------------------------------------

	{

	if ( iParts==EToMultipleFiles )

		iPutter->SetFileL( KFileNameSettings );

	iPutter->Printf(_L("*** %08x ************* Settings ****************\r\n"), iMsgId);

	CImImap4Settings* settings = new (ELeave)CImImap4Settings();

	CleanupStack::PushL(settings);

	CEmailAccounts* accounts = CEmailAccounts::NewLC();

	TImapAccount imapAccountId;

	accounts->GetImapAccountL(aEntry.Id(), imapAccountId);

	accounts->LoadImapSettingsL(imapAccountId, *settings);

	CleanupStack::PopAndDestroy(accounts);

	iPutter->Printf(         _L("IAP index:                     %u\r\n"), iEntry->Entry().MtmData1());

	iPutter->PrintIfNotNullL( _L("LoginName:                     "), settings->LoginName());

	iPutter->PrintIfNotNullL( _L("Password:                      "), settings->Password());

	iPutter->PrintIfNotNullL( _L("FolderPath:                    "), settings->FolderPath());

	iPutter->Printf(         _L("PathSeparator:                 %c\r\n"), settings->PathSeparator());