// 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:
// IMAP4 folder list synchronise
// This class deals with keeping the local mirror folder tree in sync with the
// remote server's directory structure.
// 980914 - Modifications to local tree traverse so that it will not
// look for children below message level: previously, it was
// picking up attachment folders in messages!
// 990304 - Orphaned folder check no longer orphans the inbox: we
// basically never touch it. The problem with orphaning it
// comes about with servers which have a namespace (ie
// folder path) of INBOX, which means we never "see" the
// actual inbox as we are inside it. We still know it
// exists, though.
// 990502 - Was calling CMsgActive::Cancel() as opposed to DoCancel().
// 
//

#include <e32base.h>
#include <e32cons.h>
#include <mentact.h>
#include "fldsync.h"
#include "impspan.h"
#include "imapsess.h"

#ifdef _DEBUG
#define LOG_COMMANDS(a) a
#define DBG(a) a
#define PRINTING
#else
#define LOG_COMMANDS(a)
#define DBG(a)
#undef PRINTING
#endif

// Priority of MsgActive object
const TInt EFolderSyncPriority=1;


// Debugging of folder tree traversal
#undef DEBUG_FOLDERSYNC

CImImap4FolderSync::CImImap4FolderSync():CMsgActive(EFolderSyncPriority)
	{
	__DECLARE_NAME(_S("CImImap4FolderSync"));
	}

CImImap4FolderSync::~CImImap4FolderSync()
	{
	// Global bits
	delete iFolderContents;

	if (iFolderList)
		iFolderList->ResetAndDestroy();
	delete iFolderList;

	// Get rid of bits at each level
	for(TInt a=0;a<KFolderDepth;a++)
		delete iFolderIds[a];

	// Delete local folder list
	delete iLocalFolders;
	}

CImImap4FolderSync* CImImap4FolderSync::NewLC(CImImap4Session *aSession)
	{
	CImImap4FolderSync* self=new (ELeave) CImImap4FolderSync();
	CleanupStack::PushL(self);

	// Non-trivial constructor
	self->ConstructL(aSession);
	return self;
	}

CImImap4FolderSync* CImImap4FolderSync::NewL(CImImap4Session *aSession)
	{
	CImImap4FolderSync* self=NewLC(aSession);
	CleanupStack::Pop();
	return self;
	}

// The non-trivial constructor
void CImImap4FolderSync::ConstructL(CImImap4Session *aSession)
	{
	// Save session
	iSession=aSession;

	// We're an active object...
	CActiveScheduler::Add(this);

	// One-off bits
	iFolderList=new (ELeave) CArrayPtrFlat<CImImap4DirStruct>(8);
	iFolderContents=new (ELeave) CMsvEntrySelection;

	// ...and per-level bits
	for(TInt a=0;a<KFolderDepth;a++)
		iFolderIds[a]=new (ELeave) CArrayFixFlat<TMsvId>(8);

	// Local folder list
	iLocalFolders=new (ELeave) CArrayFixFlat<TMsvId>(16);
	}

// Do setentry, leave if there is an error
void CImImap4FolderSync::SetEntryL(const TMsvId aId)
	{
	User::LeaveIfError(iEntry->SetEntry(aId));
	}

// Change entry, leave if error
void CImImap4FolderSync::ChangeEntryL(const TMsvEntry& aEntry)
	{
	User::LeaveIfError(iEntry->ChangeEntry(aEntry));
	}

// Change entry in bulk mode (i.e. no index file commit), leave if error
void CImImap4FolderSync::ChangeEntryBulkL(const TMsvEntry& aEntry)
	{
	User::LeaveIfError(iEntry->ChangeEntryBulk(aEntry));
	}
// Get children, leave if error
void CImImap4FolderSync::GetChildrenL(CMsvEntrySelection& aSelection)
	{
	User::LeaveIfError(iEntry->GetChildren(aSelection));
	}

// Set the entry to use to talk to the server
void CImImap4FolderSync::SetEntry(CMsvServerEntry* aEntry)
	{
	// Save it
	iEntry=aEntry;
	}

// Build list of local folders
void CImImap4FolderSync::BuildLocalL(const TMsvId aFolder, const TBool aDoThisOne)
	{
	// Select it
	SetEntryL(aFolder);
	TMsvEmailEntry entry=iEntry->Entry();

	// If we're a folder, set the flag
	if (entry.iType==KUidMsvFolderEntry && aDoThisOne)
		{
		// Add to list
		iLocalFolders->AppendL(iEntry->Entry().Id());
		}

	// If current entry is a message, don't look for children
	if (entry.iType==KUidMsvMessageEntry)
		return;

	// Any children?
	CMsvEntrySelection *children=new (ELeave) CMsvEntrySelection;
	CleanupStack::PushL(children);
	GetChildrenL(*children);
	if (children->Count())
		{
		// Do each in turn
		for(TInt child=0;child<children->Count();child++)
			BuildLocalL((*children)[child],ETrue);
		}
	CleanupStack::PopAndDestroy();
	}

// Called when async child completes
void CImImap4FolderSync::DoRunL()
	{
	if (ProcessDirListL())
		{
		// Done whole list, check to see what has vanished on the
		// server with regard to what's in the mirror: basically,
		// see what's still flagged in the tree.
		OrphanedFolderCheckL();

		// All done!
		Complete(KErrNone);
		}
	else
		{
		// Otherwise, another command has been issued
		SetActive();
		}
	}

// Cancel this operation
void CImImap4FolderSync::DoCancel()
	{
	DBG((iSession->LogText(_L8("CImImap4FolderSync::DoCancel()"))));

	// Cancel any outstanding session operation
	iSession->Cancel();

	// ...and parent
	CMsgActive::DoCancel();
	}

// Check for orphaned folders
void CImImap4FolderSync::OrphanedFolderCheckL()
	{
	DBG((iSession->LogText(_L8("CImImap4FolderSync::OrphanedFolderCheckL()"))));

	// Set stats
	iOrphanedFolders=iLocalFolders->Count();

	// Selection for storing children
	CMsvEntrySelection *children=new CMsvEntrySelection;
	CleanupStack::PushL(children);

	// Any folders left in iLocalFolders are orphans
	for(TInt a=0;a<iLocalFolders->Count();a++)
		{
		// Go to this folder
		if (iEntry->SetEntry((*iLocalFolders)[a])!=KErrNone)
			{
			// Probably been removed already (nested?)
			continue;
			}
		TMsvEmailEntry entry=iEntry->Entry();

		// Is it the INBOX? If so, ignore it
		if (entry.Parent()==iServiceId &&
			entry.iDetails.CompareF(KIMAP_INBOX)==0)
			continue;

		// Check all the entries in the folder
		TInt subfolders=0;
		children->Reset();
		GetChildrenL(*children);
		if (children->Count())
			{
			// Check each message
			for(TInt a=0;a<children->Count();a++)
				{
				SetEntryL((*children)[a]);
				TMsvEmailEntry child=iEntry->Entry();
				if (child.iType==KUidMsvMessageEntry)
					{
					// Orphan this message: it may delete it, if there
					// are no downloaded bodyparts

					DBG((iSession->LogText(_L8("Orphaning message %x"),(*children)[a])));

					iSession->OrphanMessageL((*children)[a]);
					}
				else if (child.iType==KUidMsvFolderEntry)
					{
					// There's a subfolder
					subfolders++;
					}
				}
			}

		// Check number of children again: if all the orphaned children
		// have been deleted (ie, they had no downloaded body parts)
		// then we can delete the folder locally, otherwise we just have
		// to mark it as orphaned.
		SetEntryL((*iLocalFolders)[a]);
		GetChildrenL(*children);
		if ((children->Count() || subfolders>0) && !entry.Orphan())
			{

			DBG((iSession->LogText(_L8("Orphaning folder %x"),(*iLocalFolders)[a])));

			// Orphan folder
			TMsvEmailEntry message=iEntry->Entry();
			message.SetOrphan(ETrue);
			ChangeEntryL(message);
			}
		else
			{

			DBG((iSession->LogText(_L8("Deleting folder %x"),(*iLocalFolders)[a])));

			// Delete folder
			SetEntryL(iEntry->Entry().Parent());
			iEntry->DeleteEntry((*iLocalFolders)[a]);
			}
		}

	// Get rid of children list
	CleanupStack::PopAndDestroy();

	// Remove list
	iLocalFolders->Reset();

	DBG((iSession->LogText(_L8("CImImap4FolderSync::OrphanedFolderCheckL() done"))));
	}

// Process returned directory list
TBool CImImap4FolderSync::ProcessDirListL()
	{
	// We've got a list, and the mirror folder ID that the contents belong to:
	// process it, and mirror the folder structure

	// First, find the existing children of this folder from the message server
	SetEntryL(iFolderId);
	GetChildrenL(*iFolderContents);
	TInt noofchildren=iFolderContents->Count();

	// Number of items in reply from server
	TInt noofreplies=iFolderList->Count();

#ifdef DEBUG_FOLDERSYNC
	iSession->LogText(_L("Level %d: Server has %d entries, mirror has %d"),
					  iFolderLevel,noofreplies,noofchildren);
#endif

	// Empty the 'to do' array
	iFolderIds[iFolderLevel]->Reset();

	// ...for each entry in reply
	for(TInt replyentry=0;replyentry<noofreplies;replyentry++)
		{
		// Does this already exist?
		TInt a;
		TMsvId thisentry;
		for(a=0;a<noofchildren;a++)
			{
			// See if the details field matches the server folder name.
			// For the INBOX folder the match should be case insensitive, all other folders
			// we must perform a case sensitive match
			SetEntryL(thisentry=(*iFolderContents)[a]);
			TPtrC entryName = iEntry->Entry().iDetails;
			TPtrC svrFolderName = (*iFolderList)[replyentry]->Leafname();
			TBool foldersMatch = EFalse;
			if(svrFolderName.CompareF(KIMAP_INBOX)==0)
				{
				// Server folder is the INBOX
				foldersMatch = (entryName.CompareF(svrFolderName)==0);
				}
			else
				{
				// Server folder is not the INBOX
				foldersMatch = (entryName.Compare(svrFolderName)==0);
				}
				
			if (foldersMatch)
				{
				// Update mailbox flag as necessary, but NOT if it's the inbox, which is
				// *ALWAYS* a mailbox
				TMsvEmailEntry folder=iEntry->Entry();
				if ((*iFolderList)[replyentry]->iIsMailbox!=folder.Mailbox())
					{
					if (folder.Parent()!=iServiceId ||
					    folder.iDetails.CompareF(KIMAP_INBOX)!=0)
						{
						folder.SetMailbox((*iFolderList)[replyentry]->iIsMailbox);
						ChangeEntryBulkL(folder);
						}
					else
						{
						DBG((iSession->LogText(_L8("Skipping Mailbox flag twiddle for folder %x (=%d)"),
						  folder.Id(),(*iFolderList)[replyentry]->iIsMailbox)));
						}
					}

				// Exists: remove from local folders list
				for(TInt b=0;b<iLocalFolders->Count();b++)
					{
					// Found it?
					if ((*iLocalFolders)[b]==thisentry)
						{
						// Remove from list
						iLocalFolders->Delete(b,1);
						break;
						}
					}

				// Exit loop
				break;
				}
			}

		// Found a match?
		if (a==noofchildren)
			{
			// No, create it
			TMsvEmailEntry message;
			
			// All flags unset (urrgh!)
			message.SetMtmData1(0);
			message.SetMtmData2(0);
			message.SetMtmData3(0);

			message.iType=KUidMsvFolderEntry;
			message.iMtm=iEntry->Entry().iMtm;
			message.iServiceId=iServiceId;
			message.iSize=0;
			message.iDetails.Set((*iFolderList)[replyentry]->Leafname());
			message.SetValidUID(EFalse);
			message.SetComplete(ETrue);

			// Visibility
			if (iNewFoldersAreInvisible)
				message.SetVisible(EFalse);

			// Is a mailbox? (basically, is it selectable?).
			message.SetMailbox((*iFolderList)[replyentry]->iIsMailbox);

#ifdef DEBUG_FOLDERSYNC
			iSession->LogText(_L("Creating folder '%S'"),&message.iDetails);
#endif
			SetEntryL(iFolderId);
			User::LeaveIfError(iEntry->CreateEntryBulk(message));

			// Increment stats
			iNewFolders++;
			
			// Get the ID, incase we're going into this level
			thisentry=message.Id();
			}

		// Does this have children? (and are we at the end of our nesting levels?)
		if ((*iFolderList)[replyentry]->iIsFolder && iFolderLevel<(KFolderDepth-1))
			{
#ifdef DEBUG_FOLDERSYNC
			iSession->LogText(_L("Adding folder to todolist, level %d"),iFolderLevel);
#endif
			// Add it to the list to scan at this level
			iFolderIds[iFolderLevel]->AppendL(thisentry);
			}
		}

#ifdef DEBUG_FOLDERSYNC
	iSession->LogText(_L("Level %d: %d items in todolist"),iFolderLevel,iFolderIds[iFolderLevel]->Count());
#endif

	// Anything in our 'to do' queue?
	while(!iFolderIds[iFolderLevel]->Count())
		{
#ifdef DEBUG_FOLDERSYNC
		iSession->LogText(_L("Nothing to do at level %d"),iFolderLevel);
#endif
		// Nothing at this level: are we at the top?
		if (iFolderLevel==0)
			{
#ifdef DEBUG_FOLDERSYNC
			iSession->LogText(_L("At level 0: completing"));
#endif
			// All done!
			// Commit any outstanding bulk creates
			SetEntryL(iFolderId);
			iEntry->CompleteBulk();
			return(ETrue);
			}

#ifdef DEBUG_FOLDERSYNC
		iSession->LogText(_L("Going up a level"));
#endif
		// Not at the top: back up a level
		iFolderLevel--;
		}

	// Something to process: remove it from todo list
	iFolderId=(*iFolderIds[iFolderLevel])[0];
	iFolderIds[iFolderLevel]->Delete(0,1);

	// Nest & issue command
	iFolderLevel++;
	iSession->ListL(iStatus,iFolderId,iFolderList);

#ifdef DEBUG_FOLDERSYNC
	iSession->LogText(_L("Stuff to do at level %d - scanning dir %x"),iFolderLevel,iFolderId);
#endif
	return(EFalse);
	}

// Synchronise mirror tree with remote server
void CImImap4FolderSync::SynchroniseTreeL(TRequestStatus& aStatus, const TMsvId aService, const TBool aNewFoldersAreInvisible)
	{
	LOG_COMMANDS((iSession->LogText(_L8("COMMAND CImImap4FolderSync::SychroniseTree (serviceid=%x)"),aService)));

	Queue(aStatus);

	// Note where this list came from
	iServiceId=aService;
	iFolderId=iServiceId;
	iFolderLevel=0;

	// Save invisibility state
	iNewFoldersAreInvisible=aNewFoldersAreInvisible;

	// Set flags on all folders, so we can tell which ones aren't matched by the
	// list returned from the server.
	iLocalFolders->Reset();
	BuildLocalL(iServiceId,EFalse);

	// List this tree
	iSession->ListL(iStatus,iFolderId,iFolderList);
	SetActive();
	}

void CImImap4FolderSync::IncProgress(TImap4SyncProgress& aProgress)
	{
	aProgress.iNewFolders+=iNewFolders;
	aProgress.iOrphanedFolders+=iOrphanedFolders;
	}

void CImImap4FolderSync::ResetStats()
	{
	// initialise counts
	iNewFolders=0;
	iOrphanedFolders=0;
	}