// Copyright (c) 1998-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 "impspan.h"

#include "impsmtm.h"

#include <msventry.h>

#include <imapset.h>

#include <miutset.h>

#include <offop.h>

#include <msvreg.h>

#include <imapcmds.h>

#include <logwrap.h>

#include <imcvutil.h>

#include <cemailaccounts.h>

#include "imapsess.h"

#include "fldsync.h"

#include "imapsync.h"

#include "imapcomp.h"

#include "imapoffl.h"

#include "impsutil.h"

#ifdef _DEBUG

#define LOG_COMMANDS(a) iPrimarySession->iSession->LogText a

#define DBG(a) a

#define PRINTING

#else

#define LOG_COMMANDS(a)

#define DBG(a)

#undef PRINTING

#endif

// Type of MTM request: used only in this file

enum

	{

	EMtmCopyToLocal=1,

	EMtmMoveToLocal,

	EMtmCopyFromLocal,

	EMtmMoveFromLocal,

	EMtmCopyWithinService,

	EMtmMoveWithinService,

	EMtmPopulate

	};

// Code for the active wrapper

CActiveWrapper* CActiveWrapper::NewL(TInt aID)

	{

	CActiveWrapper* self=new(ELeave)CActiveWrapper(aID);

	CleanupStack::PushL(self);

	self->ConstructL();

	CActiveScheduler::Add( self );

	CleanupStack::Pop();

	return self;

	}

CActiveWrapper::CActiveWrapper(TInt aID) : CActive(0), iID(aID)

	{

	}

void CActiveWrapper::ConstructL()

	{

	// The object is a session

	iSession=CImImap4Session::NewL(iID, *this);

	// Get a compound operation

	iCompound=CImImap4Compound::NewL(iSession);

	// If we're the primary session, we get a fullsync object too

	if (iID==1)

		iFullSync=CImImap4Synchronise::NewL(iSession);

	}

void CActiveWrapper::StartL(MActiveWrapperObserver* aManager)

	{

	DBG((iSession->LogText(_L8("CActiveWrapper::StartL(ID=%d)"),iID)));

	// The request has already been issued with our iStatus, so here all we

	// do is note down the completion information and do a SetActive()

	iParentPtr=aManager;

	// Activate the observer as well, in case the request is cancelled.

	iParentPtr->Activate();

	SetActive();

	}

// Pointer to ActiveWrapper's iStatus, so direct commands to session (see above)

// use the correct iStatus.

TRequestStatus* CActiveWrapper::SessionStatus()

	{

	// Return the pointer

	return(&iStatus);

	}

// Set entry pointers for classes the wrapper owns

void CActiveWrapper::SetEntry(CMsvServerEntry* aEntry)

	{

	iSession->SetEntry(aEntry);

	iCompound->SetEntry(aEntry);

	if (iFullSync)

		iFullSync->SetEntry(aEntry);

	}

void CActiveWrapper::DoCancel()

	{

	DBG((iSession->LogText(_L8("CActiveWrapper::DoCancel(ID=%d)"),iID)));

	// Cancel anything we might have outstanding

	if (iFullSync)

		iFullSync->Cancel();

	iCompound->Cancel();

	if( !iSession->IsCancelling())

		{

		// Can only cancel the session if we're not waiting for a cancelled fetch

		// to complete.

		iSession->Cancel();	

		}

	// Tell parent we've completed: DON'T complete it ourselves.

	iParentPtr->RequestCompleted(iID,KErrCancel);

	}

#ifdef PRINTING

void CActiveWrapper::DoComplete(TInt aStatus)

#else

void CActiveWrapper::DoComplete(TInt /*aStatus*/)

#endif

	{

	DBG((iSession->LogText(_L8("CActiveWrapper::DoComplete(%d, id=%d)"),aStatus,iID)));

	}

void CActiveWrapper::RunL()

	{

	// IMPORTANT: The contents of this CActiveWrapper::RunL() MUST NOT ever User::Leave()

	DBG((iSession->LogText(_L8("ActiveWrapper RunL(ID=%d, result=%d)"),iID,iStatus.Int())));

	TInt error=iStatus.Int();

	Cancel(); // Obvious to do it here

	iParentPtr->RequestCompleted(iID,error);

	}

CActiveWrapper::~CActiveWrapper()

	{

	Cancel();

	delete iSession;

	delete iCompound;

	delete iFullSync;

	}

void CActiveWrapper::NonCompletedFailure()

	{

	DBG((iSession->LogText(_L8("ActiveWrapper::NonCompletedFailure (%d)"), iID)));

	// A failure has occured on the session, but there is no outstanding asynchronous

	// request on it. This can happen if for instance we get a disconnect while doing

	// a cancel and idle operation. Pass the failure on to the parent.

	iParentPtr->NonCompletedFailureOnSession(iID);

	}

// Return of current imap session

CImImap4Session* CActiveWrapper::GetImap4Session()

	{

	return iSession;	

	}

// -----------------------------------------------------------------------

// The actual MTM

EXPORT_C CImap4ServerMtm* CImap4ServerMtm::NewL(CRegisteredMtmDll& aRegisteredMtmDll,CMsvServerEntry* aEntry)

	{

	CImap4ServerMtm* self=new CImap4ServerMtm(aRegisteredMtmDll,aEntry);

	if (self==NULL)

		{

		aRegisteredMtmDll.ReleaseLibrary();

		User::Leave(KErrNoMemory);

		}

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

void CImap4ServerMtm::ConstructL()

	{

	// Make an Imap4 session: make it under the activewrapper, so we can have

	// more than one at a time

	// The primary session is the one that does the full sync

	iPrimarySession=CActiveWrapper::NewL(1);

	// The secondary session is used if we get fetch requests while the

	// primary session is busy

	iSecondarySession=CActiveWrapper::NewL(2);

	// create an offline op controller

	iOffLineControl=CImap4OffLineControl::NewL(iServerEntry, iPrimarySession->iSession);

	// create the utils object

	iUtils = CImap4Utils::NewL(iServerEntry);

	// tell the FullSync session about them

	iPrimarySession->iFullSync->SetOffLineControl(iOffLineControl);

	iPrimarySession->iFullSync->SetUtils(iUtils);

	// Get an entry selection

	iSelection=new (ELeave) CMsvEntrySelection;

	// We're disconnected at first

	iLastSessionState=TImap4GenericProgress::EDisconnected;

	// We need to see invisible entries

	TMsvSelectionOrdering invisible;

	invisible=iServerEntry->Sort();

	invisible.SetShowInvisibleEntries(ETrue);

	iServerEntry->SetSort(invisible);

	// Tell sessions and foldersync about it

	iPrimarySession->SetEntry(iServerEntry);

	iSecondarySession->SetEntry(iServerEntry);

	}

// MTM destructor: clean up - this involves removing the sessions.

CImap4ServerMtm::~CImap4ServerMtm()

	{

	// We may still be active

	Cancel();

	// Ensure service is marked as offline (if the serviceid was initialised, anyway)

	if (iServiceId && iServiceSettings)

		{

		// Make stuff invisible as necessary

		TRAP_IGNORE(MarkOnOrOfflineL(EFalse));

		// Get rid of settings

		delete iServiceSettings;

		}

	// Clean up

	delete iSelection;

	delete iOneSelection;

	delete iPrimarySession;

	delete iSecondarySession;

	delete iOffLineControl;

	delete iUtils;

	}

// Do setentry, leave if there is an error

void CImap4ServerMtm::SetEntryL(const TMsvId aId)

	{

	User::LeaveIfError(iServerEntry->SetEntry(aId));

	}

// Change entry, leave if error

void CImap4ServerMtm::ChangeEntryL(const TMsvEntry& aEntry)

	{

	User::LeaveIfError(iServerEntry->ChangeEntry(aEntry));

	}

// Get children, leave if error

void CImap4ServerMtm::GetChildrenL(CMsvEntrySelection& aSelection)

	{

	User::LeaveIfError(iServerEntry->GetChildren(aSelection));

	}

// remove an id, leave if error, moves to the parent first

void CImap4ServerMtm::DeleteEntryL(TMsvId aId)

	{

	SetEntryL(aId);

	SetEntryL(iServerEntry->Entry().Parent());

	User::LeaveIfError(iServerEntry->DeleteEntry(aId));

	}

// Hierarchically make all folders visible/invisible: we go down until we can't

// find any more folders, so this won't affect messages with subfolders.

//

// We don't use the bulk functions as we don't want to affect messages in the

// folder, and we have to scan the entries to check for recursion anyway.

void CImap4ServerMtm::ChangeVisibilityL(TMsvId aParent, TBool aInvisible)

	{

	ChangeVisibilityL(aParent, aInvisible, ETrue, KUidMsvFolderEntry);

	}

void CImap4ServerMtm::ChangeVisibilityL(TMsvId aParent, TBool aInvisible, TBool aRecurse, TUid aType)

	{

	DBG((iPrimarySession->iSession->LogText(_L8("ChangeVisibilityL(%x, %d)"),aParent,aInvisible)));

	// Get children at this level

	CMsvEntrySelection* selection=new (ELeave) CMsvEntrySelection;

	CleanupStack::PushL(selection);

	CMsvEntrySelection* folders=new (ELeave) CMsvEntrySelection;

	CleanupStack::PushL(folders);

	SetEntryL(aParent);

	GetChildrenL(*selection);

	if (selection->Count())

		{

		DBG((iPrimarySession->iSession->LogText(_L8("  Found %d children"),selection->Count())));

		for(TInt child=0;child<selection->Count();child++)

			{

			// Move to this child

			SetEntryL((*selection)[child]);

			TMsvEntry message=iServerEntry->Entry();

			DBG((iPrimarySession->iSession->LogText(_L8("  type %x visible %d"),message.iType,message.Visible())));

			// Is this the type we want to change?

			if (message.iType==aType)

				{

				// Add to selection to do bulk change on, if necessary

				if ((message.Visible() && aInvisible) ||

					(!message.Visible() && !aInvisible))

					{

					DBG((iPrimarySession->iSession->LogText(_L8("  Adding %x to change list"),message.Id())));

					folders->AppendL(message.Id());

					}

				}

			// Recurse downwards

			if (aRecurse && message.iType==KUidMsvFolderEntry)

				ChangeVisibilityL(message.Id(),aInvisible,aRecurse,aType);

			}

		// Change its visibility off all children if necessary

		if (folders->Count())

			{

			// Do the change to the invisible flag (actual constant for the

			// flag we want is private :( )

			SetEntryL(aParent);

			User::LeaveIfError(iServerEntry->ChangeAttributes(*folders,

								aInvisible?0:KMsvVisibilityAttribute,

								aInvisible?KMsvVisibilityAttribute:0));

			}

		}

	// Release the service entry

	SetEntryL(KMsvNullIndexEntryId);

	// Get rid of selection

	CleanupStack::PopAndDestroy(2);

	}

void CImap4ServerMtm::ClearNewFlagL(TMsvId aParent)

	{

	// Get children at this level

	CMsvEntrySelection* selection=new (ELeave) CMsvEntrySelection;

	CleanupStack::PushL(selection);

	CMsvEntrySelection* msgs=new (ELeave) CMsvEntrySelection;

	CleanupStack::PushL(msgs);

	SetEntryL(aParent);

	GetChildrenL(*selection);

	// for each child

	TInt count=selection->Count();

	for(TInt child=0;child<count;child++)

		{

		SetEntryL((*selection)[child]);

		TMsvEntry entry=iServerEntry->Entry();

		if (entry.New()&& entry.iType==KUidMsvMessageEntry)

			msgs->AppendL(entry.Id());

		// if this is a folder then recurse

		if (entry.iType==KUidMsvFolderEntry)

			ClearNewFlagL((*selection)[child]);

		}

	if (msgs->Count())// change attribute only when it has finished looking at all the children

		{

		SetEntryL(aParent);

		User::LeaveIfError(iServerEntry->ChangeAttributes(*msgs,0,KMsvNewAttribute));

		iPrimarySession->iSession->LogText(_L8("number of new msgs = (%d)"),msgs->Count());

		}

	CleanupStack::PopAndDestroy(2); // selection,msgs

	}

// Mark service as on or offline

void CImap4ServerMtm::MarkOnOrOfflineL(const TBool aOnline)

	{

	// Mark service entry as on/offline	

	SetEntryL(iServiceId);

	TMsvEntry entry=iServerEntry->Entry();

	entry.SetConnected(aOnline);

	ChangeEntryL(entry);

	// Release the service entry

	SetEntryL(KMsvNullIndexEntryId);

	// Going offline?

	if (!aOnline && iServiceSettings->DisconnectedUserMode())

		{

		// We're an expert user going offline: don't touch anything

		return;

		}

	// Mark all immediate children of the service as invisible

	if (!aOnline)

		ChangeVisibilityL(iServiceId,!aOnline);

	}

// Do the misc bits we need to when we've gone offline

void CImap4ServerMtm::GoneOffline()

	{

	DBG((iPrimarySession->iSession->LogText(_L8("GoneOffline called"))));

	// Cancel sessions: parking might be dangerous otherwise

	iPrimarySession->Cancel();

	iSecondarySession->Cancel();

	// Park entries (in case a move entry has been left somewhere dangerous by a

	// leave)

	iPrimarySession->iSession->Park();

	iSecondarySession->iSession->Park();

	// Only do this is we have a valid service - we may not, due to being called

	// both by the state machine and the progress entry

	if (iServiceId)

		{

		// Offline, make folders invisible if we're not a disconnected mode user

		TRAP_IGNORE(MarkOnOrOfflineL(EFalse));

		// Clear serviceid, it's not valid anymore

		iServiceId=0;

		}

	// Settings can be dumped now

	delete iServiceSettings;

	iServiceSettings=NULL;

	// We can now be deleted

	iCanBeDeletedNow=ETrue;

	}

// Check selection: all entries should be of appropriate

// type. Messages in this context means complete messages, not RFC888

// parts of another message. parts means attachment or text

// bodies. Make a local copy of valid entries

TInt CImap4ServerMtm::CheckSelectionL(const CMsvEntrySelection& aSelection,

									  CMsvEntrySelection* aLocalCopy,

									  const TBool aMessages,

									  const TBool aParts,

									  const TBool aFolders,

									  const TBool aIsInService)

	{

	// Reset copy selection

	aLocalCopy->Reset();

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

				(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?

					// SJM: if offline iServiceId==0 so allow all

					if (!aIsInService || iServiceId==0 || iServerEntry->Entry().Id()==iServiceId)

						{

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

			gPanic(EInvalidMsvTypeToCommand);

#endif

		}

	// Anything to do?

	if (!aLocalCopy->Count())

		{

		// Nothing valid to work with

		User::RequestComplete(iRequest,KErrNotSupported);

		return(KErrNotSupported);

		}

	// All OK, the selection isn't empty

	return(KErrNone);

	}