// Copyright (c) 1999-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:

// CACHEMAN.CPP

//

#include "CACHEMAN.H"

#include "MIUTHDR.H"

#include <msvapi.h>

#include <msvuids.h>

#include <msvids.h>

#include <mmsvattachmentmanager.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <cimprunemessage.h>

#include "cimfinder.h"

#include "timrfc822datefield.h"

#include "msvconsts.h"

#endif

// The CImEntryStack implementation

CImFinder::CImEntryStack* CImFinder::CImEntryStack::NewL()

	{

	CImFinder::CImEntryStack* self;

	self = new (ELeave) CImFinder::CImEntryStack();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); // self

	return self;

	}

CImFinder::CImEntryStack::~CImEntryStack()

	{

	delete iFolders;

	}

void CImFinder::CImEntryStack::PushL(TMsvId aId)

	{

	iFolders->AppendL(aId);

	}

void CImFinder::CImEntryStack::Reset()

	{

	iFolders->Reset();

	}

TMsvId CImFinder::CImEntryStack::PopL()

	{

	TInt32 count = iFolders->Count();

	if (count == 0)

		{

		User::Leave(KErrOverflow);

		}

	TMsvId folderId = (*iFolders)[count - 1];

	iFolders->Delete(count-1);

	return folderId;

	}

void CImFinder::CImEntryStack::ConstructL()

	{

	iFolders = new (ELeave) CMsvEntrySelection;

	}

TBool CImFinder::CImEntryStack::Empty() const

	{

	return (iFolders->Count() == 0);

	}

// Implementation of abstract CImFinder class

EXPORT_C void CImFinder::FindFirstL(TMsvId aRootEntry, TRequestStatus &aStatus)

	{

	iEntryStack->Reset();

	iEntryStack->PushL(aRootEntry);

	ASSERT(iState != EImmfFindingEntry);

	FindNextL(aStatus);

	}

void CImFinder::FindFirstL(const CMsvEntrySelection& aInitialSelection, TRequestStatus &aStatus)

	{

	iEntryStack->Reset();

	TInt index = aInitialSelection.Count();

	while (index--)

		// Push each given entry on the stack so that we will visit it later.

		{

		iEntryStack->PushL(aInitialSelection[index]);

		}

	ASSERT(iState != EImmfFindingEntry);

	FindNextL(aStatus);

	}

EXPORT_C CImFinder::~CImFinder()

	{

	delete iEntryStack;

	}

void CImFinder::ConstructL()

	{

	iEntryStack = CImEntryStack::NewL();

	CActiveScheduler::Add(this);

	}

void CImFinder::DoRunL()

	{	

	if (iState == EImmfFindingEntry)

		{

		FindNextL(iStatus);

		}

	}

CImFinder::CImFinder(CMsvEntry& aEntry) : CMsgActive(EPriorityStandard), 	iCurrentEntry(aEntry)

	{

	}

EXPORT_C void CImFinder::FindNextL(TRequestStatus &aStatus)

	{

	TImmfState tempState = iState;

	if (!(iEntryStack->Empty()))

		// If there are entries on the stack then check them.

		{

		iCurrentEntry.SetEntryL(iEntryStack->PopL());

		TUid entryType = iCurrentEntry.Entry().iType;

		AddChildEntriesL();

		iStatus=KRequestPending;

		SetActive();

		TRequestStatus* status=&iStatus;

		User::RequestComplete(status, KErrNone);

		if (IsRequiredEntryType(entryType))

			// If the entry is of a required type then return it.

			{

			iState = EImmfEntryFound;

			}

		else

			// Otherwise keep looking for one.

			{

			iState = EImmfFindingEntry;

			}

		}

	else

		// If there is nothing on the stack then there are no more entries.

		{

		iStatus=KRequestPending;

		SetActive();

		TRequestStatus* status=&iStatus;

		User::RequestComplete(status, KErrNotFound);

		iState = EImmfNothingFound;

		}

	if (tempState != EImmfFindingEntry)

		{

		Queue(aStatus);

		}

	}

// Implementation of CImMessageFinder class

EXPORT_C CImMessageFinder* CImMessageFinder::NewL(CMsvEntry& aEntry)

	{

	CImMessageFinder* self = CImMessageFinder::NewLC(aEntry);

	CleanupStack::Pop(); // self

	return self;

	}

EXPORT_C CImMessageFinder* CImMessageFinder::NewLC(CMsvEntry& aEntry)

	{

	CImMessageFinder* self = new (ELeave) CImMessageFinder(aEntry);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CImMessageFinder::AddChildEntriesL()

	{

	if ((iCurrentEntry.Entry().iType == KUidMsvFolderEntry)

		|| (iCurrentEntry.Entry().iType == KUidMsvServiceEntry))

		{

		// Push the folders on to the entry stack

		TMsvSelectionOrdering ordering;

		ordering.SetShowInvisibleEntries(EFalse);

		iCurrentEntry.SetSortTypeL(ordering);

		CMsvEntrySelection* entrySelection = iCurrentEntry.ChildrenWithTypeL(KUidMsvFolderEntry);

		CleanupStack::PushL(entrySelection);

		TInt counter;

		TInt count = entrySelection->Count();

		for (counter = 0; counter < count; counter++)

			{

			iEntryStack->PushL((*entrySelection)[counter]);

			}

		CleanupStack::PopAndDestroy(); // entrySelection

		// Push the messages on to the entry stack

		entrySelection = iCurrentEntry.ChildrenWithTypeL(KUidMsvMessageEntry);

		CleanupStack::PushL(entrySelection);

		count = entrySelection->Count();

		for (counter = 0; counter < count; counter++)

			{

			iEntryStack->PushL((*entrySelection)[counter]);

			}

		CleanupStack::PopAndDestroy(); // entrySelection

		}

	}

TBool CImMessageFinder::IsRequiredEntryType(TUid aEntryType) const

	{

	if (aEntryType == KUidMsvMessageEntry)

		return ETrue;

	else

		return EFalse;

	}

CImMessageFinder::CImMessageFinder(CMsvEntry& aEntry) : CImFinder(aEntry)

	{

	}

// Implementation of CImMessageFinder class

EXPORT_C CImEntryFinder* CImEntryFinder::NewL(CMsvEntry& aEntry)

	{

	CImEntryFinder* self = CImEntryFinder::NewLC(aEntry);

	CleanupStack::Pop(); // self

	return self;

	}

EXPORT_C CImEntryFinder* CImEntryFinder::NewLC(CMsvEntry& aEntry)

	{

	CImEntryFinder* self = new (ELeave) CImEntryFinder(aEntry);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CImEntryFinder::AddChildEntriesL()

	{

	if (iCurrentEntry.Entry().Owner())

		{

		// Push the child entries on to the entry stack

		TMsvSelectionOrdering ordering;

		ordering.SetShowInvisibleEntries(ETrue);

		iCurrentEntry.SetSortTypeL(ordering);

		CMsvEntrySelection* entrySelection = iCurrentEntry.ChildrenL();

		CleanupStack::PushL(entrySelection);

		TInt counter;

		TInt count = entrySelection->Count();

		for (counter = 0; counter < count; counter++)

			{

			iEntryStack->PushL((*entrySelection)[counter]);

			}

		CleanupStack::PopAndDestroy(); // entrySelection		

		}

	}

TBool CImEntryFinder::IsRequiredEntryType(TUid /*aEntryType*/) const

// Always true because all entry types are needed.

	{

	return ETrue;

	}

CImEntryFinder::CImEntryFinder(CMsvEntry& aEntry) : CImFinder(aEntry)

	{

	}

// Implementation of CImMessage Finder

EXPORT_C CImMessageCounter* CImMessageCounter::NewL(CMsvEntry& aEntry)

	{

	CImMessageCounter* self = CImMessageCounter::NewLC(aEntry);

	CleanupStack::Pop(); // self

	return self;

	}

EXPORT_C CImMessageCounter* CImMessageCounter::NewLC(CMsvEntry& aEntry)

	{

	CImMessageCounter* self = new (ELeave) CImMessageCounter(aEntry);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

EXPORT_C TInt CImMessageCounter::Count()

	{

	return iCount;

	}

void CImMessageCounter::AddChildEntriesL()

	{

	if ((iCurrentEntry.Entry().iType == KUidMsvFolderEntry)

		|| (iCurrentEntry.Entry().iType == KUidMsvServiceEntry))

		{

		// Push the folders on to the entry stack

		TMsvSelectionOrdering ordering;

		ordering.SetShowInvisibleEntries(EFalse);

		iCurrentEntry.SetSortTypeL(ordering);

		CMsvEntrySelection* entrySelection = iCurrentEntry.ChildrenWithTypeL(KUidMsvFolderEntry);

		CleanupStack::PushL(entrySelection);

		TInt counter;

		TInt count = entrySelection->Count();

		for (counter = 0; counter < count; counter++)

			{

			iEntryStack->PushL((*entrySelection)[counter]);

			}

		CleanupStack::PopAndDestroy(); // entrySelection

		// Count the messages in the folder

		entrySelection = iCurrentEntry.ChildrenWithTypeL(KUidMsvMessageEntry);

		CleanupStack::PushL(entrySelection);

		iCount += entrySelection->Count();

		CleanupStack::PopAndDestroy(); // entrySelection

		}

	else if (iCurrentEntry.Entry().iType == KUidMsvMessageEntry)

		{ // count itself if it's a message entry

		iCount++;

		}

	}

TBool CImMessageCounter::IsRequiredEntryType(TUid) const

	{

	// The message counter doesn't require any entry types to be returned.

	return EFalse;

	}

CImMessageCounter::CImMessageCounter(CMsvEntry& aEntry) : CImFinder(aEntry)

	{

	}

// Implementation of CImPruneMessage

EXPORT_C CImPruneMessage* CImPruneMessage::NewL(CMsvEntry& aEntry, RFs& aFs)

/** Allocates and constructs a new CImPruneMessage object.

@param aEntry CMsvEntry for use by the object in performing the delete operations. 

It does not need to be set to any particular message context. The caller retains 

ownership.

@param aFs Open file server session handle

@return New CImPruneMessage object */

	{

	CImPruneMessage* self = CImPruneMessage::NewLC(aEntry, aFs);

	CleanupStack::Pop(); // self

	return self;

	}

EXPORT_C CImPruneMessage* CImPruneMessage::NewLC(CMsvEntry& aEntry, RFs& aFs)

/** Allocates and constructs a new CImPruneMessage object, leaving the object on 

the cleanup stack.

@param aEntry CMsvEntry for use by the object in performing the delete operations. 

It does not need to be set to any particular message context. The caller retains 

ownership.

@param aFs Open file server session handle

@return New CImPruneMessage object */

	{

	CImPruneMessage* self = new (ELeave) CImPruneMessage(aEntry, aFs);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

EXPORT_C void CImPruneMessage::StartL(TMsvId aMessageEntry, TRequestStatus &aStatus)

/** Starts the asynchronous message clean operation.

@param aMessageEntry The ID of the entry from which to delete the body text 

and attachment data

@param aStatus Asynchronous status word that completes with KErrNone when the 

body text and all of the attachments have been deleted. */

	{

	iCurrentEntry.SetEntryL(aMessageEntry);

	TMsvEmailEntry entry(iCurrentEntry.Entry());

	if (entry.Complete() || entry.BodyTextComplete())

		{

		entry.SetComplete(EFalse);

		entry.SetBodyTextComplete(EFalse);

		iChangeOperation = iCurrentEntry.ChangeL(entry, iStatus);

		SetActive();

		}

	else

		{

		iStatus=KRequestPending;

		SetActive();

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, KErrNone);

		}

	iState = EImPruneUpdatingFirstEntry;

	Queue(aStatus);

	iRootEntryId = aMessageEntry;

	}

CImPruneMessage::~CImPruneMessage()

/** Destructor. */

	{

	Cancel();

	delete iEntryFinder;

	delete iFileManager;

	delete iStore;

	delete iChangeOperation;	

	}

void CImPruneMessage::ConstructL()

	{

	CActiveScheduler::Add(this);

	iEntryFinder = CImEntryFinder::NewL(iCurrentEntry);

	iFileManager = CFileMan::NewL(iFs);

	}

void CImPruneMessage::DoRunL()

	{

	TInt error = KErrNone;

	switch (iState)

		{

		case EImPruneUpdatingFirstEntry:

			delete iChangeOperation;

			iChangeOperation = 0;

			PruneEntryL();

			iState = EImPruneFindFirstEntry;			

			SetActive();

			break;

		case EImPruneFindFirstEntry:

			ResetStoreL();

			iEntryFinder->FindFirstL(iRootEntryId, iStatus);

			iState = EImPruneFindingEntry;

			SetActive();

			break;

		case EImPruneUpdatingEntry:

			delete iChangeOperation;

			iChangeOperation = 0;

			PruneEntryL();

			iState = EImPruneFindNextEntry;

			SetActive();

			break;

		case EImPruneFindNextEntry:

			ResetStoreL();

			iEntryFinder->FindNextL(iStatus);

			iState = EImPruneFindingEntry;

			SetActive();

			break;

		case EImPruneFindingEntry:

			delete iStore;

			iStore = NULL;

			if (iStatus == KErrNone)

				// An entry has been found, so prune it.

				{

				// Ignore any error as it probably just means that the entry is locked.

				// We can afford to skip locked entries.

				if (iCurrentEntry.Entry().Complete())

					{

					TMsvEntry entry = iCurrentEntry.Entry();

					entry.SetComplete(EFalse);

					TRAPD(ignore, iChangeOperation = iCurrentEntry.ChangeL(entry, iStatus));

					}

				if (!iChangeOperation)

					{

					TRequestStatus* status = &iStatus;

					iStatus=KRequestPending;

					User::RequestComplete(status, KErrNone);	

					}

				iState = EImPruneUpdatingEntry;

				SetActive();

				}

			break;

		}

	}

void CImPruneMessage::DoComplete(TInt& status)

	{

	if ((iState == EImPruneFindingEntry) && (status == KErrNotFound))

	// The not found status is expected, it just means that the entry finder has already found all the entries.

		{

		status = KErrNone;

		}

	}

void CImPruneMessage::DoCancel()

	{

	iEntryFinder->Cancel();

	if (iChangeOperation)

		iChangeOperation->Cancel();

	CMsgActive::DoCancel();

	}

CImPruneMessage::CImPruneMessage(CMsvEntry& aEntry, RFs& aFs) 

	: CMsgActive(EPriorityStandard), 

	iCurrentEntry(aEntry), 

	iFs(aFs)

	{

	__DECLARE_NAME(_S("CImPruneMessage"));

	}

void CImPruneMessage::PruneEntryL()

	{

	// delete the rich text stream

	iStore = iCurrentEntry.EditStoreL();

	if (iStore->IsPresentL(KMsvEntryRichTextBody))

		{	

		iStore->DeleteBodyTextL();

		iStore->CommitL();

		}

	// If the entry has an attachment we need to remove it.

	// In order to preserve the message structure, we won't delete the attachment

	// completely, but instead we will set the file size to 0 and mark the attachment

	// as not complete.