// 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 <imcvrecv.h>
#include <logwrap.h>
#include <logwraplimits.h>

#include <bautils.h>
#include <msvutils.h>
#include <imcvutil.h>

#include <imcm.rsg>

#include "PopsTopPop.h"
#include "POPS.H"
#include "POPSOP.H" //CImPop3Operations
#include "POPSMBX.H"

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

#include "mobilitytestmtmapi.h"

// IMRC Panic function
GLREF_C void Panic(TPopsPanic aPanic);

CImPop3TopPopulate* CImPop3TopPopulate::NewL(const CMsvEntrySelection& aRemoteEntry, CMsvServerEntry& aLocalEntry, TInt aLimit, CImPop3Session* aPop3Session, RFs& anFs, CImLogMessage* aLogMessage, TBool aDisconnectedMode, RArray<TUint>& aRemoteSizes)
	{
	CImPop3TopPopulate* self = new (ELeave) CImPop3TopPopulate( aLocalEntry, aLimit, aPop3Session, anFs, aLogMessage, aDisconnectedMode, aRemoteSizes);

	CleanupStack::PushL(self);
	self->ConstructL(aRemoteEntry);
	CleanupStack::Pop(self);
	return self;
	}

CImPop3TopPopulate::~CImPop3TopPopulate()
	{
	iRemoteSizes.Close();
	delete iTop;
	delete iSource;
	delete iRecvConverter;
	}

void CImPop3TopPopulate::StartL(TRequestStatus& aStatus)
	{
	iMsgCtr=0;
	iSavedError = KErrNone;
	// set up progress obj.
	iProgress.iTotalMsgs=iSource->Count();
	iProgress.iMsgsToProcess=iProgress.iTotalMsgs;
	
	// Do a quick tally on the size of messages which are to be copied / moved.
	iProgress.iTotalSize = 0;
	for(TInt i = 0; i < iProgress.iTotalMsgs; ++i)
		{
		iDestination.SetEntry(iSource->At(i));
		if(!iDestination.Entry().Complete())
			{
			iProgress.iTotalSize += iRemoteSizes[i];
			}
		}
	

	if(iProgress.iTotalMsgs>0)
		{
		delete iTop;
		iTop=NULL;
		iTop=CImPop3Top::NewL(iPopSession,iRecvConverter,EFalse);
		DoRetrieveL();
		Queue(aStatus);
		}
	else
		{
		aStatus = KRequestPending;
		TRequestStatus* pS=&aStatus;
		User::RequestComplete(pS,KErrNone);
		}
	}

// ****************************************************************************************** 
// Resume function called by the POP Server MTM, once it has completed Migrating to new bearer
// 
// ******************************************************************************************	
void CImPop3TopPopulate::ResumeL(CImPop3Session* aPopSession, TRequestStatus& aStatus)
	{
	iMigratingToNewBearer = EFalse;
	iPopSession = aPopSession;

	delete iRecvConverter;
	iRecvConverter = NULL;
	iRecvConverter = CImRecvConvert::NewL( iFs, &iDestination, KUidMsgTypePOP3, iServiceId);
	iRecvConverter->SetCaf(*iPopSession->GetCafL(iFs));
	
	delete iTop;
	iTop=NULL;
	iTop=CImPop3Top::NewL(iPopSession,iRecvConverter,EFalse);
	
	// Set the MIME parser to point at the first message to be processed.
	iRecvConverter->SetMsvId((*iSource)[iMsgCtr]);
		
	DoRetrieveL();
	Queue(aStatus);
	}	

TPop3Progress CImPop3TopPopulate::Progress()
	{
	if(iPopTopPopState==EPopTopPopRetrieving)
		{
		// Get the Copy/Move Progress
		iProgress.iBytesDone=iTop->Progress();
		}
	else if (iPopTopPopState == EPopTopPopLogging)
		{
		// We are doing Logging so the move/copy is complete
		iProgress.iBytesDone = iProgress.iTotalBytes;
		}
	else
		{
		iProgress.iBytesDone=0;
		iProgress.iTotalBytes=0;
		}
	return iProgress;
	}

CImPop3TopPopulate::CImPop3TopPopulate(CMsvServerEntry& aLocalEntry, TInt aLimit, CImPop3Session* aPop3Session, RFs& anFs, CImLogMessage* aLogMessage, TBool aDisconnectedMode, RArray<TUint>& aRemoteSizes)
	: CMsgActive( KMsgPop3RefreshMailboxPriority ), iDestination(aLocalEntry), iPopSession(aPop3Session),iFs(anFs), iLogMessage(aLogMessage), iDisconnectedMode(aDisconnectedMode), iTopLimit(aLimit), iRemoteSizes(aRemoteSizes)
	{
	}

void CImPop3TopPopulate::ConstructL( const CMsvEntrySelection& aRemoteSelection)
	{
	// make our copy of aRemoteEntry
	iSource = aRemoteSelection.CopyL();
	iServiceId = iDestination.Entry().Id();

	// assume Entry passed in is set to service id (IMCV needs to set new entries to this)
	iRecvConverter = CImRecvConvert::NewL( iFs, &iDestination, KUidMsgTypePOP3, iServiceId);
	iRecvConverter->SetCaf(*iPopSession->GetCafL(iFs));
	iPopTopPopState=EPopTopPopRetrieving;
	iProcessComplete=EFalse;

	// set recv conv. 
	if (iSource->Count())
		{
		// Set the MIME parser to point at the first message to be populated.
		iRecvConverter->SetMsvId((*iSource)[0]);
		}	
	CActiveScheduler::Add(this);	  // Add CImPop3CopyMove to scheduler's queue
	}

void CImPop3TopPopulate::DoRetrieveL()
	{
	iAlreadyComplete = EFalse;
	iMessageMarkedForDelete = EFalse;
	TRequestStatus* pS = &iStatus;
	TMsvId msgId=(*iSource)[iMsgCtr];
	// iDestination will later be changed back to the destination entry, if required
	TInt err = iDestination.SetEntry(msgId);
	TMsvEmailEntry entry = iDestination.Entry();
	if(err != KErrNone)
        {
		SetActive();
		User::RequestComplete(pS,err);
        }
	else if (entry.Operation() && (entry.DisconnectedOperation() == EDisconnectedDeleteOperation))
		{
		iMessageMarkedForDelete = ETrue;
		SetActive();
		User::RequestComplete(pS, KErrNone);
		}
	else if ((entry.Complete()))
		{
		iAlreadyComplete = ETrue;
		SetActive();
		User::RequestComplete(pS, KErrNone);
		}
	else
		{
		iProgress.iTotalBytes = iRemoteSizes[iMsgCtr];
		// reset entry to destination context if the current entry is not meant to be populated
		User::LeaveIfError(iDestination.SetEntry(iDestId));
		iRetrieveMessage = ETrue;

		//If the message is not found complete the request.
		if (!iTop->SetMessageAndLines(msgId,iTopLimit)) 
			{
			iAlreadyComplete = ETrue;
			SetActive();
			User::RequestComplete(pS, KErrNone);
			}
		else
			{
			iCurrentMsgSize = iRemoteSizes[iMsgCtr];
			iTop->StartL(iStatus);
			SetActive();
			MOBILITY_TEST_MTM_STATE(iServiceId, KMobilityTestMtmStatePopRetrieving);
			}
		}
	}

void CImPop3TopPopulate::RetrievalCompleteL()
	{
	iProcessComplete=ETrue;
	}

void CImPop3TopPopulate::DoRunL()
	{
	// If we have already have an error then we have just been logging the failure.
	// The failure has been logged so we can leave now.
	User::LeaveIfError(iSavedError);

	// There was no error so handle the completion of either the logging or the retrieve operations.
	TRAP(iSavedError, RunLProcessingL());

	if (iSavedError != KErrNone)
		// If an error has occured then we need to clean up the message and log the failure before bailing out.
		{
		if(iRetrieveMessage)
			{
			if ((!iAlreadyComplete) && (!iMessageMarkedForDelete))
				{
				TRAPD(err,iRecvConverter->MessageCompleteL());

	 			if(err != KErrNone)
					{
					// something is wrong with the message delete and report back
					err = iDestination.SetEntry(iDestId);
					if (err == KErrNone)
						{
						err = iDestination.DeleteEntry(iTop->EntryId());
						}
					}
				}
			}

		// The message is logged as 'failed' if iSavedError is not KErrNone.
		LogFetchedMessageL();
		}
	}

void CImPop3TopPopulate::DoComplete(TInt& /*aCompleteStatus*/)
	{
	}

void CImPop3TopPopulate::DoCancel()
	{
	iPopSession->SetOpNotPending();

	if(iPopTopPopState==EPopTopPopRetrieving)
		{
		iTop->Cancel();
		}

	CMsgActive::DoCancel();
	}

void CImPop3TopPopulate::RunLProcessingL()
	{
	switch (iPopTopPopState)
		{
		case EPopTopPopRetrieving:
			{
		    TInt amountLeft = 0;
			if(iRetrieveMessage)
				{
				TBool partial=ETrue;
				if (iTop->Progress()>=TUint(iCurrentMsgSize))
					{
					partial=EFalse;
					}
				
				if ((!iAlreadyComplete) && (!iMessageMarkedForDelete))
					{
					iRecvConverter->MessageCompleteL(partial);
					}
				amountLeft=(iCurrentMsgSize)-iTop->Progress()+iRecvConverter->DeletedAttachmentSize();
				if (amountLeft<0)
					{
					amountLeft=0;
					}

				TMsvId msgId=(*iSource)[iMsgCtr];
				if(iDestination.SetEntry(msgId)==KErrNone)
					{
					TMsvEmailEntry header=iDestination.Entry();
					TBool changed=EFalse;
					if((header.Unread()))
						{
						header.SetNew(EFalse);
						changed=ETrue;
						}

					if(partial!=EFalse)
						{
						// We have used TOP so the entry will be partial, unless we have got the whole thing.
						header.SetPartialDownloaded(partial);
						changed=ETrue;
						}

					if(changed != EFalse)
						{
						User::LeaveIfError(iDestination.ChangeEntry(header));
						}						
					if(iDestination.SetEntry(iDestId)!=KErrNone)						
					{
					User::Leave(KPop3ProblemWithRemotePopServer);
					}
					}

				}

			iRecvConverter->WritePartialFooterL(amountLeft);

			iDestination.SetEntry(iDestId);	// make sure not trying to delete current context
			LogFetchedMessageL();
			}
			break;
		case EPopTopPopLogging:
			// If the message has been logged then move on and download the next one.
			{
			--iProgress.iMsgsToProcess;
			if(++iMsgCtr<iSource->Count())
				{
				// If we are migrating halt the operation here
				if (iMigratingToNewBearer)
					{			
					// If we don't SetActive, the RunL will complete the request
					return;
					}
				else
					{
 					iRecvConverter->ResetL();
					iRecvConverter->SetMsvId((*iSource)[iMsgCtr]);
					DoRetrieveL(); //add it to the collection;
					iPopTopPopState = EPopTopPopRetrieving;
					}
				}
			}
			break;
		default:
			break;
		}
	}

//
// Helper function to set up the iLogEntry object which is invoked after the copy/move.
//
void CImPop3TopPopulate::LogFetchedMessageL()
	{
	iPopTopPopState = EPopTopPopLogging;
	if (iLogMessage)
		{
// Get the header information for the message that is to be copied or moved.
		User::LeaveIfError(iDestination.SetEntry((*iSource)[iMsgCtr]));

		// Get the 'Fetch' string from the logging string table.
		TBuf<KLogMaxSharedStringLength> fetchString;
		iLogMessage->GetString(fetchString, R_LOG_DIR_FETCHED);

// Set up the log event.
		iLogMessage->LogEvent().SetEventType(KLogMailEventTypeUid);

		iLogMessage->LogEvent().SetDirection(fetchString);
		iLogMessage->LogEvent().SetRemoteParty(iDestination.Entry().iDetails);
		iLogMessage->LogEvent().SetSubject(iDestination.Entry().iDescription);
		iLogMessage->LogEvent().SetLink(iDestId);

		if (iSavedError != KErrNone)
			{
			TBuf<KLogMaxSharedStringLength> failedString;
			iLogMessage->GetString(failedString, R_LOG_DEL_FAILED);
			iLogMessage->LogEvent().SetStatus(failedString);
			}

// Run the iLogMessage operation.
		iLogMessage->Start(iDestination.Entry().iError, iStatus);
		SetActive();
		}
	else
		{
		TRequestStatus* status = &iStatus;
		SetActive();
		User::RequestComplete(status, KErrNone);
		}
	}

 
// ****************************************************************************************** 
// This is called by the POP Server MTM when it starts Migrating Bearer
// 
// ******************************************************************************************
void CImPop3TopPopulate::Pause()
	{
	// Set the Migration flag
	iMigratingToNewBearer = ETrue;
	}

// ****************************************************************************************** 
// This is called by the POP Server MTM when it starts Migrating Bearer
// 
// ******************************************************************************************	
void CImPop3TopPopulate::CancelAllowResume()
	{
	iMigratingToNewBearer = ETrue;
	
	// Cancel the copying of the current message  and decrement counters 
	// so we can restart from this message onwards when we have migrated.
	// Use the normal cancel, as we really need to cancel here.
	Cancel();		
	}