// Copyright (c) 2006-2010 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:

// cimapopfetchbody.cpp

//

#include <imapset.h>

#include <mentact.h>

#include "cimapopfetchbody.h"

#include "cimapbodystructure.h"

#include "cimapenvelope.h"

#include "cimapfetchresponse.h"

#include "cfetchbodyinfo.h"

#include "cimapfetchbodyresponse.h"

#include "cimaprfc822headerfields.h"

#include "cimapmimeheaderfields.h"

#include "cimapsession.h"

#include "cimapsettings.h"

#include "cimapmailstore.h"

#include "cimaputils.h"

#include "cimaplogger.h"

#include <imcvtext.h>

#include <imcvcodc.h>

#include <imcvutil.h>

#include <cimcaf.h>

#include "cimapsyncmanager.h"

#include "cimapfolder.h"

#include <charconv.h>

#include <miuthdr.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS  

#include "timrfc822datefield.h"

#include "cimconvertheader.h"

#endif

_LIT8(KIMAP_NIL, "NIL");

// MIME message types

_LIT8(KMIME_TEXT, "TEXT");

_LIT8(KMIME_HTML, "HTML");

_LIT8(KMIME_XVCARD, "X-VCARD");

_LIT8(KMIME_VCALENDAR, "X-VCALENDAR");

_LIT8(KMIME_ICALENDAR, "CALENDAR");

_LIT8(KMIME_RTF, "RTF");

_LIT8(KMIME_NAME, "NAME");

_LIT8(KMIME_NAME_RFC2231, "NAME*");

_LIT8(KMIME_ATTACHMENT, "ATTACHMENT");

_LIT8(KMIME_FILENAME, "FILENAME");

_LIT8(KMIME_FILENAME_RFC2231, "FILENAME*");

// Encoding types

_LIT8(KMIME_BASE64, "BASE64");

_LIT8(KIMAP_REL_PATH_SEPARATOR, ".");

// Header fields to fetch when fetching the body structure.

_LIT8(KImapFetchLargeHeaderFields, "From Subject Reply-to To Cc Bcc Message-ID Return-Receipt-To X-Return-Receipt-To Disposition-Notification-To Disposition-Notification-Options");

// No longer fetch the following fields

// Received - date set on sync

// Date     - date set on sync

// Subject  - fetched during sync - copy from TMsvEmailEntry into CImHeader

// From		- fetched during sync - copy from TMsvEmailEntry into CImHeader

// Positive completion errors for FindFilenameL()

const TInt KErrRFC2231Encoded = 2;

// Efficient and SAFE way of comparing TBools which might have different integers representing TRUE

inline TBool BoolsAreEqual( TBool aA, TBool aB )

	{

	return ((aA && aB) || (!aA && !aB));

	}

inline TBool BoolsAreNotEqual( TBool aA, TBool aB )

	{

	return ((!aA || !aB) && (aA || aB));

	}

CImapOpFetchBody::CImapOpFetchBody( CImapSession*& aSession,

									CImapSyncManager& aSyncManager, 

					  				CMsvServerEntry& aServerEntry,

					  				CImapSettings& aImapSettings, 

					  				CImapMailStore& aMailStore)

: CImapOperation(aSession, aServerEntry, EPriorityStandard),

  iSyncManager(aSyncManager),

  iImapSettings(aImapSettings), iMailStore(aMailStore)

   	{

	}

CImapOpFetchBody::~CImapOpFetchBody()

	{

	Cancel();

	// Fetch Response objects

	delete iFetchResponse;

	delete iFetchBodyResponse;

	iFetchList.ResetAndDestroy();

	// CAF support

	delete iCaf;

	// Characterset conversion

	delete iHeaderConverter;

	delete iCharConv;

	delete iCharacterConverter;

	}

/**

Static construction for CImapOpFetchBody class.

@param aSession      connected IMAP Session object to use.

@param aServerEntry  access to the message entry array.

@param aImapSettings access to the settings for the IMAP Service.

@return the newly created CImapOpFetchBody object. The caller is responsible for

deletion.

*/

CImapOpFetchBody* CImapOpFetchBody::NewL(CImapSession*& aSession,CImapSyncManager& aSyncManager, CMsvServerEntry& aServerEntry, CImapSettings& aImapSettings, CImapMailStore& aMailStore)

	{

	CImapOpFetchBody* self = new (ELeave) CImapOpFetchBody(aSession, aSyncManager, aServerEntry, aImapSettings, aMailStore);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CImapOpFetchBody::ConstructL()

	{

	// Caf utils

	iCaf = new (ELeave) CImCaf(CImapUtils::GetRef().Fs());

	// Create converter objects

	iCharacterConverter=CCnvCharacterSetConverter::NewL();

	iCharConv=CImConvertCharconv::NewL(*iCharacterConverter, CImapUtils::GetRef().Fs());

	iHeaderConverter=CImConvertHeader::NewL(*iCharConv); 

	// we assume that this message is MIME as we have no way of

	// detecting otherwise (without sending a new FETCH to the

	// server to get the MIME-Version).

	iHeaderConverter->SetMessageType(ETrue);

	CActiveScheduler::Add(this);

	}

/**

Fetches the specified bodypart and all parts that exist below it that match

the specified fetch criteria. Thus if called with the root of a message as

the specified part, then all message parts that satisfy the criteria will

be fetched, up to the entire message contents.

@param aStatus request status of the Proctocol Controller

@param aPart the ID in the local message store of the message part to fetch.

@param aGetPartialMailInfo: partial fetch settings.

*/

void CImapOpFetchBody::FetchBodyL(TRequestStatus& aRequestStatus, const TMsvId aPart, const TImImap4GetPartialMailInfo& aGetPartialMailInfo)

	{

	__LOG_TEXT(iSession->LogId(), "CImapOpFetchBody::FetchBodyL(): fetching message");

	iRequestedPart=aPart;

	iGetPartialMailInfo=aGetPartialMailInfo;

	Queue(aRequestStatus);

	// sets the next state and sets active

	DoFetchL();

	}

/**

Initialises the fetch of the requested body parts.

If there is nothing to fetch (ie the client has requested a fetch of headers 

only, which are fetched during synchronise) the user request is completed.

Otherwise, if the body structure representation for the message already exists

in the message store, the tree structure is parsed to identify parts to fetch.

Otherwise, a request is issued for the required message headers and bodystructure.

*/

void CImapOpFetchBody::DoFetchL()

	{

 	// Reset stats

 	iBytesToDo=0;

 	iBytesDone=0;

 	iFetchList.ResetAndDestroy();

	iHtmlEntryPart = 0;

	iBodyTextSize = 0;

	iHtmlEntrySize = 0;

	iBodyPartRemainingSize = 0;

	iSizeOfToBeFetchedAttachments=0;

	iHasTextParts = 0;

	CheckForPartialPopulate();

	// if we only want headers then there is nothing to do as they

	// have already been fetched on synchronisation. We complete here.

	if(!iFetchPartialMail && iGetPartialMailInfo.iGetMailBodyParts == EGetImap4EmailHeaders)

		{

		__LOG_TEXT(iSession->LogId(), "CImapOpFetchBody:DoFetchL(): Nothing to fetch, completing");

		Complete(KErrNone);

		return;

		}

	// Get info on what is being fetching

	SetEntryL(iRequestedPart);

	// Find the root entry for the message this part belongs to.

	// No need to check the selected folder is correct - the 

	// compound operation checks this.

  	TBool messageFound = EFalse;

  	while(!messageFound)

		{

		// Reached the message ?

		if (iServerEntry.Entry().iType==KUidMsvMessageEntry)

			{

			messageFound = ETrue;

			TMsvEmailEntry entry = iServerEntry.Entry();

			iMessageUid  = entry.UID();

			iMessageMsvId  = entry.Id();

			// indicate that a fetch operation has been performed on this message.

			// This is used to prevent subsequent fetches during 2-phase sync.

			// ((TMsvEmailEntry&)iServerEntry.Entry()).

			entry.SetValidUID(ETrue);

			User::LeaveIfError(iServerEntry.ChangeEntry(entry));

  			if (!(iServerEntry.Entry().Owner()))

  				{

				// If there are no child entries then we need to fetch 

				// the envelope and body structure

  				FetchLargeHeaderL();

  				}

  			else

  				{

  				// If the structure is already present then build up an array of

  				// parts to be fetched from the data in the message server entry

  				// array and associated mime parts. Do this in the RunL

  				iCurrentStep=iNextStep=EBuildFetchList;

  				// complete self

  				SetActive();

				TRequestStatus* status = &iStatus;

				User::RequestComplete(status, KErrNone);

  				}

   			}

		// Up a level

		SetEntryL(iServerEntry.Entry().Parent());

		} // end while(!messageFound)

	}

/**

Checks if the partial mail download parameters are set to default 

and the full download mail option is set, then this is a request for full download.

Allows for efficiency when identifying message parts to fetch.

*/

void CImapOpFetchBody::CheckForPartialPopulate()

	{

	if(iGetPartialMailInfo.iPartialMailOptions == ENoSizeLimits &&

		iGetPartialMailInfo.iTotalSizeLimit == KMaxTInt &&

		iGetPartialMailInfo.iBodyTextSizeLimit == KMaxTInt && 

		iGetPartialMailInfo.iAttachmentSizeLimit == KMaxTInt && 

		(iGetPartialMailInfo.iGetMailBodyParts == EGetImap4EmailHeaders || 

		iGetPartialMailInfo.iGetMailBodyParts == EGetImap4EmailBodyText ||

		iGetPartialMailInfo.iGetMailBodyParts == EGetImap4EmailBodyTextAndAttachments ||

		iGetPartialMailInfo.iGetMailBodyParts == EGetImap4EmailAttachments ||

		iGetPartialMailInfo.iGetMailBodyParts == EGetImap4EmailBodyAlternativeText))

		{

		__LOG_TEXT(iSession->LogId(), "CImapOpFetchBody: Doing non-partial fetch");

		iFetchPartialMail = EFalse;

		}

	else

		{

		__LOG_TEXT(iSession->LogId(), "CImapOpFetchBody: Doing partial fetch");

		iFetchPartialMail = ETrue;

		}

	}

/**

Issues a request to IMAP Session to fetch the IMAP Header details and bodystructure.

*/

void CImapOpFetchBody::FetchLargeHeaderL()

 	{

  	// Issue the fetch request to the imap session

  	delete iFetchResponse;

  	iFetchResponse = NULL;

  	iFetchResponse = CImapFetchResponse::NewL();

  	iCurrentStep = EGetBodyStructure;

  	iNextStep = EProcessBodyStructure;

  	iSession->FetchBodyStructureAndHeadersL(iStatus, iMessageUid, KImapFetchLargeHeaderFields, *iFetchResponse);

  	SetActive();

   	}

/**

Called when asynchronous service requests complete.

Handles errors returned by aSynchronous services. 

Implements the state handling for message fetching.

*/

void CImapOpFetchBody::DoRunL()

	{

	// Handle any server errors

	if (iStatus.Int()!=KErrNone)

		{

		if (TInt err=ProcessServerError() != KErrNone)

			{

			Complete(err);

			return;

			}

		}

	iCurrentStep = iNextStep;

	switch (iCurrentStep)

		{

	case EProcessBodyStructure:

		{

		if (ProcessBodyStructureL())

			{

			iNextStep = EFetchFirstPart;

			// complete self

  			SetActive();

			TRequestStatus* status = &iStatus;

			User::RequestComplete(status, KErrNone);

			}

		else

			{

			// No body structure. Message has probably been deleted from server but local

			// copy has not yet been removed.

			Complete(KErrNone);

			return;

			}

		break;

		}

	case EBuildFetchList:

		{

		DoBuildFetchListL();

		iCurrentStep = EFetchFirstPart;

		// falls through to fetch the first item in the fetch array.

		}

	case EFetchFirstPart:

		{

		// initialise progress counters:

		iPartsToDo=iFetchList.Count();

		iPartsDone=0;

 		if (FetchPartL())

 			{

 			//DBG((LogText(_L8("Starting body fetch of %d parts (%d bytes)"),

	 		iNextStep = EFetchNext;

 			}

 		else

 			{

 			// No parts identified for fetch - complete the user request.

 			Complete(KErrNone);

 			return;

 			}

	 	break;

		}

	case EFetchNext:

		{

		FetchPartCompleteL();

 		// Issue fetch for the next part in the array

		if (FetchPartL())

 			{

	 		iNextStep = EFetchNext;

 			}

 		else

 			{

 			// No more parts to fetch - complete the user request.

 			iCurrentStep=EFinished;

 			Complete(KErrNone);

 			return;

 			}

 		break;

		}

	default:

		{

		User::Leave(KErrNotSupported);

		}

		}

	if (!IsActive())

		{

		SetActive();

		}

	}

/**

Special form of Cancel(), which enables message currently being fetched to be resumed.

*/

void CImapOpFetchBody::CancelEnableResume()

	{

	Cancel();

	TRAP_IGNORE(ClearFetchAttemptedL());

	}

/** 

Clears the fetch-attempted flag (re-use of ValidUID flag) to indicate that the

cancelled fetch may be resumed according to download rules.

*/

void CImapOpFetchBody::ClearFetchAttemptedL()

	{

	SetEntryL(iMessageMsvId);

	TMsvEmailEntry entry = iServerEntry.Entry();

	entry.SetValidUID(EFalse);

	User::LeaveIfError(iServerEntry.ChangeEntry(entry));

	}

/**

Called by Cancel() to cancel asynchronous service requests

*/

void CImapOpFetchBody::DoCancel()

	{

	switch (iCurrentStep)

		{

	// States involving a session request

	case EGetBodyStructure:

	case EFetchFirstPart:

	case EFetchNext:

		{

		iSession->Cancel();

		break;

		}

	// Self completing or synchronous states	

	case EProcessBodyStructure:

	case EBuildFetchList:

	default:

		{

		break;

		}

		} // end of switch (iCurrentStep)

	CMsgActive::DoCancel();

	}

/**

Called when a user request is completed.

*/

#ifdef __IMAP_LOGGING

void CImapOpFetchBody::DoComplete(TInt& aErr)

#else

void CImapOpFetchBody::DoComplete(TInt& /*aErr*/)

#endif //__IMAP_LOGGING

	{

	__LOG_FORMAT((iSession->LogId(), "CImapOpFetchBody::DoComplete(aErr = %d) CurrentStep = %d", aErr, iCurrentStep));

	}

/**

Builds a list of parts to fetch from the server entry array.

This method is used when the mailstore representation of the bodystructure 

for the message has previously been constructed.

*/

void CImapOpFetchBody::DoBuildFetchListL()

	{

 	SetEntryL(iRequestedPart);

 	TMsvEmailEntry temp = (TMsvEmailEntry)iServerEntry.Entry();

 	TUid type=temp.iType;

 	// if we are not asking for a Message type then override the get

	// options to ensure that this is fetched

 	if(!iFetchPartialMail)

		{

		if (type != KUidMsvMessageEntry)

 			iGetPartialMailInfo.iGetMailBodyParts = EGetImap4EmailBodyTextAndAttachments;

		}

 	// Build a list of parts to fetch: 

 	BuildFetchListL(iRequestedPart);

	UpdateBodyTextRemainingSizeForHtml();

	}

/**

Add the message part identified by aMessage and aMimeHeader to the array of 

parts to fetch.

Creates a CFetchBodyInfo object for each part to be fetched. This is the data

that the session requires to fetch each message part.

Note that this function should only be called when the part has been correctly

identified as a part for fetching.

@param aMessage     the TMsvEmailEntry for the part.

@param aMimeHeader  the mime header for the part.

@param aIsText	    bool indicating whether this is a text part.

@param aSizeToFetch	amount of data to fetch - this may indicate a partial fetch

                    if less than the total size of the part.

*/

void CImapOpFetchBody::AddFetchItemL(CImMimeHeader& aMimeHeader, TMsvEmailEntry& aMessage, TBool aIsText, TInt32 aSizeToFetch)

	{

	CFetchBodyInfo* fetchInfo=CFetchBodyInfo::NewLC(aMessage.Id());

	fetchInfo->SetSizeToFetch(aSizeToFetch);

	fetchInfo->SetBodyPartRemainingSize(aMessage.iBioType - aSizeToFetch);

	fetchInfo->SetRelativePathL(aMimeHeader.RelativePath()); 

	fetchInfo->SetIsText(aIsText);

	fetchInfo->SetContentTransferEncoding(aMimeHeader.ContentTransferEncoding());

	fetchInfo->iEmbed = iEmbed;

	if (aIsText)

		{

		fetchInfo->SetCharsetId(aMimeHeader.MimeCharset());

		}

	else if (aMimeHeader.ContentType().MatchF(KImcvApplication) == 0)

		{

		// Set the CAF pointer if the attachment is an application.

		// This is not registered at this stage, this is done just

		// prior to issuing the fetch request. This allows a single

		// CImCaf instance to be re-used.

		fetchInfo->SetCaf(iCaf);

		}

	iFetchList.AppendL(fetchInfo);

	CleanupStack::Pop(fetchInfo);

	// Add this part's size to the size total

	iBytesToDo+=aMessage.iBioType;

	}

/**

Determines if an item is to be fetched, depending on the parttypes specified.

Items are also rejected if they have been marked complete due to having 0 

length. An attachment info object is created for attachment items rejected 

this way.