// 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 <e32std.h>

#include "POPSMBX.H"

#include "POPS.H"

#include "POPSOP.H" //CImPop3Operations

// includes for IMCV stuff

#include <txtetext.h>

#include <txtrich.h>

#include <miuthdr.h>

#include <imcvrecv.h>

#include <msvapi.h>

#include <s32mem.h>

#include <s32file.h>

#include "POPS.PAN" // imrc's own panic codes

// Oyster includes

#include <msvstd.h>

#include <msventry.h>	// CMsvServerEntry

#include <msvstore.h>

#include <mmsvattachmentmanager.h>

#include <mmsvattachmentmanagersync.h>

#include <miutset.h>

#include <imcvutil.h>

#include <popsmtm.h>

#include "POPSRFSH.h"

#include "POPS.H"

#include "POPSOP.H" //CImPop3Operations

#include "POPSMBX.H"

_LIT(KUidlFile,"UIDLS");

const TInt KMaxStringLength = 1024;	

//

// My own panic command 

//

GLREF_C void Panic(TPopsPanic aPanic);

CImPop3RefreshMailBox::CImPop3RefreshMailBox(CImPop3Session& aPopSession): CMsgActive( KMsgPop3RefreshMailboxPriority ), iPopSession( aPopSession)

	{

	__DECLARE_NAME(_S("CImPop3RefreshMailBox"));

	}

CImPop3RefreshMailBox* CImPop3RefreshMailBox::NewL(CMsvServerEntry& aRemoteServerEntry, CImPop3Session& aPopSession, RFs& anFs)

	{

	CImPop3RefreshMailBox* self = new (ELeave) CImPop3RefreshMailBox( aPopSession);

	CleanupStack::PushL(self);	

	self->ConstructL(aRemoteServerEntry, anFs);

	CleanupStack::Pop();

	return self;

	}

void CImPop3RefreshMailBox::ConstructL(CMsvServerEntry& aRemoteServerEntry, RFs& anFs)

	{

	iRefreshOperation = CImPop3RefreshOperation::NewL(aRemoteServerEntry, &iPopSession, anFs);	

	_LIT8(KCrLfStr,".\r\n");

	iFullStopTerminator = KCrLfStr();

	iTextServer=iPopSession.TextServerSession();

	CActiveScheduler::Add(this);	  // Add PopSession to scheduler's queue

	}

CImPop3RefreshMailBox::~CImPop3RefreshMailBox()

	{

	Cancel();

	delete iRefreshOperation;

	}

void CImPop3RefreshMailBox::DoCancel()

	{

	switch(iState)

		{

		case EPop3RefreshBoxDefault:

		case EPop3RefreshBoxTop:

			{

			if (iMigratingToNewBearer)

			{

			iRefreshOperation->CancelAllowResume();

			}

			else

			{

			iRefreshOperation->Cancel();

			}

			break;

			}

		case EPop3RefreshBoxPurgeInput:

			{

			iTextServer->Cancel();

			break;

			}

		default:

			{

			__ASSERT_DEBUG(EFalse, Panic(EImppUnknownRefreshState));

			}

			break;

		}

	CMsgActive::DoCancel();

	}

void CImPop3RefreshMailBox::Start(TRequestStatus& aStatus, CArrayFixFlat<TMsvId>* aMsvIdArray)

	{	

	Queue(aStatus);

	iMsvIdArray = aMsvIdArray;// Provided for transparency

	TRAPD(stateErr,ChangeStateL(EPop3RefreshBoxDefault));

	if(stateErr!=KErrNone)

		{

		Complete(stateErr);

		}

	}

void CImPop3RefreshMailBox::DoRunL()

	{

	if (iMigratingToNewBearer)

		{

		// The Pops MTM is currently migrating so no processing is required here

		// This call to doRunl is probably as a result of CImPop3RefreshOperation::Pause()

		// completing us.

		return;

		}

	switch (iState)

		{

	case EPop3RefreshBoxDefault:

		if (iStatus.Int() == KPop3RefreshUidlEquate) 

			{

			ChangeStateL(EPop3RefreshBoxPurgeInput);

			}

		break;

	case  EPop3RefreshBoxPurgeInput:

		iTextServer->GetCurrentTextLine(iTextServerResponse);

		if(iTextServerResponse.Compare(iFullStopTerminator)!=0)	

			{

			iTextServer->QueueReceiveNextTextLine(iStatus);

			SetActive();

			} 

		else 

			{

			ChangeStateL(EPop3RefreshBoxTop);

			}

		break;

	case EPop3RefreshBoxTop:

			break;

	default:

			break;

		};		

	}

void CImPop3RefreshMailBox::ChangeStateL(TState aState)

    {

	switch (aState)

        {

	case EPop3RefreshBoxDefault:

			// Start refresh with UIDL

			iRefreshOperation->Start(iStatus,iMsvIdArray);

			break;

	case EPop3RefreshBoxPurgeInput:

			iPopSession.SetOpNotPending();

			iTextServer->GetCurrentTextLine(iTextServerResponse);

			if(iTextServerResponse.Compare(iFullStopTerminator)!=0) 

			{

				iTextServer->QueueReceiveNextTextLine(iStatus);

				// Break here to make sure Async function is called before SetActive() is called, 

				// else we'll get a Stray Signal

				break;

			}

	case EPop3RefreshBoxTop:

			iRefreshOperation->Cancel();

			iRefreshOperation->Start(iStatus); // Restart refresh with Top

			break;

	default:

			break;

	}

	iState = aState;

	SetActive();

	}

TPop3Progress CImPop3RefreshMailBox::Progress()

	{

	 return iRefreshOperation->Progress();

	}

void CImPop3RefreshMailBox::SetMessagesToKeepL(const CMsvEntrySelection* aMessagesToKeep)

	{

	iRefreshOperation->SetMessagesToKeepL(aMessagesToKeep);

	}

TUint CImPop3RefreshMailBox::RemoteMessageSizeL(TMsvId aId)

	{

	return iRefreshOperation->RemoteMessageSizeL(aId);

	}

// ****************************************************************************************** 

// This is called by the POP Client MTM when it starts Migrating Bearer

// 

// ******************************************************************************************	

void CImPop3RefreshMailBox::Pause()

	{

	iMigratingToNewBearer = ETrue;

	// Ask the Refresh Operation to prepare itself for Migration

	switch(iState)

		{

		case EPop3RefreshBoxDefault:

		case EPop3RefreshBoxTop:

			{

			iRefreshOperation->Pause();

			break;

			}

		case EPop3RefreshBoxPurgeInput:

			{

			// Cancel the Text Server request, so we can complete to migrate.

			iTextServer->Cancel();

			break;

			}

		default:

			{

			__ASSERT_DEBUG(EFalse, Panic(EImppUnknownRefreshState));

			}

			break;

		}

	}

// ****************************************************************************************** 

// This is called by the POP Client MTM when it starts Migrating Bearer

// 

// ******************************************************************************************	

void CImPop3RefreshMailBox::CancelAllowResume()

	{

	iMigratingToNewBearer = ETrue;

	Cancel();

	}

// Called by the POP Client MTM, once it has completed Migrating to new bearer 

void CImPop3RefreshMailBox::ResumeL(CImPop3Session* aPopSession, TRequestStatus& aStatus)

	{

	Queue(aStatus);

	iMigratingToNewBearer = EFalse;

	if (iState == EPop3RefreshBoxPurgeInput)

		{

		ChangeStateL(EPop3RefreshBoxTop);

		}

	else

		{

		// Inform the Refresh Operation of Migration Completion

		iRefreshOperation->ResumeL(aPopSession, iStatus);

		SetActive();

		}

	}

//================================================================================

CImPop3RefreshOperation::CImPop3RefreshOperation(CMsvServerEntry& aRemoteServerEntry, CImPop3Session* aPopSession, RFs& anFs)

	: CMsgActive( KMsgPop3RefreshMailboxPriority ),	iUidlKey(_FOFF(TMsgUidlStore,iMsvId),ECmpTUint),

		iRemoteServerEntry(aRemoteServerEntry),iPopSession(aPopSession),iFs(anFs)

	{

	__DECLARE_NAME(_S("CImPop3RefreshOperation"));

	}

CImPop3RefreshOperation* CImPop3RefreshOperation::NewL(CMsvServerEntry& aRemoteServerEntry, CImPop3Session* aPopSession, RFs& anFs)

	{

	CImPop3RefreshOperation* self = new (ELeave) CImPop3RefreshOperation( aRemoteServerEntry, aPopSession, anFs);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

void CImPop3RefreshOperation::ConstructL()

	{

	// store id of remote collection

	iRemoteId=iRemoteServerEntry.Entry().Id();

	iRecvConverter=CImRecvConvert::NewL( iFs, &iRemoteServerEntry, KUidMsgTypePOP3, iRemoteId);

	iRecvConverter->SetCaf(*iPopSession->GetCafL(iFs));

	iPopTop=CImPop3Top::NewL(iPopSession,iRecvConverter);

	iPopRetr=CImPop3Retr::NewL(iPopSession,iRecvConverter, iFs);

	iUidlArray = new(ELeave) CArrayFixSeg<TMsgUidlStore>(8);

	iMsvSelection = new (ELeave) CMsvEntrySelection;

	iUnwantedEntries = new (ELeave) CMsvEntrySelection;

	// store id of remote collection

	// set recv conv. 

	iRecvConverter->SetMsvId(iRemoteId);

	CActiveScheduler::Add(this);	  // Add CImPop3RefreshOperation to scheduler's queue

	iCurrentDrive = MessageServer::CurrentDriveL(iFs);

	}

CImPop3RefreshOperation::~CImPop3RefreshOperation()

	{

	Cancel();

	delete  iMsvSelection;

	// delete everything here

	delete iPopStat;

	delete iPopList;

	delete iPopUidl;

  	delete iPopTop;

	delete iPopRetr;

	iUniqueUidlPosArray.Close();

	iTemporaryUidlPosArray.Close();

	if (iUidlArray)

		{

		for (TInt ii=iUidlArray->Count();--ii>=0;)

			DeleteUidl(ii);

		delete iUidlArray;

		}

	delete iPop3Uidls;

	delete [] iSize;

	delete iRecvConverter;

	delete iUnwantedEntries;

	delete iMessagesToKeep;

	}

//

// Cancel any current operation

//

void CImPop3RefreshOperation::DoCancel()

	{

	iPopSession->SetOpNotPending();

	switch(iState)

		{

		case EPopRefreshStat:

			if(iPopStat)

				{

				iPopStat->Cancel();

				}

			break;

		case EPopRefreshList:

			if(iPopList)

				{

				iPopList->Cancel();

				}

			break;

		case EPopRefreshUidl:

			if(iPopUidl)

				{

				iPopUidl->Cancel();

				}

			break;

		case EPopRefreshGetHeader:

			if(iPopTop)

				{

				iPopTop->Cancel();

				}

			if(iPopRetr)

				{

				iPopRetr->Cancel();

				}

			break;

		default:	// do nothing for all other states

				break;

		}

	CMsgActive::DoCancel();

	}

//

// what to do on completion

//

void CImPop3RefreshOperation::DoComplete(TInt& aCompleteStatus)

	{

	// if we had empty headers report back to user with error code

	switch (iState)

		{

	case EPopRefreshComplete:

		break;

	case EPopRefreshGetHeader:

		if (aCompleteStatus!=KErrNone)

			{// If there is no memory to download further, complete

			 // the operation without calling MessageCompleteL.

			 if(aCompleteStatus == KErrNoMemory)

				{

				break;

				}

			// try and remember what we've done, at least

			TRAPD(ignore,iRecvConverter->MessageCompleteL());

			TRAP(ignore,RefreshFinishedL());

			}

		break;

	default:

		break;

		}

	}

//

// Start me up

//

void CImPop3RefreshOperation::Start(TRequestStatus& aStatus, CArrayFixFlat<TMsvId>* aMsgIdArray)

	{	

	Queue(aStatus);

	iCheckDiskSpaceCounter = 0;

	iNewMsg=aMsgIdArray; // take ownership of the message id array

	TRAPD(stateErr,ChangeStateL(EPopRefreshSyncCollection));

	if(stateErr!=KErrNone)

		{

		Complete(stateErr);

		}

	}

//

// Start me up and skip UIDL downloading

// (BFSW1-2016)

void CImPop3RefreshOperation::Start(TRequestStatus& aStatus)

	{

	Queue(aStatus);

	__ASSERT_ALWAYS(iNewMsg,Panic(ETopStartBeforeUidlStart));

	iCheckDiskSpaceCounter = 0;

	if (iUidlArray) 

		{ // Delete unreliable UIDL list (BFSW1-2016)

		for (TInt ii=iUidlArray->Count();--ii>=0;)

			DeleteUidl(ii);

		}

	TRAPD(stateErr,ChangeStateL(EPopRefreshGetHeader));

	if(stateErr!=KErrNone)

		{

		Complete(stateErr);	

		}

	}

// ****************************************************************************************** 

// Resume function called by the POP Client MTM, once it has completed Migrating to new bearer

// 

// ******************************************************************************************	

void CImPop3RefreshOperation::ResumeL(CImPop3Session* aPopSession, TRequestStatus& aStatus)

	{

	iMigratingToNewBearer = EFalse;

	iPopSession = aPopSession;

	delete iRecvConverter;

	iRecvConverter = NULL;

	iRecvConverter=CImRecvConvert::NewL( iFs, &iRemoteServerEntry, KUidMsgTypePOP3, iRemoteId);

	iRecvConverter->SetCaf(*iPopSession->GetCafL(iFs));

	delete iPopTop;

	iPopTop = NULL;

	iPopTop=CImPop3Top::NewL(iPopSession,iRecvConverter);

	delete iPopRetr;

	iPopRetr = NULL;

	iPopRetr=CImPop3Retr::NewL(iPopSession,iRecvConverter, iFs);

	iRecvConverter->SetMsvId(iRemoteId);

	Queue(aStatus);

	iCheckDiskSpaceCounter = 0;

	TRAPD(stateErr,ChangeStateL(iState));

	if(stateErr!=KErrNone)

		{

		Complete(stateErr);

		}

	}	

//

// Result of last active call

//

void CImPop3RefreshOperation::DoRunL()

    {

	switch(iState)

	{

	case EPopRefreshSyncCollection:

		if(iRemoteArrayCtr>0)

			{

			SyncCollectionL();

			QueueRemoteUpdate();

			}

		else

			{

			CompleteSyncCollection();

			if (iMigratingToNewBearer)

				{

				ChangeStateForMigrate(EPopRefreshStat);

				return;

				}

			else

				{

				ChangeStateL(EPopRefreshStat);

				}

			}

		break;

	case EPopRefreshStat:

		// initialise progress object

		iProgress.iMsgsToProcess=iNoMessages;

		iProgress.iTotalMsgs=iNoMessages;

		User::LeaveIfError(iRemoteServerEntry.SetEntry(iRemoteId));

		iEntry = iRemoteServerEntry.Entry();

		iEntry.SetMtmData3(iNoMessages);

		User::LeaveIfError(iRemoteServerEntry.ChangeEntry(iEntry));

		delete iPopStat;

		iPopStat=NULL;