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

//

#include "cimapfolder.h"

#include "cimapsyncmanager.h"

#include "cimapsession.h"

#include "cimaprfc822headerfields.h"

#include "cimapbodystructure.h"

#include "cimapfolderinfo.h"

#include "cimapfolderindex.h"

#include "cimaplogger.h"

#include <numberconversion.h>

#include <imcvcodc.h>

#include <miutconv.h>

#include "cimapmimeheaderfields.h"

#include "cimapcharconv.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS  

#include "cimconvertheader.h"

#include "cimconvertcharconv.h"

#endif

// For first stage download (to view in folder list)

_LIT8(KImapFetchHeaderToEnd, "%d:*");

_LIT8(KImapFetchHeaderRange,"%d:%d");

_LIT8(KImapFetchHeaderUIDRange,"UID %d:%d");

_LIT8(KImapFetchHeaderRangeSearch,"%d:%d %S");

_LIT8(KImapSmallHeaderFields,"Received Date Subject From Priority X-MSMail-Priority X-Priority Importance");

//_LIT8(KImapLargeHeaderFields,"Received Date Subject From Reply-to To Cc Bcc Message-ID Priority %S");

_LIT(KQuoteChar, "\\");

_LIT(KIMAP_INBOX, "INBOX");

_LIT8(KImapTxtImage, "IMAGE");

_LIT8(KImapTxtAudio, "AUDIO");

_LIT8(KImapTxtVideo, "VIDEO");

_LIT8(KImapTxtApplication, "APPLICATION");

_LIT8(KImapTxtRelated, "RELATED");

_LIT8(KImapTxtAlternative, "ALTERNATIVE");

_LIT8(KImapTxtMixed, "MIXED");

_LIT8(KImapTxtHtml, "HTML");

_LIT8(KImapTxtAttachment, "ATTACHMENT");

_LIT8(KImapTxtCalendar, "CALENDAR");

_LIT8(KImapTxtXVCalendar, "X-VCALENDAR");

_LIT8(KImapTxtDeliveryStatus, "DELIVERY-STATUS");

_LIT8(KImapTxtBase64, "BASE64");

// IMAP Priority fields

//_LIT8(KImapPriorityFieldsSearch, "Priority Priority X-MSMail-Priority Precedence Importance");

// Constants

const TInt KImapUidSearchSize = 400;

const TInt KImapMaxIntChars = 11; // the maximum number of characters needed to represent a 32-bit unsigned integer as a string.

// 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));

	}

/**

Constructor

*/

CImapFolder::CImapFolder(CImapSyncManager& aSyncMan, CMsvServerEntry& aServerEntry, CImapSettings& aImapSettings)

: CMsgActive(EPriorityStandard), 

iSyncManager(aSyncMan),

iServerEntry(aServerEntry),

iImapSettings(aImapSettings),

iHeaderConverter(CImapUtils::GetRef().Charconv().HeaderConverter())

	{

	}

/**

Destructor

*/

CImapFolder::~CImapFolder()

	{

	iMatchingMessageIds.Reset();

	iDeletedMessageIds.Reset();

	iMissingMessageIds.Reset();

	if(iCachedEntryData)

		{

	    iCachedEntryData->Close();

		}

	delete iSelection;

	iFolderIndex->Reset();

	iMessageFlagInfoArray.Reset();

	delete iFolderIndex;

	delete iCachedEntryData;

	delete iClearSeenList;

	delete iSetSeenList;

	iFullFolderPath.Close();

	}

/**

Static factory constructor

@param aSyncMan

Reference to the owning Sync Manager (for access to offline control object)

@param aEmailServerEntry

The folder entry on the Message server that will be use to construct this folder object

@return The constructed CImapFolder object pushed onto the cleanup stack

*/

EXPORT_C CImapFolder* CImapFolder::NewLC(CImapSyncManager& aSyncMan, CMsvServerEntry& aServerEntry, TMsvEmailEntry& aEmailEntry, CImapSettings& aImapSettings, const TDesC& aFullFolderPath)

	{

	CImapFolder* self=new (ELeave) CImapFolder(aSyncMan, aServerEntry, aImapSettings);

	CleanupStack::PushL(self);

	// Non-trivial constructor

	self->ConstructL(aServerEntry, aEmailEntry, aFullFolderPath);

	return self;

	}

/**

Static factory constructor with cleanup

@param aSyncMan

Reference to the owning Sync Manager (for access to offline control object)

@param aEmailServerEntry

The folder entry on the Message server that will be use to construct this folder object

@return The constructed CImapFolder object

*/

EXPORT_C CImapFolder* CImapFolder::NewL(CImapSyncManager& aSyncMan, CMsvServerEntry& aServerEntry, TMsvEmailEntry& aEmailEntry, CImapSettings& aImapSettings, const TDesC& aFullFolderPath)

	{

	CImapFolder* self=NewLC(aSyncMan, aServerEntry, aEmailEntry, aImapSettings, aFullFolderPath);

	CleanupStack::Pop();

	return self;

	}

/**

The non-trival constructor

@param aEmailServerEntry

The folder entry on the Message server that will be use to construct this folder object

*/

void CImapFolder::ConstructL(CMsvServerEntry& /*aServerEntry*/, TMsvEmailEntry& aEmailEntry, const TDesC& aFullFolderPath)

	{

	iSessionFolderInfo = NULL;

	iMailboxId = aEmailEntry.Id();

	iMailboxSize = aEmailEntry.RemoteFolderEntries();

	iFolderIndex = new (ELeave) CImapFolderIndex();

	iSelection   = new (ELeave) CMsvEntrySelection();

	iSyncLimit = KImImapSynchroniseAll;

	// Set the Path of folder object

	SetFullFolderPathL(aFullFolderPath) ;

	// We're an active object...

	CActiveScheduler::Add(this);

	}

/**

Sets the full path name of the folder from the service entry downwards. Layout as on the remote IMAP Server.

Should only be use by the CImapSyncManager.

@param aFullFolderPath

The new path to use as the full path of the folder.

*/

void CImapFolder::SetFullFolderPathL(const TDesC& aFullFolderPath)

	{

	iFullFolderPath.Close(); // discard any previous data

	iFullFolderPath.CreateL(aFullFolderPath);

	}

/**

Processing message loop for the active object. Called by the active scheduler.

*/

void CImapFolder::DoRunL()

	{

	// Finish if any server errors.

	if(iStatus.Int()!=KErrNone)

		{

		Complete(iStatus.Int());

		return;

		}

	switch(iNextAction)

		{

	case CImapSyncManager::ESyncNew:

		{

		__LOG_TEXT(iSavedSession->LogId(), "ImapFolder: Starting SynchroniseNewL");				

		SynchroniseNewL();

		return;

		}

	case CImapSyncManager::ESyncFlags:

		{

		__LOG_TEXT(iSavedSession->LogId(), "ImapFolder: Syncing flags for local messages");

		// Whenever iSavedSession->FetchBodyStructureAndHeadersL() is called, this is the next step 

		// (although this step can be reached without calling FetchBodyStructureAndHeadersL())

		// This means that OnFetchLD() may have been called, in which case there are 

		// outstanding BULK entry operations that need to be completed here.

		iServerEntry.CompleteBulk();

		// If there were message flags that has been changed locally and need upadting on the remote server

		// then do those first.

		if(iSetSeenList)

			{

			if(ProcessSeenFlagsL(ESetSeenFlag))

				{

				return;

				}

			}

		if(iClearSeenList)

			{

			if(ProcessSeenFlagsL(EClearSeenFlag))

				{

				return;

				}

			}

		__LOG_TEXT(iSavedSession->LogId(), "ImapFolder: Syncing flags for remote messages");

		// Creates the list of old messages then update the flags for them

		GetMessageChildrenL(iMailboxId, iSelection);

		MakeSortedFolderIndexL(ETrue);

		if(iSelection->Count() > 0)

			{

			iHighestUid = (*iFolderIndex)[iSelection->Count()-1].iUid;

			}

		else

			{

			iHighestUid = 0;

			}

		TInt localcount = iFolderIndex->Size();

		iMatchingMessageIds.Reset();

		for(TInt localloop = 0; localloop < localcount; ++localloop)

			{

			TMsvId localid = (*iFolderIndex)[localloop].iUid;

			iMatchingMessageIds.AppendL(localid);

			}

		iMessageFlagInfoArray.Reset();

		HBufC8* sequenceSetOnHeap = CImapSession::CreateSequenceSetLC(iMatchingMessageIds);

		// Call the FETCHFLAGS function in the session

		iNextAction = CImapSyncManager::EEndSyncFlags;

		iSavedSession->FetchFlagsL(iStatus, *sequenceSetOnHeap, iMessageFlagInfoArray);

		SetActive();

		CleanupStack::PopAndDestroy(sequenceSetOnHeap);

		}

		break;		

	case CImapSyncManager::EEndSyncFlags:

		{

		__LOG_TEXT(iSavedSession->LogId(), "ImapFolder: Call to get the remote flags completed");

		// Loop through the messages array and update the flags for each UID returned

		// Get a clean version of the folder children

		TInt resultscount = iMessageFlagInfoArray.Count();

		for(TInt resultsloop = 0; resultsloop < resultscount; ++resultsloop)

			{

			TMessageFlagInfo *messageinfo = &(iMessageFlagInfoArray[resultsloop]);

			TInt localmsgcount = iFolderIndex->Size();

			// For each returned Uid go through the list of local index to find the matching TMsvId.

			for(TInt localloop = 0; localloop < localmsgcount; ++localloop)

				{

				if((*iFolderIndex)[localloop].iUid == messageinfo->MessageUid())

					{

					SetEntryL((*iFolderIndex)[localloop].iMsvId);

					TMsvEmailEntry entry = iServerEntry.Entry();

					TBool messageInfoSeen = messageinfo->QueryFlag(TMessageFlagInfo::ESeen);

					TBool oldEntrySeen = entry.SeenIMAP4Flag();

					// Are we configured to update the \seen flag on the server?

					// If so then we need to translate "read\unread" flags into "\\seen" or not "\\seen"

					if (iImapSettings.UpdatingSeenFlags())

						{

						// Make a note to update the servers \Seen flag if "read\unread" has CHANGED on the client

						// and is different to the server's version

						if (BoolsAreEqual(entry.Unread(), messageInfoSeen) && BoolsAreEqual(oldEntrySeen, messageInfoSeen))

							{

							if (entry.Unread())

								{

								AppendClearSeenL(entry.UID());

								}

							else

								{

								AppendSetSeenL(entry.UID());

								}								

							}

						}

					entry.SetSeenIMAP4Flag(messageInfoSeen);

					entry.SetFlaggedIMAP4Flag(messageinfo->QueryFlag(TMessageFlagInfo::EFlagged));

					entry.SetDeletedIMAP4Flag(messageinfo->QueryFlag(TMessageFlagInfo::EDeleted));

					entry.SetDraftIMAP4Flag(messageinfo->QueryFlag(TMessageFlagInfo::EDraft));

					entry.SetRecentIMAP4Flag(messageinfo->QueryFlag(TMessageFlagInfo::ERecent));

					// Are we configured to update the \seen flag on the server?

					if (iImapSettings.UpdatingSeenFlags())

						{

						// Now copy the inverse of the \Seen flag down to the phone's Unread flag 

						//  except when LastSyncSeen is set (ie when the client version is more up to date)

						//  This means that the client Read status ALWAYS reflects the IMAP \Seen state

						if (BoolsAreEqual(entry.Unread(), messageInfoSeen) 		&& BoolsAreNotEqual(oldEntrySeen, messageInfoSeen))

							{

							// Phone and server disagree on whether the message has been read.

							// And the seen flag on the server is different to that on the phone.

							// Which means that a change has happened on the server that the phone was not aware of.

							// So server is more up to date, and we take its value.

							entry.SetUnread(!messageInfoSeen);

							}

						}

					ChangeEntryBulkL(entry); // completed after the outer for loop

					break;

					}

				} // end of inner for loop

			}

		iServerEntry.CompleteBulk();

		iNextAction = CImapSyncManager::ESyncProcessSeenFlagsAndComplete;

		SetActive();

		CompleteSelf();

		}

		break;		

	case CImapSyncManager::ESyncProcessSeenFlagsAndComplete:

		{

		// If there were message flags that has been changed locally and need upadting on the remote server

		// then do those now.

		if(iSetSeenList)

			{

			if(ProcessSeenFlagsL(ESetSeenFlag))

				{

				return;

				}

			}

		if(iClearSeenList)

			{

			if(ProcessSeenFlagsL(EClearSeenFlag))

				{

				return;

				}

			}

		SyncCompleteL();

		Complete(iStatus.Int());

		}

		break;

	case CImapSyncManager::ESyncSearch:

		{

		if(iStatus == KErrNone) 

			{

			if(iSyncState == CImapSyncManager::ESyncSearch)

				{

				// Process the seach results to see if any messages ids are left.

				if(CheckAndProgressMessageSyncL())

					{

					// More messages and the search command has been sent so just return.

					return;

					}

				}

			// If the sync action is syncing old messages then go through the list of found ids

			// match it with the folder index and build a list of messages that are no longer on the server.

			if(iSyncState == CImapSyncManager::ESyncOld)

				{

				// At this point the remote command to search out folder UIDs has completed. This

				// list will contain all UIDs for messages in the remote folder. This may be too

				// many, and if so, the list is truncated to only include the N most recent 

				// messages in accordance with the synchronisation limit.

				TInt syncThresh = GetSyncThreshold();

				__LOG_FORMAT((iSavedSession->LogId(), "ImapFolder: Syncing old. syncThresh = %d", syncThresh));

				// Perform the check on the message ids to make sure that only messages that are within

				// the sync limit will be left in iDeletedMessageIds.

				CheckMessagesInRangeL(syncThresh);

				// Check the delete ids list and delete messages according to what's in the list	

				TInt deletedcount = iDeletedMessageIds.Count();

				// Remove message from the local server

				for(TInt deleteloop = 0; deleteloop < deletedcount; ++deleteloop)

					{

					__LOG_FORMAT((iSavedSession->LogId(), "ImapFolder: Local message (%d) deleting.", (*iFolderIndex)[iDeletedMessageIds[deleteloop]].iMsvId));

					DeleteMessageL((*iFolderIndex)[iDeletedMessageIds[deleteloop]].iMsvId);

					}

				// Trim the list down to the most recent UIDs consistant with the sync limit.

				if(iMatchingMessageIds.Count() > syncThresh)

					{

					for(TInt i = 0; i < syncThresh; ++i)

						{

						iMatchingMessageIds.Remove(0);

						}

					}

				// Get a clean version of the folder children

				GetMessageChildrenL(iMailboxId, iSelection);

				//update the progress object

				iMsgsToDo = iMatchingMessageIds.Count();

				MakeSortedFolderIndexL(ETrue);

				if(iSelection->Count() > 0)

					{

					iHighestUid = (*iFolderIndex)[iSelection->Count()-1].iUid;

					}

				else

					{

					iHighestUid = 0;

					}

				// At this point, the remote command to fetch all old messages has completed. 

				// Now we can look at fetching all new messages. 'iHighestUid' will contain the

				// highest UID of the old messages. The top entry in 'iSearchList' will contain

				// the highest UID in the remote folder. This gives us the range of UID to fetch

				// for new messages.

				// First check are there any new messages to fetch? If 'iHighestUid' is the highest

				// UID locally and remotely, then we finished sync'ing when we completed the old

				// sync.

				if(iMatchingMessageIds.Count() == 0)

					{

					__LOG_TEXT(iSavedSession->LogId(), "ImapFolder: Search List is empty");				

					}

				else if(iHighestUid < iMatchingMessageIds[iMatchingMessageIds.Count()-1])

					{

					TUint32 uidLow = iHighestUid;

					TUint32 uidHigh = iMatchingMessageIds[iMatchingMessageIds.Count()-1];

					// Only want new messages.

					uidLow++;

					// Are there only new messages (and no old)?

					if(iHighestUid == 0)

						{

						// Set this to ensure range is correct.

						uidLow = iMatchingMessageIds[0];

						}

					// Perform the new sync.

					__LOG_FORMAT((iSavedSession->LogId(), "ImapFolder: Synchronising new messages with range %d:%d", uidLow, uidHigh));

					SynchroniseRangeL(uidLow, uidHigh);

					return;

					}

				iSyncState = CImapSyncManager::ESyncNew;	

				}

			if((iSyncState == CImapSyncManager::ESyncNew) && (iImapSettings.SearchString().Length() == 0))

				{

				// Check for missing UIDs, ie. holes in the messages that we should have.

				CheckForMissingMessagesUidsL();

				// If there were any "missing" messages found during the sync that we should have

				// mirrored previously, get these now.

				if(iMissingMessageIds.Count() != 0)

					{

					__LOG_FORMAT((iSavedSession->LogId(), "ImapFolder: Missing messages detected %d", iMissingMessageIds.Count()));

					HBufC8* sequenceSetOnHeap = CImapSession::CreateSequenceSetLC(iMissingMessageIds);

					// Call the FETCH function in the session

					iSavedSession->FetchBodyStructureAndHeadersL(iStatus, sequenceSetOnHeap->Des(), KImapSmallHeaderFields(), *this);

					CleanupStack::PopAndDestroy(sequenceSetOnHeap);

					SetActive();

				 	iSyncState = CImapSyncManager::EFolderSynchronise;

				 	iNextAction = CImapSyncManager::ESyncFlags;

					return;

					}

				if(iSyncLimit <= KImImapSynchroniseAll)

					{

					__LOG_TEXT(iSavedSession->LogId(), "ImapFolder: Starting SynchroniseNewL");				

					SynchroniseNewL();

					return;

					}

				// If we haven't returned yet, then no new messages to sync

				// so just sync the flags of existing messages.

				iSyncState = CImapSyncManager::EFolderSynchronise;

			 	iNextAction = CImapSyncManager::ESyncFlags;

			 	SetActive();

			 	CompleteSelf();

				return;

				}

			else

				{

				SyncCompleteL();

				Complete(iStatus.Int());

				}

			}

		}

		break;

	case CImapSyncManager::EFolderExpunge:

		{

		// Call expunge to delete messages marked for delete

		__LOG_FORMAT((iSavedSession->LogId(), "ImapFolder: calling EXPUNGE in folder %S", &iFullFolderPath));

		iSyncState = CImapSyncManager::EFolderExpunge;

		iNextAction = CImapSyncManager::EFolderLocalExpunge;

		iSavedSession->ExpungeL(iStatus);

		SetActive();

		}

		break;

	case CImapSyncManager::EFolderClose:

		{

		//Permanently removes all messages that have the deleted flag set

		//from the currently selected mailbox

		iSyncState = CImapSyncManager::EFolderClose;