// 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:
//

#include "cimapcompoundcreate.h"
#include "cimapfolder.h"
#include "cimapsyncmanager.h"
#include "cimapsessionconsts.h"
#include "cimaplogger.h"
#include "imappaniccodes.h"

#include "mobilitytestmtmapi.h"

CImapCompoundCreate::CImapCompoundCreate(CImapSyncManager& aSyncManager,
						 				 CMsvServerEntry& aServerEntry,
						 				 CImapSettings& aImapSettings,
						 				 const TMsvId aParent,
						 				 const TBool aIsFolder) :
	CImapCompoundBase(aSyncManager, aServerEntry, aImapSettings),
	iParentId(aParent), iIsFolder(aIsFolder)
	
	{
	
	}

CImapCompoundCreate::~CImapCompoundCreate()
	{
	delete iLeafName;
	iFolderList.ResetAndDestroy();
	}
	
CImapCompoundCreate* CImapCompoundCreate::NewL(CImapSyncManager& aSyncManager,
						 				  	   CMsvServerEntry& aServerEntry,
						 				  	   CImapSettings& aImapSettings,
											   const TMsvId aParent, 
						  					   const TDesC& aLeafName, 
						  					   const TBool aIsFolder)
	{
	CImapCompoundCreate* self = new (ELeave) CImapCompoundCreate(aSyncManager,
																 aServerEntry,
																 aImapSettings,
																 aParent,
																 aIsFolder);
	CleanupStack::PushL(self);
	self->ConstructL(aLeafName);
	CleanupStack::Pop(self);
	return self;
	}

void CImapCompoundCreate::ConstructL(const TDesC& aLeafName)
	{
	iLeafName = aLeafName.AllocL();
	
	// Add to the active scheduler
	CActiveScheduler::Add(this);
	}

	
void CImapCompoundCreate::StartOperation(TRequestStatus& aStatus, CImapSession& aSession)
	{
	iSession = &aSession;
	__LOG_TEXT(iSession->LogId(), "CImapCompoundCreate::StartOperation()");
	iNextStep = ECreate;
	Queue(aStatus);
	CompleteSelf();
	}

/**
Handles the compound operation state machine

@return ETrue if compound operation is completed, 
		EFalse otherwise.
*/	
TBool CImapCompoundCreate::DoRunLoopL()
	{
	SetCurrentStep();
	switch (iCurrentStep)
		{
		case ECreate:		// asynchronous
			{
			MOBILITY_TEST_MTM_STATE(iImapSettings.ServiceId(), KMobilityTestMtmStateImapCreateFolder);
			// Make the folder/mailbox name to create
			HBufC* newFolderPath = MakeFolderNameL(iParentId, *iLeafName, iIsFolder);
			CleanupStack::PushL(newFolderPath);
			
			iSession->CreateL(iStatus, *newFolderPath);

			CleanupStack::PopAndDestroy(newFolderPath);

			iProgressState = TImap4GenericProgress::EBusy;
			iNextStep = ECreateLocal;
			SetActive();
			break;
			}
		
		case ECheckFolderExists:
			{
			// This state allows to check if a folder already exists remotely.
			// It is entered if a migration occurs during the create state,
			// and is used to determine if the CREATE succeeded, even though we
			// did not receive a response prior to the operation being cancelled
			// to allow the migration to occur.
			__LOG_TEXT(iSession->LogId(), "CImapSessionManager::ECheckFolderExists");

			// Make the folder/mailbox name to create
			HBufC* newFolderPath = MakeFolderNameL(iParentId, *iLeafName, iIsFolder);
			CleanupStack::PushL(newFolderPath);
			
			iFolderList.ResetAndDestroy();
			iSession->ListL(iStatus, KNullDesC(), *newFolderPath, iFolderList);
			
			CleanupStack::PopAndDestroy(newFolderPath);

			iNextStep = EProcessFolderCheck;
			SetActive();
			break;
			}

		case EProcessFolderCheck:
			{
			if (iFolderList.Count()==0)
				{
				// the folder does not exist remotely - (re)send the CREATE
				iNextStep = ECreate;
				}
			else
				{
				// the folder exists on the remote server - create a local copy
				iNextStep = ECreateLocal;
				}
			return EFalse;
			}
		
		case ECreateLocal: 	// synchronous
			{	
			CreateLocalFolderL();
			iNextStep = EFinished;
			// fall through
			}
			
		case EFinished:		// finished
			{
			__LOG_TEXT(iSession->LogId(), "CImapCompoundCreate::Completing OK");
			iProgressState = TImap4GenericProgress::EIdle;
			Complete(KErrNone);
			return ETrue;
			}
			
		default:
			{
			__ASSERT_DEBUG(EFalse, 
			   TImapServerPanic::ImapPanic(TImapServerPanic::ECreateCompoundUnexpectedState));
			// unexpected state - complete the request
			iProgressState = TImap4GenericProgress::EIdle;
			return ETrue;
			}
		}
	return EFalse;
	}

/**
May be called in case of a genuine cancel or a cancel for migrate.
Following a genuine cancel, the compound operation will be deleted.
Following a cancel for migrate, the compound operation will be resumed,
so the iNextState is updated here to ensure the operation is
correctly restarted.

In either case, CMsgActive::DoCancel() is called to complete the
user request with KErrCancel.

Note that if the default CMsgActive::DoComplete() is overridden,
then that must also be modified to handle either case described above.
*/
void CImapCompoundCreate::DoCancel()
	{
	switch (iCurrentStep)
		{
		case ECreate:
		case ECheckFolderExists:
			{
			// outstanding request is on session
			iSession->Cancel();
			iNextStep = ECheckFolderExists;
			break;
			}
		case EProcessFolderCheck:
		case ECreateLocal:
		case EFinished:
			{
			// self-completed or no outstanding request.
			break;
			}
		case ESuspendedForMigrate:
		default:
			{
			__ASSERT_DEBUG(EFalse,
			   TImapServerPanic::ImapPanic(TImapServerPanic::ECreateCompoundCancelUnexpectedState));
			break;
			}
		} // end switch (iCurrentStep)
	
	if (!iCancelForMigrate)
		{
		// genuine cancel - update progress
		iProgressErrorCode = KErrCancel;
		}
	CMsgActive::DoCancel();
	}

/**
Builds the full IMAP pathname for the folder to be created.

@param aParent   id of the parent TMsvEntry
@param aLeafName name of the folder to be created
@param aIsFolder ETrue if the folder is to be a folder rather than a mailbox
@return a heap descriptor containing the full pathname.  Ownership is transferred to the caller.
*/
HBufC* CImapCompoundCreate::MakeFolderNameL(const TMsvId aParent, 
										  const TDesC& aLeafName,
										  const TBool aIsFolder)
	{
	
	// parent path is empty if creating a folder under the service entry.
	HBufC* parentpath = NULL;
	// Creates the ImapFolder without subscribe.. (EFalse is passed for not to subscribe folder)
	CImapFolder* folder = iSyncManager.GetFolderL(aParent, EFalse);
	if (aParent!=iImapSettings.ServiceId())
		{
		// Puts parentpath on the cleanupstack
		parentpath = folder->FullFolderPathL().AllocLC();
		}
	else
		{
		// otherwise parentpath is empty
		parentpath = KNullDesC().AllocLC();
		}

	const TDesC& pathSeparator = iImapSettings.PathSeparator();			
	HBufC* newFolderPath = NULL;
			
	if (*parentpath==KNullDesC)
		{
		// creating a root entry folder
		if (aIsFolder)
			{
			// +1 for trailing heirarchy path separator
			newFolderPath = HBufC16::NewLC(aLeafName.Length()+1);
			TPtr16 ptr(newFolderPath->Des());
			ptr.Copy(aLeafName);
			ptr.Append(pathSeparator);
			}
		else
			{
			// Root level mailbox
			newFolderPath = aLeafName.AllocLC();
			}
		}
	else
		{
		// creating a subfolder
		if (aIsFolder)
			{
			// +1 for heirarchy separator, +1 for trailing heirarchy path separator
			newFolderPath = HBufC16::NewLC(parentpath->Length()+aLeafName.Length()+2);
			TPtr16 ptr(newFolderPath->Des());
			ptr.Copy(*parentpath);
			ptr.Append(pathSeparator);
			ptr.Append(aLeafName);
			ptr.Append(pathSeparator);
			}
		else
			{
			// +1 for heirarchy separator
			newFolderPath = HBufC16::NewLC(parentpath->Length()+aLeafName.Length()+1);
			TPtr16 ptr(newFolderPath->Des());
			ptr.Copy(*parentpath);
			ptr.Append(pathSeparator);
			ptr.Append(aLeafName);
			}
		}
		
	CleanupStack::Pop(newFolderPath);
	CleanupStack::PopAndDestroy(parentpath);
	
	return newFolderPath;
	}


/**
Creates local mirror of the newly created folder.

*/
void CImapCompoundCreate::CreateLocalFolderL()
	{
	TMsvEmailEntry message;
	SetEntryL(iParentId);
	// No need to set iMtmData1-3 or iSize to 0 as this is done on construction.
	
	message.iType=KUidMsvFolderEntry;
	message.iMtm=KUidMsgTypeIMAP4;
	message.iServiceId=iImapSettings.ServiceId();
	message.SetValidUID(EFalse);
	message.SetMailbox(ETrue); // Default to creating a mailbox
	message.SetComplete(ETrue);
	message.iDetails.Set(*iLeafName);
	iServerEntry.CreateEntry(message);
	// Save the created id for the progress response
	iNewFolderId=message.Id();
	}


void CImapCompoundCreate::Progress(TImap4CompoundProgress& aCompoundProgress)
	{
	// Create does not set iOperation, it just sets iState to EBusy 
	// when doing the creation
	aCompoundProgress.iGenericProgress.iState = iProgressState;
	aCompoundProgress.iGenericProgress.iReturnedMsvId = iNewFolderId;
	
	// Put error into progress buffer
	if( aCompoundProgress.iGenericProgress.iErrorCode == KErrNone )
		{
		aCompoundProgress.iGenericProgress.iErrorCode = iProgressErrorCode;
		}
	}


/**
Handles NO/BAD responses according to current step.
Negative server responses are not fatal - the error is reported in the 
progress report, and the operation completes.

@return KErrNone if the error has been handled
		Completion error code otherwise.
*/
TInt CImapCompoundCreate::ProcessNegativeServerResponse()
	{
	TInt err = iStatus.Int();
	switch (iCurrentStep)
		{
		case ECreate:
		case ECheckFolderExists:
			// Skip creation of local folder...
			iNextStep = EFinished;
			break;
		case EProcessFolderCheck:
		case ECreateLocal:
		case EFinished:
		case ESuspendedForMigrate:
		default:
			{
			// positive error code not expected,
			// self-completed states or no outstanding request.
			TImapServerPanic::ImapPanic(TImapServerPanic::ECreateCompoundUnexpectedState);
			break;
			}
		
		} // end switch (iCurrentStep)
	iProgressErrorCode = err;
	return KErrNone;
	}

/**
Called to resume the compound operation following a bearer migration.
*/
void CImapCompoundCreate::ResumeOperationL(TRequestStatus& aStatus, CImapSession& aSession)
	{
	iSession = &aSession;
	__LOG_TEXT(iSession->LogId(), "CImapCompoundCreate::Resuming");
	__ASSERT_DEBUG(iCurrentStep==ESuspendedForMigrate, TImapServerPanic::ImapPanic(TImapServerPanic::ECreateCompoundUnexpectedState));
	iStopForMigrate = EFalse;

	// Switch on next step
	switch (iNextStep)
		{
		case ECreate:
		case ECheckFolderExists:
			{
			// Restart the operation
			CompleteSelf();
			break;
			}
		
		case ECreateLocal:
		case EFinished:
		default:
			{
			__ASSERT_DEBUG(EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::ECreateCompoundUnexpectedState));
			// abandon the compound operation
			iNextStep=EFinished;
			CompleteSelf();
			break;
			}
		} // end switch (iNextStep)
	Queue(aStatus);
	}