// 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 <e32base.h>

#include <e32math.h>

#include <txtrich.h>

#include <bautils.h>

#include <miut_err.h>

#include "IMUTDLL.H"

#include "IMCVSEND.H"

#include <miuthdr.h>

#include <miutpars.h>

#include <imcm.rsg>	

#include <barsread.h>	// TResourceReader

#include <cmsvattachment.h> 

#include <mmsvattachmentmanager.h>

#include <cmsvplainbodytext.h>		

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "miut_errconsts.h"

#include "timrfc822datefield.h"

#include "cimconvertheader.h"

#endif

#define SENDLOG(x)				\

	if (iLogFileExists)			\

		iLogFile.Write(x);	

#define SENDLOG2(x,y)			\

	if (iLogFileExists)			\

		{						\

		iLogFile.Write(x);		\

		iLogFile.Write(y);		\

		}

_LIT(KLogFilePath, "c:\\logs\\mailtext\\");

_LIT(KLogFileName, "out.txt");

_LIT8(KNewLogHeader, "\r\n------ New Send Session ------\r\n");

_LIT8(KSent, "Sent : ");

_LIT8(KSetBody, "Body length = %d\r\n");

const TInt KArrayGranularity = 3;

const TInt KChunkSize = 1024;

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

//              Class CImSendMessage Functions

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

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

EXPORT_C CImSendMessage* CImSendMessage::NewLC(CMsvServerEntry& aServerEntry)

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

	{

	CImSendMessage* self = new (ELeave) CImSendMessage(aServerEntry);

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

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

EXPORT_C CImSendMessage* CImSendMessage::NewL(CMsvServerEntry& aServerEntry)

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

	{

	CImSendMessage* self = CImSendMessage::NewLC(aServerEntry);

	CleanupStack::Pop( );

	return self;

	}

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

CImSendMessage::CImSendMessage(CMsvServerEntry& aServerEntry) : iServerEntry(aServerEntry)

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

	{	

	}

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

void CImSendMessage::ConstructL()

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

	{

	// logfile stuff

	TInt ret=0;

	TParse logFileName;

	logFileName.Set(KLogFileName, &KLogFilePath, NULL);

	TFileName filename(logFileName.FullName());

	ret=iLogFile.Replace(iServerEntry.FileSession(), filename, EFileShareExclusive|EFileWrite );

	iLogFileExists = (ret==KErrNone);

	SENDLOG( KNewLogHeader )

	}

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

EXPORT_C void CImSendMessage::InitialiseL(TMsvId aMessageId, TImSendMethod aSendMethod, 

					const TTime aTimeDate, const TDesC& aDomainName, 

					TUint aCharset, const TImSMTPSendCopyToSelf aCopyToSelf)

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

	{

	TImEmailTransformingInfo info;

	info.SetToDefault(aSendMethod); // Sets defaults

	info.SetHeaderAndBodyCharset(aCharset) ; // Sets charset for header/body

	InitialiseL(aMessageId, aTimeDate, aDomainName, info, aCopyToSelf);

	}

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

EXPORT_C void CImSendMessage::InitialiseL(TMsvId aMessageId, const TTime aTimeDate,

							const TDesC& aDomainName,	const TImEmailTransformingInfo& aInfo,

							const TImSMTPSendCopyToSelf aCopyToSelf)

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

	{

	User::LeaveIfError(iServerEntry.SetEntry(aMessageId));

	__ASSERT_ALWAYS(iServerEntry.Entry().iType==KUidMsvMessageEntry, gPanic(KPanicEntryIsNotMessage));

	SetSendMethodL(aInfo.SendMethod());

	iSendEmail->InitialiseL(aTimeDate, aDomainName, aCopyToSelf, aInfo);

	Reset();

	}

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

EXPORT_C void CImSendMessage::Reset()

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

	{

	iSendEmail->Reset();

	}

// Creates the required email sending object, either Mime or non MIME.

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

void CImSendMessage::SetSendMethodL(TImSendMethod aSendMethod)

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

	{

	switch (aSendMethod)

		{

		case ESendAsSimpleEmail:

			iSendEmail = CImSendPlainEmail::NewL(iServerEntry);

			break;

		case ESendAsMimeEmail:

			iSendEmail = CImSendMimeEmail::NewL(iServerEntry);

			break;

		default:

			gPanic(KPanicUnknownSendingMethod);

		}

	}

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

EXPORT_C TInt CImSendMessage::NextLineL( TDes8& rOutputLine, TInt& rPaddingCount  )

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

	{

	// Format the next line of output into rOutputLine.

	// If the output line contains more characters than the size of the source data cosumed 

	// in preparing it, then the difference is passed back in aPaddingCount.

	TInt localPaddingCount=0;

	rOutputLine.Zero();

	TInt ret = iSendEmail->NextLineL( rOutputLine, localPaddingCount );

	AddCRLFAtEndOfLine(rOutputLine, localPaddingCount);

	SENDLOG(KSent);

	SENDLOG(rOutputLine);

	rPaddingCount = localPaddingCount;

	return ret;

	}

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

EXPORT_C CImSendMessage::~CImSendMessage( )

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

	{

	if (iLogFileExists)

		iLogFile.Close();

	delete iSendEmail;

	}

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

EXPORT_C TInt CImSendMessage::HeaderSize()

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

	{

	TInt size = iSendEmail->HeaderSize();

	iSendEmail->Reset();

	return size;

	}

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

EXPORT_C TInt CImSendMessage::BodySizeL()

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

	{

	return iSendEmail->BodySizeL();

	}

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

//              Class CImSendEmail Functions

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

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

CImSendEmail::CImSendEmail(CMsvServerEntry& aServerEntry) : 

							iServerEntry(aServerEntry), iDomainName(TPtrC())

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

	{

	}

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

CImSendEmail::~CImSendEmail( )

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

	{

	delete iCharConv;

	delete iCharacterConverter;

	delete iHeaderConverter;

	delete iSendFile;

	delete iEmailTraverser;

	delete iRfc822Header;

	delete iSendRichText;

	}

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

void CImSendEmail::ConstructL()

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

	{

	iCharacterConverter = CCnvCharacterSetConverter::NewL();

	iCharConv = CImConvertCharconv::NewL(*iCharacterConverter, iServerEntry.FileSession());

	iSendFile =	CImSendFile::NewL(iServerEntry.FileSession(), *iCharConv);

	iEmailTraverser = CImEmailTraverser::NewL(iServerEntry);

	iHeaderConverter = CImConvertHeader::NewL(*iCharConv);

	iRfc822Header = CImSendRfc822Header::NewL(iServerEntry.FileSession(), *iHeaderConverter);

	iSendRichText = CImSendRichText::NewL(*iCharConv);

	}

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

void CImSendEmail::InitialiseL( const TTime aTimeDate, const TDesC& aDomainName,

							   const TImSMTPSendCopyToSelf aCopyToSelf,

							   const TImEmailTransformingInfo& aTransformingInfo)

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

	{

	// get a list of all attachments

	iDomainName.Set(aDomainName);

	iDefaultTransformingInfo=aTransformingInfo;

	iTimeDate=aTimeDate;

	iRfc822Header->InitialiseL(iTimeDate,	iDomainName, iServerEntry, 

					iServerEntry.Entry().Priority(), aCopyToSelf, iDefaultTransformingInfo);

	iEmailTraverser->InitialiseL( iServerEntry.Entry().Id() );

	}

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

TBool CImSendEmail::InitBodyObjectL(TMsvEntry& rEntry)

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

	{

	return ( rEntry.iType==KUidMsvEmailTextEntry

		  && iSendRichText->InitialiseL( iServerEntry, 

							Encoder(EEncodingTypeNone), EEncodingTypeNone,

							iRfc822Header->TransformingInfo().BodyTextCharset()) );

	}

// calculates & returns the total size of the header info, including the RFC822 tags, 

// comma & space separation, the CRLFs and the blank line after the header itself

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

TInt CImSendEmail::HeaderSize()

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

	{

	return iRfc822Header->Size();

	}

// Sum of body parts and file attachments.

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

TInt CImSendEmail::BodySizeL()

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

	{

	TMsvEntry entry;

	TInt size=0;

	TBool isEndOfEmail=EFalse;

	entry = iEmailTraverser->ThisEntry();

	do {

		if (InitBodyObjectL(entry))

			size += iSendRichText->Size();

		else if (InitAttachmentObjectL(entry))

			size += iSendFile->Size();

		if ( iEmailTraverser->DownLevelL() )

			entry = iEmailTraverser->ThisEntry();

		else

			while ( !iEmailTraverser->NextEntryL(entry) )

				{

				if ( !iEmailTraverser->UpLevelL() || iEmailTraverser->IsBaseLevel() )

					{

					// end of traversal, reached message entry.

					isEndOfEmail=ETrue;

					break;

					}

				}

	} while (!isEndOfEmail);

	return size;

	}

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

void CImSendEmail::Reset()

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

	{

	if(iRfc822Header)

		{		

		iRfc822Header->Reset();

		}

	iState = 0;

	}

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

TImFileCodec&  CImSendEmail::Encoder(TImEncodingType aType)

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

	{

	switch (aType)

		{

	case EEncodingTypeUU: 

		iUUEncoder.Initialise();

		return iUUEncoder;

	case EEncodingTypeBASE64: 

		iB64Encoder.Initialise();

		return iB64Encoder;

	case EEncodingTypeQP: 

		return iQPEncoder;

	case EEncodingTypeNone:

		return iNULLEncoder;

	default:

		__ASSERT_DEBUG( ETrue, gPanic(KPanicInvalidEncodingType) );

		return iNULLEncoder;

		}

	}

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

TBool CImSendEmail::InitAttachmentObjectL(TMsvEntry& rEntry)

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

	{

	if ( !(rEntry.iType==KUidMsvAttachmentEntry || rEntry.iType==KUidMsvEmailHtmlEntry) )

		return EFalse;

	iSendFile->InitialiseL(iServerEntry, Encoder(iRfc822Header->TransformingInfo().AttachmentEncoding())); 

	return ETrue;

	}

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

//              Class CImEmailTraverser Functions

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

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

CImEmailTraverser* CImEmailTraverser::NewL( CMsvServerEntry& aServerEntry)

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

	{

	CImEmailTraverser* self = new (ELeave) CImEmailTraverser( aServerEntry );

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( );

	return self;

	}

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

CImEmailTraverser::CImEmailTraverser( CMsvServerEntry& aServerEntry ) : 

				iServerEntry(aServerEntry), iCurrentEntryList(KArrayGranularity)

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

	{

	iBaseId = iServerEntry.Entry().Id();

	}

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

void CImEmailTraverser::ConstructL()

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

	{

	iSelectionList = new (ELeave) CArrayFixFlat<CMsvEntrySelection*>(KArrayGranularity);

	}

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

CImEmailTraverser::~CImEmailTraverser()

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

	{

	Reset();

	delete iSelectionList;

	}

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

void CImEmailTraverser::Reset()

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

	{

	while (DeleteCurrentList())

		;

	}

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

void CImEmailTraverser::InitialiseL( TMsvId aId)

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

	{

	iBaseId = aId;

	User::LeaveIfError(iServerEntry.SetEntry(iBaseId));

	Reset();

	}

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

TBool CImEmailTraverser::DownLevelL()

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

	{

	TMsvSelectionOrdering ordering(KMsvNoGrouping,EMsvSortById,ETrue);

	iServerEntry.SetSort(ordering);

	CMsvEntrySelection*	children = new(ELeave) CMsvEntrySelection;

	CleanupStack::PushL(children);

	User::LeaveIfError(iServerEntry.GetChildren(*children));

	if (children->Count())

		{

		AddList(*children);

		CleanupStack::Pop(children);

		User::LeaveIfError(iServerEntry.SetEntry( CurrentList()[0]));

		return ETrue;

		}

	CleanupStack::PopAndDestroy(children);

	return EFalse;

	}

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

TBool CImEmailTraverser::UpLevelL()

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

	{

	if (!DeleteCurrentList())

		return EFalse;

	if (!LevelExists())

		User::LeaveIfError( iServerEntry.SetEntry(iBaseId) );

	else

		User::LeaveIfError( iServerEntry.SetEntry( CurrentList()[CurrentEntry()]) );

	return ETrue;

	}

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

TBool CImEmailTraverser::NextEntryL(TMsvEntry& rEntry)

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

	{	

	if (IsBaseLevel())

		return EFalse;

	iCurrentEntryList[0] += 1;

	if ( CurrentEntry()>=CurrentList().Count() )

		return EFalse; // last entry on this level.

	if (!LevelExists())

		User::LeaveIfError( iServerEntry.SetEntry(iBaseId) );

	else

		User::LeaveIfError( iServerEntry.SetEntry( CurrentList()[CurrentEntry()]) );

	rEntry = ThisEntry();

	return ETrue;

	}

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

//              Class CImSendPlainEmail Functions

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

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

CImSendPlainEmail* CImSendPlainEmail::NewLC(CMsvServerEntry& aServerEntry)

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

	{

	CImSendPlainEmail* self = new (ELeave) CImSendPlainEmail(aServerEntry);

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

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

CImSendPlainEmail* CImSendPlainEmail::NewL(CMsvServerEntry& aServerEntry)

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

	{

	CImSendPlainEmail* self = CImSendPlainEmail::NewLC(aServerEntry);

	CleanupStack::Pop( );

	return self;

	}

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

CImSendPlainEmail::CImSendPlainEmail(CMsvServerEntry& aServerEntry) : CImSendEmail(aServerEntry)

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

	{

	}

// Sending header followed by body and attachment parts, in the order in which they are

// arranged in the TMsventry structure.

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

TInt CImSendPlainEmail::NextLineL( TDes8& rOutputLine, TInt& rPaddingCount )

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

	{