// 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 <imcm.rsg>

#include <barsread.h>

#include "imcvcodc.h"

#include "imcvutil.h"

#include "CMsvBodyText.h"

#include "ImCltCvRecv.h"

#ifdef __WINS__

#include <e32wins.h> 

#include <msvapi.h>

#endif

#ifndef __WINS__

#include <msvapi.h>

#endif

#include <cmsvattachment.h> 

#include <mmsvattachmentmanager.h>

#include <mmsvattachmentmanagersync.h>

#ifndef _MSG_NO_LOGGING

#define __IMUT_LOGGING

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

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

_LIT8(KFound, "found: ");

_LIT8(KPartLine, "unknown or part line");

_LIT8(KEndOFHeader, "End of header");

_LIT8(KSkippingData, "Skipping data");

_LIT8(KFoundMIMEBoundary, "MIME boundary");

_LIT8(KRemoveBoundary, "Remove boundary");

_LIT8(KRemovedBoundary, "Removed boundary");

_LIT8(KSectionHeader, "Section header");

_LIT8(KWritingToFile, "writing attachment");

_LIT8(KWroteToFile, "wrote attachment");

_LIT8(KFailedToWriteToFile, "Failed to write to attachment file");

_LIT8(KFoundUUEStartBoundary, "UUE start boundary");

_LIT8(KFoundUUEEndBoundary, "UUE end boundary");

_LIT8(KReset, "Resetting CImRecvConvert");

_LIT8(KReseted, "Resetting CImRecvConvert");

_LIT8(KLastToken, "That was the last token");

_LIT8(KResetForNewEntry, "Reset for a New Entry");

_LIT8(KResetedForNewEntry, "Reseted for a New Entry");

_LIT8(KCreatingEntry, "Creating Entry");

_LIT8(KCreatedEntry, "Created Entry");

_LIT8(KUpdatingEntry, "Updating Entry");

_LIT8(KUpdatedEntry, "Updated Entry");

_LIT8(KMoveToParentEntry, "Moved to parent entry");

_LIT8(KMovedToParentEntry, "End of Moved to parent entry");

_LIT8(KIgnoringStreams, "Discarding streams");

_LIT8(KStartMessageComplete, "Start Message Complete");

_LIT8(KMessageComplete, "Message Complete");

_LIT8(KHeaderComplete, "Message Header complete");

_LIT8(KReturnReceiptTo, "return-receipt-To is set");

_LIT8(KStartStoringEntryStream, "Starting Storing Entry Stream");

_LIT8(KStoringEntryStream, "Storing Entry Stream");

_LIT8(KDoneStoringEntryStream, "Done Storing Entry Stream");

#endif // _MSG_NO_LOGGING

// uncomment the line below if logging is to be enabled

#if defined(__IMUT_LOGGING)

#define RECVLOG(text) (iImcvLog?iImcvLog->AppendComment(text):void(0));

#define RECVLOG_OUT(text) (iImcvLog?iImcvLog->AppendOut(text):void(0));

#define LOGGING(string1, string2) (Logging(string1, string2));

#else

#define RECVLOG(text) (void(0));

#define RECVLOG_OUT(text) (void(0));

#define LOGGING(string1, string2) (void(0));

#endif

const TInt KBodyTextChunkSizeBytes = 512;

/*EXPORT_C*/ CImCltRecvConvert* CImCltRecvConvert::NewLC(RFs& anFs,CMsvEntry* aClientEntry,TUid aMsgType,TMsvId aEmailServiceId)

	{

	CImCltRecvConvert* self = new (ELeave) CImCltRecvConvert(anFs,aClientEntry,aMsgType,aEmailServiceId);

	CleanupStack::PushL(self);

	self->ConstructL(anFs);

	return self;

	}

/*EXPORT_C*/ CImCltRecvConvert* CImCltRecvConvert::NewL(RFs& anFs,CMsvEntry* aClientEntry,TUid aMsgType,TMsvId aEmailServiceId)

	{

	CImCltRecvConvert* self = CImCltRecvConvert::NewLC(anFs,aClientEntry,aMsgType,aEmailServiceId);

	CleanupStack::Pop();

	return self;

	}

void CImCltRecvConvert::ConstructL(RFs& anFs)

	{

	iFsSession = &anFs;  

	RResourceFile resFile;

	OpenResourceFileL(resFile, anFs);	// NB leaves if file not found

	// make sure the resource file will be closed if anything goes wrong

	// CloseResourceFile is declared in IMUTDLL.H and defined in IMUTDLL.CPP

	TCleanupItem close( CloseResourceFile, &resFile );

	CleanupStack::PushL( close );

	// Read iStore8BitData flag.

	HBufC8* buf = resFile.AllocReadLC(STORE_8BIT_BODY_TEXT);

	TResourceReader reader;

	reader.SetBuffer(buf);

	iStore8BitData = reader.ReadInt8();

	CleanupStack::PopAndDestroy(buf);

	buf = resFile.AllocReadLC(REMOVED_ATTACHMENT_TAG);

	reader.SetBuffer(buf);

	iRemovedAttachmentTag = reader.ReadTPtrC().AllocL();

	CleanupStack::PopAndDestroy(buf);

	buf = resFile.AllocReadLC(DEFAULT_ATTACHMENT_NAME);

	reader.SetBuffer(buf);

	iDefaultAttachmentName = reader.ReadTPtrC().AllocL();

	CleanupStack::PopAndDestroy(buf);

	buf = resFile.AllocReadLC(PARTIAL_DOWNLOAD_FOOTER_MESSAGE);

	reader.SetBuffer(buf);

	iPartialEmailFooter = (reader.ReadTPtrC()).AllocL();

	CleanupStack::PopAndDestroy(buf);

	buf = NULL;

	CleanupStack::PopAndDestroy(&resFile);

	// create CImHeader object to store Rfc822 header info...

	iOutputHeader = CImHeader::NewLC();

	CleanupStack::Pop();			   

	if (iStore8BitData)

		{

		//Create body text storage helper.

		iBodyText = CMsvBodyText::NewL();

		}

	else

		{

		// create CRichText object to store body...

		iParaLayer = CParaFormatLayer::NewL();

		iCharLayer = CCharFormatLayer::NewL();

		iOutputBody = CRichText::NewL(iParaLayer, iCharLayer);

		}

	// Create Rfc822 filter object...

	iRfc822Token = CLocalRfc822Token::NewLC();

	CleanupStack::Pop();				 

	iRfc822Token->SetImRecvConvert(this);

	// Create converter objects...

	iCharacterConverter = CCnvCharacterSetConverter::NewL();

	iCharConv = CImConvertCharconv::NewL(*iCharacterConverter, anFs);

	iHeaderConverter = CImConvertHeader::NewL(*iCharConv); 

	// Create MIME filter object...

	iMimeParser = CLocalMimeParser::NewL(*this);

	// logfile stuff

	iImcvLog=NULL;

#ifdef __IMUT_LOGGING	

	TRAP_IGNORE(iImcvLog=CImLog::NewL(KLogFilePath, EAppend));

#endif

	iRootEntryId = EntryId();

	iNotFinishedRfc822Header = ETrue;

	iEmailEntry = new (ELeave) TMsvEmailEntry;

	iReceivingHeadersOnly=EFalse;	

	iParent = new (ELeave) CArrayFixFlat<TParentDetails>(3);

	iFirstBoundaryReached=EFalse;

	ResetL();

	RECVLOG( KNewLogHeader )

	}

CImCltRecvConvert::CImCltRecvConvert(RFs& anFs,CMsvEntry* aClientEntry,TUid aMsgType,TMsvId aEmailServiceId)

	: CLocalImRecvConvert(anFs,iNullServerEntry,aMsgType,aEmailServiceId),

	  iClientEntry(aClientEntry)

	{

	__DECLARE_NAME(_S("CImCltRecvConvert"));

	}

/*EXPORT_C*/ CImCltRecvConvert::~CImCltRecvConvert()

	{

	}

/*EXPORT_C*/ void CImCltRecvConvert::ResetForHeadersL()

	{

	// This function is used in preference to ResetL() when the owner

	// only wishes to create  email entries in the remote mailbox - 

	// they do not wish to create any stores associated with the message

	// entry

	ResetL();

	iReceivingHeadersOnly=ETrue;

	}

/*EXPORT_C*/ void CImCltRecvConvert::ResetL()

	{

	RECVLOG(KReset) 

	iBodyId=KMsvNullIndexEntryId;

	iSizeOfAttachmentsRemoved=0;

	iClientEntry->SetEntryL(iRootEntryId);

	iReceivingHeadersOnly=EFalse;

	iMessageEntryCalled=EFalse;

	iLeaveError=KErrNone; 		

	iCurrentMultipartFolderEntryId=0;

	TParentDetails parent;

	parent.iAttachment=parent.iMHTML=EFalse;

	parent.iSize=0;

	iParent->InsertL(0,parent);

	if(iEmailEntry)

		{

		delete iEmailEntry;

		iEmailEntry=NULL;

		}

	iEmailEntry = new (ELeave) TMsvEmailEntry;

	// "iSavingAttachments" commands this code to store attachments in files.

	// Currently this is always set to ETrue as we intend to save all attachments

	// However, if the user wishes to discard (ie do not save) any 

	// attachments in incoming email messages - then this member variable

	// may be set to EFalse by the inline accessor function "SaveAllAttachments(TBool)"

	iSavingAttachments=ETrue;

	iAttachmentFileState=EFileIsClosed;

	// iLeaveError contains the error value of any functions that leaves (ie CRichText::InsertL)

	// or any returned error value that generates a leave from within CImRecvConvert (ie RFile::Create)

	iGlobalIndent=0;

	iLongestLine=50;

	iImPriority=EMsvMediumPriority;

	delete iImcvUtils;

	iImcvUtils=NULL;

	iImcvUtils=CImcvUtils::NewL();

	// reset internal date

	iTimeDate.HomeTime();

	iMimeParser->Reset();

	iNewEntry=EFalse; //EFalse if the entry was moved to. ETrue if the entry was just created

	iTopMessagePart=KMsvRootIndexEntryId;

	ResetForNewEntryL(iDefaultEntryType);

	iMIMEPart_822Header = EFalse;

	iPartialEmail=EFalse;

	RECVLOG(KReseted) 

	}

/*EXPORT_C*/ TInt CImCltRecvConvert::ParseNextFieldL(const TDesC8& aSourceLine) 

	{

	__ASSERT_DEBUG(iRootEntryId!=KMsvRootIndexEntryId, gPanic(KPanicServiceIdNotValid));

	RECVLOG_OUT(aSourceLine);

	if ((iLeaveError == KErrNone) && (iClientEntry->Entry().Id() == KMsvRootIndexEntryId))

		{

		iClientEntry->SetEntryL(iSavedEntryId);

		}

	if(iLeaveError==KErrNone)

		{

		TRAP(iLeaveError, ParseNextLineL(aSourceLine));		

		}

	if (iLeaveError==KErrNone)

		iSavedEntryId = iClientEntry->Entry().Id();

	TUid type = iClientEntry->Entry().iType;

	if( type != KUidMsvMessageEntry    &&

		type != KUidMsvEmailTextEntry  &&

		type != KUidMsvEmailHtmlEntry  &&

		type != KUidMsvAttachmentEntry)

		{

		iClientEntry->SetEntryL(KMsvRootIndexEntryId);

		}

	return iLeaveError;

	}

void CImCltRecvConvert::ParseNextLineL(const TDesC8& aSourceLine)

	{

	iParsedMimeBoundaryLast=0;

	if(!iFinishedHeader)

		{

		// start by getting the next token from the header

		iRfc822Token->ParseNextLineL(aSourceLine);

		switch(iRfc822Token->iHeaderPart)

			{

			case CLocalRfc822Token::EUnknown:

			case CLocalRfc822Token::ENotFinished:

				RECVLOG(KPartLine)

				break;

			case CLocalRfc822Token::EFrom:

				iOutputHeader->SetFromL(*iRfc822Token->OutputLine());

				LOGGING(KFound,KImcvFromPrompt);

				break;

			case CLocalRfc822Token::EReplyTo:

				iOutputHeader->SetReplyToL(*iRfc822Token->OutputLine());

				LOGGING(KFound,KImcvReplyToPrompt);

				break;

			case CLocalRfc822Token::ETo:

				ParseRecipientListL(iOutputHeader->ToRecipients());

				LOGGING(KFound,KImcvToPrompt);

				break;

			case CLocalRfc822Token::ECc: 

				ParseRecipientListL(iOutputHeader->CcRecipients());

				LOGGING(KFound,KImcvCcPrompt);

				break;

			case CLocalRfc822Token::EBcc: 

				ParseRecipientListL(iOutputHeader->BccRecipients());

				LOGGING(KFound,KImcvBccPrompt);

				break;

			case CLocalRfc822Token::ESubject:

				iOutputHeader->SetSubjectL(*iRfc822Token->OutputLine());

				LOGGING(KFound,KImcvSubjectPrompt);

				break;

			case CLocalRfc822Token::EDate:

				iRfc822Date.ParseDateField(*iRfc822Token->OutputLine() , iTimeDate); 

				if (iEmailEntry->Id() != iTopMessagePart)

					{

					iEmailEntry->iDate = iTimeDate;

					}

				LOGGING(KFound,KImcvDatePrompt);

				break;

			case CLocalRfc822Token::EMessageId:

				iOutputHeader->SetImMsgIdL(*iRfc822Token->OutputLine());

				LOGGING(KFound,KImcvMessageIdPrompt);

				break;

			case CLocalRfc822Token::EPriority:

				iImPriority=iImcvUtils->EvaluatePriorityText(*iRfc822Token->OutputLine());

				LOGGING(KFound,KImcvPriorityPrompt);

				break;

			case CLocalRfc822Token::EReturnReceiptTo:

				iOutputHeader->SetReceiptAddressL(*iRfc822Token->OutputLine());

				LOGGING(KFound,KReturnReceiptTo);

				break;

			case CLocalRfc822Token::EEndOfHeader:

				// the next line goes in the body part

				iFinishedHeader = ETrue;

				RECVLOG(KEndOFHeader)

				break;

			default:

				RECVLOG(KEndOFHeader)

				break;

			}

		if(iRfc822Token->iHeaderPart != CLocalRfc822Token::ENotFinished)

			{

			// Now that we've used the data, we also need to clear the output line from the tokeniser....

			iRfc822Token->OutputLine()->Des() = KNullDesC8;

			// whatever part we just read, we may also have read the empty line that separates

			// the header from the body

			if((iFinishedHeader = iRfc822Token->LastToken()) != EFalse)	//iFinishedHeader set to 1 on CRLF-

				{

				RECVLOG(KLastToken);

				iNotFinishedRfc822Header = EFalse;

				iHeaderConverter->SetMessageType(iMimeParser->MessageIsMime());

				iHeaderConverter->DecodeAllHeaderFieldsL(*iOutputHeader);

				if (iMimeParser->MessageIsMime())

					{

					EndOfHeaderMIMEProcessingL();

					}

				else

					{

					EndOfHeaderProcessingL();

					}

				if (iStore8BitData)

					{

					iBodyText->SetDefaultCharacterSet(iCharConv->SystemDefaultCharset());

					if ( iMimeParser->MessageIsMime() && iMimeParser->ContentType()==EMimeText )

						{

						iBodyText->SetCharacterSet(iMimeParser->CurrentCharsetL());

						}

					else

						{

						iBodyText->SetCharacterSet(0);

						}

					}

				else

					{

					// Get charset for decoding.

					if ( iMimeParser->MessageIsMime() && iMimeParser->ContentType()==EMimeText )

						{

						iCharConv->PrepareToConvertToFromOurCharsetL(iMimeParser->CurrentCharsetL());

						}

					else

						{

						iCharConv->PrepareToConvertToFromOurCharsetL(iCharConv->SystemDefaultCharset());

						}

					}

				}

			}

		}

	else if (iReceivingHeadersOnly==EFalse)

		{	

		//Set to EFalse when a single line is to be skipped (ie boundary line)

		iCommitLine=ETrue; 

		// read one line of the message body if I am processing a whole email message

		if(iMimeParser->MessageIsMime())

			{

			ParseMimeLineL(aSourceLine);

			}

		else

			{

			ParseBodyLineL(aSourceLine);	

			}

		if((iCommitLine)&&(!iSkipData))

			{

			DecodeAndStoreLineL(aSourceLine);

			}	

		}

	}

/*EXPORT_C*/ TMsvEmailEntry CImCltRecvConvert::MessageEntryDetailsL()

	{

	iMessageEntryCalled=ETrue;

	CloseAttachmentFileL();

	// A message requiring manual termination and not part way through a MIME part header

	if( iTopMessagePart==EntryId() && iFinishedHeader) 

		{

		StoreEntryStreamsL(KStore822Header|KStoreMIMEHeader);

		}

	else

		{

		iClientEntry->SetEntryL(iTopMessagePart);         

		if(iEmailEntry)

			{

			delete iEmailEntry;

			iEmailEntry=NULL;

			}

		iEmailEntry = new (ELeave) TMsvEmailEntry(iClientEntry->Entry());

		}

	return *iEmailEntry;

	}

/*EXPORT_C*/ void CImCltRecvConvert::MessageCompleteL(TMsvEmailEntry aEmailEntry)

	{

	if (iClientEntry->Entry().Id() == KMsvRootIndexEntryId)

		{

		iClientEntry->SetEntryL(iSavedEntryId);

		}

	__ASSERT_DEBUG(iMessageEntryCalled, gPanic(KPanicMessageEntryNotCalled));

	__ASSERT_DEBUG(aEmailEntry.Id()==iTopMessagePart, gPanic(KPanicMessageEntryIdHasChanged));

	// Called ResetL() to reset object instead of ResetForHeadersL()

	__ASSERT_DEBUG(iReceivingHeadersOnly, gPanic(KPanicIncorrectResetState)); 

	if(iEmailEntry)

		{

		if (iEmailEntry->Id())

			{

			if(iLeaveError==KErrNone)

				{

				// a remote email header cannot have any attachments or be marked as complete...

				aEmailEntry.SetAttachment(EFalse);

				aEmailEntry.SetMHTMLEmail(EFalse);

				aEmailEntry.SetComplete(EFalse);

				iClientEntry->SetEntryL(aEmailEntry.Id());

				RECVLOG(KHeaderComplete)

				}

			else

				{

				if (!iPopulateMessage)

					{

					TMsvId currentId = EntryId();

					iClientEntry->SetEntryL(iClientEntry->Entry().Parent());			

					iClientEntry->DeleteL(currentId);

					}

				User::Leave(iLeaveError);

				}

			}

		}

	iSavedEntryId = iClientEntry->Entry().Id();

	iClientEntry->SetEntryL(KMsvRootIndexEntryId);

	}

/*EXPORT_C*/ TMsvId CImCltRecvConvert::MessageCompleteL()

	{