// Copyright (c) 2004-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 "MSVSERV.H"

#include "MSVAPI.H"

#include <cmsvcopystoreoperation.h>

// the amount of space used, even if empty (an approximation)

const TInt KMinimumSpace=400;

_LIT(KIndex, "Index");

CMsvCopyStoreOperation::CMsvCopyStoreOperation(const RMessage2& aMessage, CMsvServer& aServer)

: CMsvServerOperation(aMessage, aMessage.Int0(), KUidMsvLocalServiceMtm, KMsvLocalServiceIndexEntryId, -1), iDrive(TDriveUnit (aMessage.Int1() )), iServer(aServer)

	{

	CActiveScheduler::Add(this);

	}

CMsvCopyStoreOperation* CMsvCopyStoreOperation::NewL(const RMessage2& aMessage, CMsvServer& aServer)

	{

	CMsvCopyStoreOperation* self=new(ELeave)CMsvCopyStoreOperation(aMessage, aServer);

	return self;

	}

CMsvCopyStoreOperation::~CMsvCopyStoreOperation()

	{

	Cancel();

	delete iDir;

	delete iFileMan;

	}

void CMsvCopyStoreOperation::StartL()

	{

	__ASSERT_DEBUG(!IsActive() , PanicServer(EMsvCopyStoreReset));

	iProgress().iState=TMsvCopyProgress::ENotYetStarted;

	iPos=0;

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

	CompleteSelf();

	}

/* Function to retrieve progress of the Copy operation

**/

const TDesC8& CMsvCopyStoreOperation::Progress()

	{

	 return iProgress;

	}

void CMsvCopyStoreOperation::DoCancel()

	{

	iCopyCancel = ETrue;

	Completed(KErrCancel);

	}

/* Run different operations like LockStore, CopyStore

   UnlockStore and Completed */

void CMsvCopyStoreOperation::RunL()

	{

	User::LeaveIfError(iStatus.Int());

	switch(iProgress().iState)

		{

		case TMsvCopyProgress::ENotYetStarted:

			LockMailStoreL();

			iProgress().iState=TMsvCopyProgress::ELock;

			break;

		case TMsvCopyProgress::ELock:

			InitCopyStoreL();

			iProgress().iState=TMsvCopyProgress::EInitCopy;

			break;

		case TMsvCopyProgress::EInitCopy:

			iProgress().iState=TMsvCopyProgress::ECopyStore;

		//drop through the next case statement

		case TMsvCopyProgress::ECopyStore:

			if (iPos<iProgress().iTotal)

				{

				CopySourceL();

				}

			else

			   	{

				FinishCopyStoreL();

				iProgress().iState=TMsvCopyProgress::EUnlock;

			   	}

			break;

		case TMsvCopyProgress::EUnlock:

			Completed(KErrNone);

			iProgress().iState=TMsvCopyProgress::ECompleted;

			break;

		default:

			__ASSERT_DEBUG(EFalse,PanicServer(EMsvCopyStoreReset));

			Completed(KErrUnknown);

			iProgress().iState=TMsvCopyProgress::ECompleted;

			break;

		}

	}

/* Lock the Mail store so other operations dont use it while

   the copy event is in progress

*/

void CMsvCopyStoreOperation::LockMailStoreL()

	{

	User::LeaveIfError(iServer.Context().IndexAdapter()->ErrorState());

	iServer.NotifyChanged(EMsvMediaUnavailable, KMsvNullIndexEntryId, iServer.Drive());

	iServer.SetStartupState(EMsvMediaUnavailable);

	iServer.Context().IndexAdapter()->SetErrorState(KErrNone);

	//Complete yourself

	CompleteSelf();

	}

/* Initialise the copy process by setting the destination path,etc

*/

void CMsvCopyStoreOperation::InitCopyStoreL()

	{

	//Check if the drive already contains a store,

	//if so then unlock the index file and complete

	if(MessageServer::DriveContainsStore(iServer.FileSession(),iDrive))

		{

		User::Leave(KErrAlreadyExists);

		}

	else

		{

		//Create the destination path

		iDest = iDrive.Name();

		iDest.Append(iServer.Context().MessageFolder());

		//Delete the drive letters from Messagefolder path

		iDest.Delete(2,2);

		//check if the target disk has enough disk space

		CheckDiskSpaceL();

		//Get the directory structure of the source path

		delete iDir;

		iDir=NULL;

    	User::LeaveIfError(iServer.FileSession().GetDir(iServer.Context().MessageFolder(), KEntryAttDir|KEntryAttNormal, ESortNone, iDir));

    	iProgress().iTotal = iDir->Count();

 		//Check if there is any broken store already existing on iDest

 		TUint unused;

		TInt error=iServer.FileSession().Att(iDest,unused);

		if(error == KErrNone)

			{

			//delete any files that may exist

			User::LeaveIfError(iFileMan->RmDir(iDest,iStatus));

			SetActive();

			}

		else

			{

		    //Complete

   			CompleteSelf();

            }

		}

	}

/** Copy Message Store directories from source to destination

	except for the Index file, which is copied in the end after

	all goes well.

*/

void CMsvCopyStoreOperation::CopySourceL()

	{

	iCopyCancel = EFalse;

	TEntry entry;

	TFileName dest=iDest;

	entry = (*iDir)[iPos];

	if(entry.iName==KIndex)

    	{

    	//complete yourself

	   	CompleteSelf();

    	}

    else

    	{

	    iSrc.Zero();

    	iSrc.Append(iServer.Context().MessageFolder());

       	iSrc.Append(entry.iName);

       	dest.Append(entry.iName);

       	// Check if the entry is a directory

    	if(entry.IsDir())

    		{

    		dest.Append('\\');

    		iSrc.Append('\\');

      		// Get the contents of this directory

      		CDir *dirList=NULL;

      		TInt err = iServer.FileSession().GetDir(iSrc, KEntryAttDir, ESortByName, dirList);

      		// Get the count to check if the directory is empty

      		TInt count = dirList->Count();

      		delete dirList;

      		if(err == KErrNone)

      			{

      			// Create an empty directory

      			User::LeaveIfError(iServer.FileSession().MkDirAll(dest));

      			// Copy the contents over

      			if( count != 0 )

       	     		{

       	     		User::LeaveIfError(iFileMan->Copy(iSrc,dest,CFileMan::ERecurse,iStatus));

    				SetActive();

       	     		}

       	     	// Directory empty nothing needed

       	    	else

       				{

       				CompleteSelf();

       				}

      			}

      		else

      			{

       			User::Leave(err);

      			}

    		}

    	else

    		{

    		if(iPos==0)

    			{

    			User::LeaveIfError(iServer.FileSession().MkDirAll(dest));

    			}

    		User::LeaveIfError(iFileMan->Copy(iSrc,dest,CFileMan::EOverWrite,iStatus));

    		SetActive();

    		}

    	}

    dest.Zero();

    iProgress().iCurrent = iPos++;

    }

/** Finish the Copy Process by copying over the index

*/

void CMsvCopyStoreOperation::FinishCopyStoreL()

	{

	TDriveUnit drive = MessageServer::CurrentDriveL(iServer.FileSession());

	TParse parse;

	TPtrC currDrive(drive.Name());

	parse.Set(KMsvDbFile, &currDrive, NULL);

	TFileName src = parse.FullName();

	TPtrC newDrive(iDrive.Name());

	parse.Set(KMsvDbFile, &newDrive, NULL);

	TFileName dest = parse.FullName();

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

	TRAP_IGNORE(iServer.Context().IndexAdapter()->GetDbAdapter()->DetachDBL(KCurrentDriveId));

#else

	delete iServer.Context().IndexAdapter()->GetDbAdapter();

#endif

	RSqlDatabase::Copy(src, dest);

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

	// Update the drive status of the target 

	// drive in the preferred drive list.

	iServer.UpdateDriveStatusL(iDrive, EMsvMessageStoreAvailableStatus);

#endif

	CompleteSelf();

	}

/** Unlock the Index file so other functions can

    use it once again

*/

void CMsvCopyStoreOperation::UnlockMailStore()

	{

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

	TMsvId maxId;

	TDriveNumber driveNum = CMsvPreferredDriveList::GetDriveList()->CurrentDriveNumber();

#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

	TRAP_IGNORE(iServer.Context().IndexAdapter()->GetDbAdapter()->AttachDBL(driveNum, KCurrentDriveId, maxId, &iServer.MessageDBAdapter()));

#else

	TRAP_IGNORE(iServer.Context().IndexAdapter()->GetDbAdapter()->AttachDBL(driveNum, KCurrentDriveId, maxId));

#endif

#else

	TDriveUnit driveUnit;

	TRAP_IGNORE(driveUnit = MessageServer::CurrentDriveL(iServer.FileSession()));

	TPtrC drive(driveUnit.Name());

	TParse parse;

	parse.Set(KMsvDbFile, &drive, NULL);

	TFileName dest = parse.FullName();

	TRAP_IGNORE(iServer.Context().IndexAdapter()->OpenclosedL(dest));

#endif		// #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

	iServer.NotifyChanged(EMsvMediaAvailable, KMsvNullIndexEntryId, iServer.Drive());

	iServer.Context().IndexAdapter()->SetErrorState(KErrNone);

	iServer.SetStartupState(EMsvNullNotification);

	}

/** Complete the unlock process and Set yourself active

*/

void CMsvCopyStoreOperation::CompleteSelf()

	{

	TRequestStatus *status=&iStatus;

	iStatus=KRequestPending;

	SetActive();

	User::RequestComplete(status,KErrNone);

	}

TInt CMsvCopyStoreOperation::RunError(TInt aError)

	{

	//Delete any broken store on the target disk

	TUint unused;

	if (iDest.Length() > 0)

		{

		if(iServer.FileSession().Att(iDest,unused) == KErrNone)

			{

			iFileMan->RmDir(iDest);	// ignore error - don't care if fails

			}

		}

	Completed(aError);

	return(KErrNone);

	}

/* Completed */

void CMsvCopyStoreOperation::Completed(TInt aError)

	{

	iProgress().iError=aError;

	if(iProgress().iState >= TMsvCopyProgress::ELock)

		{

		 UnlockMailStore();

		}

	SetState(EMsvOperationCompleted);

	iMessage.Complete(KErrNone);

	}

/* Check the target disk space */

void CMsvCopyStoreOperation::CheckDiskSpaceL()

	{

	RFs& fs = iServer.FileSession();

	TInt64 spaceNeed=KMinimumSpace;

	CDirScan* dirScan = CDirScan::NewLC(fs);

	CDir* dirList = NULL;

	TVolumeIOParamInfo volumeIOInfo;

	User::LeaveIfError(fs.VolumeIOParam(TInt(iDrive), volumeIOInfo));

	TInt clusterSize = volumeIOInfo.iClusterSize;

	dirScan->SetScanDataL(iServer.Context().MessageFolder(), KEntryAttNormal, ESortByName, CDirScan::EScanDownTree);

	do{

		dirScan->NextL(dirList);

		CleanupStack::PushL(dirList);

		if(dirList)

			{

			for(TInt item = 0; item < dirList->Count(); ++item)

				{

				const TEntry& entry = (*dirList)[item];

				spaceNeed+=entry.iSize+clusterSize;

				}

			}

		else

			{

			spaceNeed+=KMinimumSpace;

			}

		CleanupStack::PopAndDestroy(dirList);

		} while(dirList); 

	 CleanupStack::PopAndDestroy(dirScan);

	 TVolumeInfo volumeInfo;

	 User::LeaveIfError(iServer.FileSession().Volume(volumeInfo, iDrive));

	 if(volumeInfo.iFree<spaceNeed)

	 	{

	 	User::Leave(KErrDiskFull);

	 	}

	 }

/**

NotifyFileManOperation is called by the Fileman observer framework after/before each

file operation.

@param None.

@return MFileManObserver::TControl

        ECancel If the operation is cancelled for one entry.

        EContinue If the operation needs to be continued.

*/

MFileManObserver::TControl CMsvCopyStoreOperation::NotifyFileManOperation()

	{

	if(iCopyCancel)

		{

		return MFileManObserver::ECancel;

		}

	return MFileManObserver::EContinue;

	}

/**

NotifyFileManEnded is called by the Fileman observer framework to inform the observer

that an operation is complete.

@param None.

@return MFileManObserver::TControl

        EAbort If the bulk operation is cancelled.

        EContinue If the operation needs to be continued.

*/

MFileManObserver::TControl CMsvCopyStoreOperation::NotifyFileManEnded()

	{

	if(iCopyCancel)

		{

		return MFileManObserver::EAbort;

		}

	return MFileManObserver::EContinue;

	}