// Copyright (c) 2006-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:
// cimapcompoundbase.cpp
//

#include "cimapcompoundbase.h"
#include "cimapsession.h"
#include "cimapsettings.h"
#include "cimapsessionconsts.h"
#include "cimaplogger.h"
#include "imappaniccodes.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS  
#include "timrfc822datefield.h"				
#endif

CImapCompoundBase::CImapCompoundBase( CImapSyncManager& aSyncManager,
					   				  CMsvServerEntry& aServerEntry,
					   				  CImapSettings& aImapSettings) :
	CMsgActive(EPriorityStandard ),
	iSyncManager(aSyncManager),
	iServerEntry(aServerEntry),
	iImapSettings(aImapSettings),
	iStopForMigrate(EFalse),
	iCancelForMigrate(EFalse),
	iProgressState(TImap4GenericProgress::EIdle),
	iSyncProgressState(TImap4SyncProgress::EIdle)
	{

	}

CImapCompoundBase::~CImapCompoundBase( )
	{
	}

#ifdef __IMAP_LOGGING
void CImapCompoundBase::DoComplete(TInt& aErr)
#else
void CImapCompoundBase::DoComplete(TInt& /*aErr*/)
#endif //_IMAP_LOGGING
	{
	__LOG_FORMAT((iSession->LogId(), "CImapCompoundBase::DoComplete(aErr = %d) CurrentStep = %d", aErr, iCurrentStep));
	}

/**
Called when asynchronous service requests complete.
Handles errors returned by aSynchronous services. 

The state machine for derived compound commands is managed by 
the pure-virtual DoRunLoopL() which is called by DoRunL(). 

This form of DoRunL also allows synchronous steps to be performed 
sequentially.
*/
void CImapCompoundBase::DoRunL()
	{
	// Handle any server errors
	if (iStatus.Int()!=KErrNone)
		{
		if (TInt err=ProcessSessionError() != KErrNone)
			{
			Complete(err);
			return;
			}
		}

	// Operation state machine handled by DoRunLoopL()
	while (!IsActive() && !DoRunLoopL())
		{
		// do nothing in the body of this
		}
	}


/**
Base class method for handling errors returned by the session.
Called on completion of an asynchronous request on the IMAP session,
ie at the start of the DoRunL() method. If this method returns
a value other than KErrNone, the compound operation should complete
with the return value as the error code.

This will catch any positive error codes returned by the imap
session These indicate either NO/BAD server responses or a more
serious error has occurred, for example a disconnect, or corrupt
data received from the remote server.

NO/BAD server responses are handled by the derived compound
operation classes (these are non-fatal errors, an attempt is
made to continue the requested operation)

Other errors are more serious - these are passed up to the
Protocol Controller to deal with.

@return KErrNone if the error has been handled,
        otherwise the positive error code as returned by
        the IMAP session.
*/
TInt CImapCompoundBase::ProcessSessionError()
	{
	TInt errCode = iStatus.Int();
	if (errCode==KErrImapNo || errCode==KErrImapBad)
		{
		return ProcessNegativeServerResponse();
		}
	else
		{
		return errCode;
		}
	}

/**
Checks the input selection for entries of specified types.
In this context, "Messages" means complete messages, not RFC888
parts of another message. "parts" means attachment or text bodies.

@param aSelection    - original list of message entry ids
@param aLocalCopy    - filtered copy of message entry ids.
@param aMessages     - accept entries of type KUidMsvMessageEntry
@param aParts        - accept entries of type KUidMsvEmailTextEntry,
											  KUidMsvAttachmentEntry, 
											  KUidMsvMessageEntry
											  KUidMsvEmailHtmlEntry
  	  	                                      KUidMsvEmailExternalBodyEntry
  	  	                                      KUidMsvEmailRtfEntry
@param aFolders		 - accept entries of type KUidMsvFolderEntry
@param aIsInService	 - only accept entries under the IMAP service entry

@return KErrNotSupported if no valid entries,
        KErrNone otherwise
*/
TInt CImapCompoundBase::CheckSelectionL(const CMsvEntrySelection& aSelection,
									    CMsvEntrySelection* aLocalCopy,
									    const TBool aMessages,
									    const TBool aParts,
									    const TBool aFolders,
									    const TBool aIsInService)
	{
	// reset the local copy
	aLocalCopy->Reset();
	
	// get the service ID
	TMsvId serviceId = iImapSettings.ServiceId();

	// Check all entries are messages
	for(TInt a=0;a<aSelection.Count();a++)
		{
		// Does entry exist?
		TBool addIt = EFalse;

		if (iServerEntry.SetEntry(aSelection[a])==KErrNone)
			{
			TUid type = iServerEntry.Entry().iType;
			if ((aMessages && type==KUidMsvMessageEntry) ||
				(aParts && (type==KUidMsvEmailTextEntry || type==KUidMsvAttachmentEntry || type==KUidMsvMessageEntry || type==KUidMsvEmailHtmlEntry || type==KUidMsvEmailExternalBodyEntry || type==KUidMsvEmailRtfEntry)) ||
				(aFolders && type==KUidMsvFolderEntry))
				{
				TBool inEnclosingMessage=EFalse;

				// Do we need to check if it's in the local service or
				// if it is a complete message
				if (aIsInService || (!aParts && type==KUidMsvMessageEntry))
					{
					// Work up the tree until we get to the service or the root
					do
						{
						SetEntryL(iServerEntry.Entry().Parent());
						if (iServerEntry.Entry().iType==KUidMsvMessageEntry)
							{
							inEnclosingMessage=ETrue;
							}
						}
					while(iServerEntry.Entry().iType!=KUidMsvServiceEntry &&
						  iServerEntry.Entry().Id()!=KMsvRootIndexEntryId);		
	
					// Are we at the service that this MTM referrs to?
					// if offline iServiceId==0 so allow all
					if (!aIsInService || serviceId==0 || iServerEntry.Entry().Id()==serviceId)
						{
						// it's OK if it is not a message type (in
						// which case it has already been checked and
						// passed) or it is not within an enclosing message
						if (type!=KUidMsvMessageEntry || !inEnclosingMessage || aParts)
							{
							addIt = ETrue;
							}
						}
					}
				else
					{
					// Add to local copy
					addIt = ETrue;
					}
				}
			}

		if (addIt)
			{
			aLocalCopy->AppendL(aSelection[a]);
			}
#ifdef _DEBUG
		// UI shouldn't really be giving us bogus items so panic
		else
			{
			TImapServerPanic::ImapPanic(TImapServerPanic::EInvalidMsvTypeToCommand); 
			}
#endif
		}

	// Anything to do?
	if (!aLocalCopy->Count())
		{
		// Nothing valid to work with
		return(KErrNotSupported);
		}
	else
		{
		// All OK, the selection isn't empty
		return(KErrNone);
		}
	}

/**
Sums the total size of messages to be copied or moved

@param aSelection - selection of messages to be processed
@return TInt      - the total size of the messages in the selection
*/
TInt CImapCompoundBase::CalculateDownloadSizeL(const CMsvEntrySelection& aSelection)
	{
	TInt totalSize = 0;

	// Do a quick tally on the size of messages which are to be copied / moved.
	TInt count=aSelection.Count();
	while (count--)
		{
		SetEntryL(aSelection.At(count));
		// Only add the size up if the message is not complete.
		if(!iServerEntry.Entry().Complete())
			{
			totalSize += iServerEntry.Entry().iSize;
			}
		}
	return totalSize;
	}

/**
Find the folder that contains specified message

@param aMessage - selection of messages to be processed
@return TMsvId  - the parent folder of aMessage, or the service ID.
*/
TMsvId CImapCompoundBase::FindFolderL(const TMsvId aMessage)
	{
	__LOG_FORMAT((iSession->LogId(), "CImapCompoundBase::FindFolderL(%d)", aMessage));

	// Find folder that encloses this message (has Mailbox flag set), or service,
	// whichever we find first
	SetEntryL(aMessage);
	TMsvEmailEntry entry;
	do
		{
		// Change context to parent of current entry
		SetEntryL(iServerEntry.Entry().Parent());
		entry=iServerEntry.Entry();

		__LOG_FORMAT((iSession->LogId(), "  At %x, type=%x, mailbox=%d", entry.Id(),entry.iType,entry.Mailbox()));
		
		// A folder & a mailbox, or a service?
		if (entry.iType==KUidMsvFolderEntry && entry.Mailbox())
			{
			// This'll do!
			return(entry.Id());
			}
		}
	while(iServerEntry.Entry().iType!=KUidMsvServiceEntry && entry.Id()!=KMsvRootIndexEntryId);

	__LOG_TEXT(iSession->LogId(), "  FindFolderL() Failed");

	return(NULL);
	}

// Do setentry, leave if there is an error
void CImapCompoundBase::SetEntryL(const TMsvId aId)
	{
	User::LeaveIfError(iServerEntry.SetEntry(aId));
	}

/**
Self completes to allow RunL to be called.
*/	
void CImapCompoundBase::CompleteSelf()
	{
	SetActive();
	TRequestStatus* status = &iStatus;
	User::RequestComplete(status, KErrNone);
	}


void CImapCompoundBase::SetCurrentStep()
	{
	iCurrentStep = iNextStep;
	}

/**
Save error code in a message

@param aMessgeId
@param aError
*/
void CImapCompoundBase::MessageErrorL(const TMsvId aMessageId, const TInt aError)
	{
	// Save error code: if we can't access this entry, then it's probably something to do
	// with the error we're trying to report: ignore it silently
	if (iServerEntry.SetEntry(aMessageId)==KErrNone)
		{
		TMsvEntry entry=iServerEntry.Entry();

		// Save unnecessary writes...
		if (entry.iError!=aError)
			{
			entry.iError=aError;
			User::LeaveIfError(iServerEntry.ChangeEntry(entry));
			}
		}
	}

/**
Cancels outstanding service request, and recovers the compound operation
object to a state in which the operation may be restarted following migration
to a new carrier.
The operation will be restarted by a call to ResumeOperationL().

Derived classes must implement a DoCancel that sets iNextStep to the step
that should be performed following the migration, when ReumeOperationL is called;
*/
void CImapCompoundBase::CancelForMigrate()
	{
	__LOG_TEXT(iSession->LogId(), "CImapCompoundBase::CancelForMigrate()");
	iCancelForMigrate = ETrue;
	Cancel();
	iCancelForMigrate = EFalse;
	// Mark Operation as suspended.
	iCurrentStep = ESuspendedForMigrate;
	}

/**
Indicates that the compound operation should complete as soon as it is possible
for the operation to be re-started without requiring a significant amount of
repeated communication.
The operation will be restarted by a call to ResumeOperationL()
*/
void CImapCompoundBase::StopForMigrate()
	{
	__LOG_TEXT(iSession->LogId(), "CImapCompoundBase::StopForMigrate()");
	iStopForMigrate = ETrue;
	}
	
/**
Returns ETrue if the compound operation has been suspended (stopped/cancelled).
This would occur in the case of a bearer migration.
*/
TBool CImapCompoundBase::Suspended()
	{
	if (iCurrentStep == ESuspendedForMigrate)
		{
		return ETrue;
		}
	return EFalse;
	}