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

#include "MSVIDS.H"

#include "MSVDELET.H"

#include "MSVSERV.H"

#include "MSVPANIC.H"

#include "MSVUTILS.H"

#include "msvindexadapter.h"

#include "msventryfreepool.h"

// static

CMsvDelete* CMsvDelete::NewL(CMsvServer& aServer)

//

//

//

	{

	CMsvDelete* self = new(ELeave) CMsvDelete(aServer);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CMsvDelete::CMsvDelete(CMsvServer& aServer)

: CActive(EPriorityStandard), iServer(aServer), iLockedIndex(-2)

//

//

//

	{

	}

void CMsvDelete::ConstructL()

//

//

//

	{

	iFileMan = CFileMan::NewL(iServer.FileSession());

	iDescendents = new(ELeave)CMsvEntrySelection;

	CActiveScheduler::Add(this);

	}

CMsvDelete::~CMsvDelete()

//

//

//

	{

	Cancel();

	delete iDescendents;

	delete iFileMan;

	iDeleteArray.Close();

	}

void CMsvDelete::StartL(TMsvId aId, CMsvEntrySelection& aDeletedEntries, CMsvEntrySelection& aMovedEntries, TRequestStatus& aObserverStatus, TBool aPCSyncOverride)

//

//

//

	{

	DoStartL(aId, aDeletedEntries, aMovedEntries, aPCSyncOverride);

	iStatus = KRequestPending;

	TRequestStatus* st=&iStatus;

	User::RequestComplete(st, KErrNone);

	SetActive();

	//

	iObserverStatus = &aObserverStatus;

	*iObserverStatus = KRequestPending;

	}

void CMsvDelete::StartL(TMsvId aId, CMsvEntrySelection& aDeletedEntries, CMsvEntrySelection& aMovedEntries, TBool aPCSyncOverride)

//

//

//

	{	

	DoStartL(aId, aDeletedEntries, aMovedEntries, aPCSyncOverride);

	// the state machine from RunL

	while (iState!=ECompleted)

		{

		switch (iState)

			{

			case ECheck:

				TRAP(iError, CheckEntriesL());

				if (iError)

					iState=ECompleted;

				break;

			case EFiles:

				TRAPD(leave, DeleteFilesL());

				if (leave)

					{

					iError=leave;

					iState=ECompleted;

					}

				break;

			case EIndex:

				DeleteAllIndexEntries();

				iState=ECompleted;

				break;

			case EIndexIndividually:

				DeleteIndividualIndexEntries();

				iState=ECompleted;

				break;

			default:

				__ASSERT_DEBUG(EFalse, PanicServer(EMsvDeleteBadState2));

			}

		}

	// completion code

	iDeletionIndex=0;

	User::LeaveIfError(iError);

	}

void CMsvDelete::DoStartL(TMsvId aId, CMsvEntrySelection& aDeletedEntries, CMsvEntrySelection& aMovedEntries, TBool aPCSyncOverride)

//

//

//

	{

	// Fail now if the index says it's not available

	User::LeaveIfError(iServer.IndexAdapter().ErrorState());

	iId = aId;

	iPCSyncOverride = aPCSyncOverride;

	// Let's not support deletion of entries from non-current drive.

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

	if(GetDriveId(iId) != KCurrentDriveId)

		{

		User::Leave(KErrNotSupported);

		}

#endif

	// get the expanded selection

	iDescendents->Reset();

	iDescendents->AppendL(iId);

	User::LeaveIfError(iServer.IndexAdapter().ExpandSelectionRecursively(*iDescendents));

	// make sure all deleted entries can be stored

	iDeletedEntries = &aDeletedEntries;

	iDeletedEntries->SetReserveL(iDescendents->Count());

	iMovedEntries = &aMovedEntries;

	iMovedEntries->SetReserveL(iDescendents->Count());

	// check if the entry is a service then set up PC override

	TMsvEntry* entry;

	User::LeaveIfError(iServer.IndexAdapter().GetEntry(aId, entry));

	if (entry->iType==KUidMsvServiceEntry)

		iPCSyncOverride=ETrue;

	iState = ECheck;

	}

void CMsvDelete::DoCancel()

//

//

//

	{

	// need to remove the index entries for any already deleted

	if (iState==EFiles || iState==EIndex || iState==EIndexIndividually)

		iPCSynced ? DeleteIndividualIndexEntries() : DeleteAllIndexEntries();

	Complete(KErrCancel);

	}

void CMsvDelete::RunL()

//

//

//

	{

	TInt error = iStatus.Int();

	if (error==KErrNone)

		TRAP(error, DoRunL());

	if (error)

		Complete(error);

	}

void CMsvDelete::DoRunL()

//

//

//

	{

	switch (iState)

		{

		case EFiles:

			DeleteFilesL();

			break;

		case ECheck:

			CheckEntriesL();

			break;

		case EIndex:

			DeleteAllIndexEntries();

			Complete(iError);

			return;

		case EIndexIndividually:

			DeleteIndividualIndexEntries();

			Complete(iError);

			return;

		default:

			__ASSERT_DEBUG(EFalse, PanicServer(EMsvDeleteBadState));

		}

	iStatus = KRequestPending;

	TRequestStatus* st=&iStatus;

	User::RequestComplete(st, KErrNone);

	SetActive();

	}

void CMsvDelete::CheckEntriesL()

//

//

//

	{

	iLockedIndex = iDescendents->Count();

	while (iLockedIndex)

		{

		TMsvId id = iDescendents->At(iLockedIndex-1);

		// lock the entry

		User::LeaveIfError(iServer.IndexAdapter().IsEntryOrStoreLocked(id));

		iLockedIndex--;

		// check noone is reading the store (reading the store now doesn't

		// keep the file open, therefore we can't rely on checking the file to stop

		// deleting while reading

		TBool reading=EFalse;

		User::LeaveIfError(iServer.IndexAdapter().IsStoreReadingLocked(id,reading));

		if(reading) User::Leave(KErrInUse);

		// get the entry

		TMsvEntry entry;

		User::LeaveIfError(iServer.IndexAdapter().GetEntryNoCache(id, &entry));

		TMsvDelete deleteEntry(entry.Id(), entry.Owner(), entry.PcSyncCount(), entry.iType, entry.Complete());

		iDeleteArray.AppendL(deleteEntry);

		// check if any entries have been synced and not been overridden

		if (!iPCSyncOverride && entry.PcSyncCount())

			iPCSynced=ETrue;

		// cannot delete standard folders

		if (entry.StandardFolder())

			User::Leave(KErrAccessDenied);

		// check the store

		TFileName filename;

		iServer.GetEntryName(id, filename, EFalse);

		TBool open;

		TInt error = iServer.FileSession().IsFileOpen(filename, open);

		if (error!=KErrNone && error!=KErrNotFound && error!=KErrPathNotFound)

			User::Leave(error);

		if (error==KErrNone && open)

			User::Leave(KErrInUse);

		// check any files

		CDir* dir;

		error = iServer.GetFileDirectoryListing(id, filename, dir);

		if (error==KErrNone)

			{

			CleanupStack::PushL(dir);

			User::LeaveIfError(iServer.FileSession().SetSessionPath(filename));

			TInt fCount=dir->Count();

			if (fCount--)

				{

				TBool open;

				TInt error = iServer.FileSession().IsFileOpen((*dir)[fCount].iName, open);

				if (error!=KErrNone && error!=KErrNotFound && error!=KErrPathNotFound)

					User::Leave(error);

				if (error==KErrNone && open)

					User::Leave(KErrInUse);

				if ((*dir)[fCount].IsReadOnly())

					User::LeaveIfError(iServer.FileSession().SetAtt((*dir)[fCount].iName, 0, KEntryAttReadOnly));

				}

			CleanupStack::PopAndDestroy(); // dir

			}

		else if (error!=KErrPathNotFound)

			User::Leave(error);

		}

	iState = EFiles;

	}

void CMsvDelete::DeleteFilesL()

//

//

//

	{

	TFileName filename;

	TMsvId id = iDescendents->At(iDeletionIndex++);

	// delete the binary files

	CDir* dir=NULL;

	TBool partiallyDeleted=EFalse;

	TInt error = iServer.GetFileDirectoryListing(id, filename, dir);

	if (error==KErrNone)

		{

		User::LeaveIfError(iServer.FileSession().SetSessionPath(filename));

		// remove any files

		TInt fCount=dir->Count();

		while (fCount--)

			{

			error = iServer.FileSession().Delete((*dir)[fCount].iName);

			if (error==KErrNone)

				partiallyDeleted=ETrue;

			else if (error!=KErrNotFound && error!=KErrPathNotFound)

				goto failed;

			}

		// remove the directory

		error = iServer.FileSession().RmDir(filename);

		if (error==KErrNone)

			partiallyDeleted=ETrue;

		else if (error!=KErrNotFound && error!=KErrPathNotFound)

			goto failed;

		}

	else if (error!=KErrPathNotFound && error!=KErrNotFound)

		goto failed;

	// delete the store

	iServer.GetEntryName(id, filename, EFalse); // error ignore as entry exists

	error = iServer.FileSession().Delete(filename);

	// Try to delete the (single digit) parent folder if it is empty. E.g.: "...\00001001_S\9\"

	iServer.FileSession().RmDir(filename); // ignore error

	if (error==KErrNone)

		partiallyDeleted=ETrue;

	else if (error!=KErrNotFound && error!=KErrPathNotFound)

		goto failed;

	filename.Append(KMsvUtilsNewExtension);  // try and make sure that a temporary store file

	iServer.FileSession().Delete(filename);  // hasn't been left behind by CMsvCachedStore

	                                         // but ignore the error as we can't do anything about it

	// for the last entry, check if it a service and move to next state

	if (iDeletionIndex==iDescendents->Count())

		{

		// get the entry and check whether it is a service

		TBool serviceType =EFalse;

		TInt deleteArrayCount = iDeleteArray.Count();

		for(TInt i =0; i < deleteArrayCount; ++i)

			{

			if(iDeleteArray[i].iEntryId == id)

				{

				if(iDeleteArray[i].iType == KUidMsvServiceEntry)

					{

					serviceType = ETrue;

					}

				break;	

				}

			}	

		if(serviceType)

			{

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

			iServer.Context().MessageFolder(GetDriveId(id), filename);

			MsvUtils::ConstructEntryName(UnmaskTMsvId(id), id, filename, MsvUtils::EPath);

#else

			filename = iServer.Context().MessageFolder();

			MsvUtils::ConstructEntryName(id, id, filename, MsvUtils::EPath);

#endif

			error = iFileMan->RmDir(filename);

			if (error && error!=KErrPathNotFound && error!=KErrNotFound)

				goto failed;

			}

		// we have completed all the deletion, move onto next state

		iState = iPCSynced ? EIndexIndividually : EIndex;

		}

	// deletion was successful

	iDeletedEntries->AppendL(id); // will not leave, space has been reserved

	iMovedEntries->AppendL(id);   // will not leave, space has been reserved

	return;

failed:

	if (partiallyDeleted)

		{

		TMsvEntry* entry=NULL;

		TBool complete =EFalse;

		for(TInt i =0; i< iDeleteArray.Count(); ++i)

			{

			if(iDeleteArray[i].iEntryId == id)

				{

				if(iDeleteArray[i].iIsComplete)

					{

					iServer.IndexAdapter().GetEntry(id, entry);

					if(entry)

						{

						complete = ETrue;

						}

					}

				break;	

				}

			}

		if(complete)

			{

			// mark as imcomplete

			TMsvEntry icmpEntry=*entry;

			icmpEntry.SetComplete(EFalse);

			iServer.IndexAdapter().LockEntry(id);

			iServer.IndexAdapter().ChangeEntry(icmpEntry, KMsvServerId, EFalse); // ignore error

			iServer.IndexAdapter().ReleaseEntry(id);

			}

		}

	// we have failed, move onto next state

	iState = iPCSynced ? EIndexIndividually : EIndex;

	iError=error;

	}

void CMsvDelete::DeleteAllIndexEntries()

//

//

//

	{

	iMovedEntries->Reset();

	if (iDeletedEntries->Count()==0)

		return;

	// delete the entries

	TInt error = KErrNone;

#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

	TMsvEntry* entry = NULL;

	TInt deleteIndex = 0;

	while(deleteIndex < iDeletedEntries->Count())

		{

		iServer.IndexAdapter().GetEntry(iDeletedEntries->At(deleteIndex), entry);

		if(entry==NULL)			

			{

			iDeletedEntries->Delete(deleteIndex);

			continue;

			}

		// If there's a DB store, delete any header entries associated with the entry.

		TRAP(error, iServer.MessageDBAdapter().DeleteHeaderEntryL(entry->iMtm, entry->iId));

		if(KErrNotFound == error) // Ignore entry not found case

			error = KErrNone;

		if(error)

			iDeletedEntries->Delete(deleteIndex);

		else

			++deleteIndex;

		}

#endif

	if(!error) // Looks awkward inside the macro above..

		error = iServer.IndexAdapter().DeleteSelectionUsingTransaction(*iDeletedEntries);

	if (error && iError==KErrNone)

		iError=error;

	}

void CMsvDelete::DeleteIndividualIndexEntries()

//

//

//

	{

	if (iDeletedEntries->Count()==0)

		return;

	TInt moveIndex=0;

	TInt deleteIndex=0;

	iServer.IndexAdapter().BeginTransaction();

	while(deleteIndex < iDeletedEntries->Count())

		{

		// get the entry

		TMsvEntry* entry=NULL;

 	    iServer.IndexAdapter().GetEntry(iDeletedEntries->At(deleteIndex), entry);

		if(entry==NULL)			

			{

			iDeletedEntries->Delete(deleteIndex);

			iMovedEntries->Delete(moveIndex);

			continue;

			}

		TInt error = KErrNone;

		if(!entry->Owner())

			{

			// either delete the entry, or move it to the deleted folder

			if(entry->PcSyncCount()==0)

				{ // Deleting the entry..

#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

				// If there's a DB store, delete any header entries associated with the entry.

				TRAP(error, iServer.MessageDBAdapter().DeleteHeaderEntryL(entry->iMtm, entry->iId));

				if(KErrNotFound == error) // Ignore entry not found case

					error = KErrNone;

#endif

				if(!error) // Looks awkward inside the macro above..

					error = iServer.IndexAdapter().ForceDeleteEntry(entry->Id());

				if (error)

					iDeletedEntries->Delete(deleteIndex);

				else

					deleteIndex++;

				iMovedEntries->Delete(moveIndex);

				}

			else

				{ // Moving the entry..

				TMsvEntry deletedEntry(*entry);

				// this should be removed and CMsvDelete made a friend of TMsvEntry

				deletedEntry.iDetails.Set(TPtrC());

				deletedEntry.iDescription.Set(TPtrC());

				deletedEntry.SetDeleted(ETrue);

				deletedEntry.SetVisible(EFalse);

				deletedEntry.SetParent(KMsvDeletedEntryFolderEntryId);