/*

* Copyright (c) 2002-2008 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:  Handles the copy/move operation

*

*/

// INCLUDE FILES

#include <bautils.h>

//#include <cmgxfilemanager.h>

//#include <mgxfilemanagerfactory.h>

#include "CFileManagerActiveExecute.h"

#include "MFileManagerProcessObserver.h"

#include "CFileManagerEngine.h"

#include "CFileManagerFileSystemIterator.h"

#include "Cfilemanagerindexiterator.h"

#include "CFileManagerCommonDefinitions.h"

#include "CFileManagerUtils.h"

#include "FileManagerDebug.h"

#include "CFileManagerThreadWrapper.h"

// CONSTANTS

const TInt KFileManagerNotificationArrayGranularity = 64;

// ============================ MEMBER FUNCTIONS ===============================

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

// CFileManagerActiveExecute::NewL

// 

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

// 

EXPORT_C CFileManagerActiveExecute* CFileManagerActiveExecute::NewL( 

        CFileManagerEngine& aEngine,

        MFileManagerProcessObserver::TFileManagerProcess aOperation,

        MFileManagerProcessObserver& aObserver,

        CArrayFixFlat<TInt>& aIndexList,

        const TDesC& aToFolder )

    {

    CFileManagerActiveExecute* self = 

        new( ELeave ) CFileManagerActiveExecute(

            aEngine,

            aOperation,

            aObserver );

    CleanupStack::PushL( self );

    self->ConstructL( aIndexList, aToFolder );

    CleanupStack::Pop( self );

    return self;

    }

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

// CFileManagerActiveExecute::~CFileManagerActiveExecute

// 

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

// 

EXPORT_C CFileManagerActiveExecute::~CFileManagerActiveExecute()

    {

    Cancel();

    delete iThreadWrapper;

    delete iItemIterator;

    delete iFullPath;

    delete iDestination;

    delete iToFolder;

    delete iIndexList;

    delete iChangedSrcItems;

    delete iChangedDstItems;

    }

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

// CFileManagerActiveExecute::ExecuteL

// 

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

// 

EXPORT_C void CFileManagerActiveExecute::ExecuteL( TFileManagerSwitch aOverWrite )

    {

    TInt error( KErrNone );

    if ( iCancelled )

        {

        TFileName newName;

        TParsePtrC parse( *iFullPath );

        if ( parse.NameOrExtPresent() )

            {

            newName.Copy( parse.NameAndExt() );

            }

        else

            {

            TPtrC name( iEngine.LocalizedName( *iFullPath ) );

            if ( name.Length() > 0 )

                {

                newName.Copy( name );

                }

            else

                {

                newName = BaflUtils::FolderNameFromFullName( *iFullPath );

                }

            }

        iObserver.ProcessFinishedL( iError, newName );

        return;

        }

    if ( aOverWrite == ENoOverWrite )

        {

        iItemIterator->CurrentL( &iSrc, &iDst, iItemType );

        }

    if ( iDst && iDst->Length() > KMaxFileName )

        {

        error = KErrBadName;

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, error );              

        }

    else if ( iItemType == EFileManagerFile )

        {

#ifdef __KEEP_DRM_CONTENT_ON_PHONE

    if ( iSrc && iDst &&

        CFileManagerUtils::IsFromInternalToRemovableDrive( iFs, *iSrc, *iDst ) )

        {

        TBool protectedFile( EFalse );

        // silently ignore this file if it is protected, or if there

        // was an error in checking.

        // Did consider leaving, but what about eg KErrNotFound - eg another

        // process moving/deleting the file...

        TInt ret( iEngine.IsDistributableFile( *iSrc, protectedFile ) );

        if( protectedFile || ret != KErrNone )

            {

            TRequestStatus* status = &iStatus;

            User::RequestComplete( status, KErrNone );

            SetActive();

            return;

            }

        }

#endif

        DoOperation( aOverWrite );

        return;

        }

    else if ( iItemType == EFileManagerFolder )

        {

        if ( !iIsDstRemoteDrive && iEngine.IsNameFoundL( *iDst ) )

            {

            TRequestStatus* status = &iStatus;

            User::RequestComplete( status, KErrAlreadyExists );

            SetActive();

            return;

            }

        DoOperation( aOverWrite );

        return;

        }

    else

        {

        // We must complete this

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, error );              

        }

    SetActive();

    }

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

// CFileManagerActiveExecute::CancelExecution

// 

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

// 

EXPORT_C void CFileManagerActiveExecute::CancelExecution()

    {

    FUNC_LOG

    iCancelled = ETrue;

    if ( iSrc )

        {

        iEngine.CancelTransfer( *iSrc );

        }

    if ( iDst )

        {

        iEngine.CancelTransfer( *iDst );

        }

    delete iThreadWrapper; // Cancel thread

    iThreadWrapper = NULL;

    Cancel();

    TRAP_IGNORE( CompleteL( KErrCancel ) );

    }

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

// CFileManagerActiveExecute::DoCancel

// 

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

// 

void CFileManagerActiveExecute::DoCancel()

    {

    iCancelled = ETrue;

    if ( iSrc )

        {

        iEngine.CancelTransfer( *iSrc );

        }

    if ( iDst )

        {

        iEngine.CancelTransfer( *iDst );

        }

    delete iThreadWrapper; // Cancel thread

    iThreadWrapper = NULL;

    }

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

// CFileManagerActiveExecute::KErrNoneAction

//

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

//

void CFileManagerActiveExecute::KErrNoneActionL()

    {

    UpdateNotifications( EFalse, KErrNone );

    if ( iItemIterator->NextL() )

        {

        ExecuteL( ENoOverWrite );

        }

    else

        {

        if ( iOperation == MFileManagerProcessObserver::EMoveProcess && 

            iEngine.IsFolder( iIndexList->At( 0 ) ) )

            {

            if ( !iFinalizeMove )

                {

                // Finalize move in the thread, the finalizing way take time

                iFinalizeMove = ETrue;

                DoOperation( ENoOverWrite );

                return;

                }

            }

        UpdateNotifications( ETrue, KErrNone );

        iObserver.ProcessFinishedL( KErrNone );

        }

    }

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

// CFileManagerActiveExecute::KErrAlreadyExistsAction

//

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

//

void CFileManagerActiveExecute::KErrAlreadyExistsActionL()

    {

    TParsePtrC dstParse( *iDst );

    HBufC* name = HBufC::NewLC( KMaxFileName );

    TPtr ptrName( name->Des() );

    TBool doContinue( EFalse );

    // Depending on target file can it be delete, we ask overwrite or rename.

    // If source and target is same, then rename is only possible choice.

    if ( iItemType == EFileManagerFile && iEngine.CanDelete( *iDst ) && iSrc->FindF( *iDst ) )

        {

        if ( iObserver.ProcessQueryOverWriteL( *iDst, ptrName, iOperation ) )

            {

            ExecuteL( EOverWrite );

            }

        else

            {

            // user does not want to overwrite item and ptrName should now contain

            // user given new name

            if ( ptrName.Length() > 0 )

                {

                ptrName.Insert( 0, dstParse.DriveAndPath() );

                if ( !iDst->CompareF( ptrName ) )

                    {

                    DoOperation( ENoOverWrite );

                    }

                else

                    {

                    iDst->Des().Copy( ptrName );

                    // Overwrite, because user already queried by overwrite

                    DoOperation( EOverWrite );

                    }

                }

            else

                {

                // User is not willing to rename item, continue current operation

                doContinue = ETrue;

                }

            }

        }

    else

        {

        // item can't be overwrite

        if ( iObserver.ProcessQueryRenameL( *iDst, ptrName, iOperation ) )

            {

            if ( ptrName.Length() > 0 )

                {

                if ( iItemType == EFileManagerFile )

                    {

                    ptrName.Insert( 0, dstParse.DriveAndPath() );

                    iDst->Des().Copy( ptrName );

                    }

                else if ( iItemType == EFileManagerFolder )

                    {

                    TPtr ptr( iDst->Des() );

                    AddLastFolder( ptr, ptrName, *iToFolder );

                    iDestination->Des().Copy( ptr );

                    }

                // Overwrite, because user already queried by rename

                ExecuteL( EOverWrite );

                }

            else if ( iItemType == EFileManagerFolder )

                {

                iCancelled = ETrue;

                iError = KErrCancel;

                ExecuteL( ENoOverWrite );

                }

            else

                {

                // User is not willing to rename item, continue current operation

                doContinue = ETrue;

                }

            }

        else if ( iItemType == EFileManagerFolder )

            {

            iCancelled = ETrue;

            iError = KErrCancel;

            ExecuteL( ENoOverWrite );

            }

        else

            {

            // User is not willing to rename item, continue current operation

            doContinue = ETrue;

            }

        }

    CleanupStack::PopAndDestroy( name );

    if ( doContinue )

        {

        if ( iItemIterator->NextL() )

            {

            ExecuteL( ENoOverWrite );

            }

        else

            {

            UpdateNotifications( ETrue, KErrNone );

            iObserver.ProcessFinishedL( KErrNone );

            }

        }

    }

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

// CFileManagerActiveExecute::RunL

// 

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

// 

void CFileManagerActiveExecute::RunL()

    {

    CompleteL( iStatus.Int() );

    }

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

// CFileManagerActiveExecute::CompleteL

// 

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

// 

void CFileManagerActiveExecute::CompleteL( TInt aError )

    {

    if ( iCancelled || !iItemIterator )

        {

        UpdateNotifications( ETrue, iError );

        TParsePtrC parse( CFileManagerUtils::StripFinalBackslash(

            *iDestination ) );

        if ( parse.NameOrExtPresent() )

            {

            iObserver.ProcessFinishedL( iError, parse.NameAndExt() );

            }

        else if ( parse.DrivePresent() )

            {

            iObserver.ProcessFinishedL( iError, parse.Drive() );

            }

        else

            {

            iObserver.ProcessFinishedL( iError );

            }

        return;

        }

    // Symbian returns KErrNone if source and destination

    // in moving is same. Here we have to treat it as error.

    if( iSrc && iDst )

        {

        if ( !iSrc->CompareF( *iDst ) && aError == KErrNone )

            {

            aError = KErrInUse;

            }

        }    

    ERROR_LOG1( "CFileManagerActiveExecute::CompleteL()-aError=%d", aError )

    switch ( aError )

        {

        case KErrNone:

            {

            KErrNoneActionL();

            break;

            }

        case KErrAlreadyExists:

            {

            KErrAlreadyExistsActionL();

            break;

            }

        case KErrCancel: // Suppressed errors

            {

            UpdateNotifications( ETrue, KErrNone );

            iObserver.ProcessFinishedL( KErrNone );

            break;

            }

        default:

            {

            if ( iSrc )

                {

                // Try rename when moving and the target file exists and is in use

                if ( iOperation == MFileManagerProcessObserver::EMoveProcess &&

                    aError == KErrInUse &&

                    iDst &&

                    iEngine.CanDelete( *iSrc ) &&

                    iEngine.IsNameFoundL( *iDst ) )

                    {

                    KErrAlreadyExistsActionL();

                    }

                else

                    {

                    UpdateNotifications( ETrue, aError );

                    TParsePtrC parse( *iSrc );

                    iObserver.ProcessFinishedL( aError, parse.NameAndExt() );

                    }

                }

            else

                {

                UpdateNotifications( ETrue, aError );

                iObserver.ProcessFinishedL( aError );

                }

            break;

            }

        }

    }

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

// CFileManagerActiveExecute::RunError

// 

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

// 

TInt CFileManagerActiveExecute::RunError(TInt aError)

    {

    return aError;

    }

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

// CFileManagerActiveExecute::CFileManagerActiveExecute

// 

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

// 

CFileManagerActiveExecute::CFileManagerActiveExecute( 

    CFileManagerEngine& aEngine,

    MFileManagerProcessObserver::TFileManagerProcess aOperation,

    MFileManagerProcessObserver& aObserver ) :

        CActive( CActive::EPriorityLow ), // Use low to avoid progress note mess up

        iEngine( aEngine ),

        iFs( aEngine.Fs() ),

        iOperation( aOperation ),

        iObserver( aObserver )

    {

    CActiveScheduler::Add( this );

    }

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

// CFileManagerActiveExecute::ConstructL

// 

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

// 

void CFileManagerActiveExecute::ConstructL( CArrayFixFlat<TInt>& aIndexList,

                                            const TDesC& aToFolder )

    {

    iChangedSrcItems = new( ELeave ) CDesCArrayFlat(

        KFileManagerNotificationArrayGranularity );

    iChangedDstItems = new( ELeave ) CDesCArrayFlat(

        KFileManagerNotificationArrayGranularity );

    iToFolder = aToFolder.AllocL();

    TInt count( aIndexList.Count() );

    iIndexList = new( ELeave ) CArrayFixFlat< TInt >( count );

    for( TInt i( 0 ); i < count; ++i )

        {

        // make own copy of index list because caller may

        // destroy the original one.

        iIndexList->AppendL( aIndexList.At( i ) );

        }

    TInt index( iIndexList->At( iCurrentIndex ) );

    iFullPath = iEngine.IndexToFullPathL( index );

    TBool isDirectory( iEngine.IsFolder( index ) );

    iDestination = HBufC::NewL( KFmgrDoubleMaxFileName );

    if ( isDirectory )

        {

        TPtr ptr( iDestination->Des() );

        AddLastFolder( ptr, *iFullPath, *iToFolder );

        }

    else

        {

        iDestination->Des().Copy( aToFolder );

        }

    // Check that we are not copying/moving folder to inside it ( recursive copy )

    if ( isDirectory && !iDestination->FindF( *iFullPath ) && 

         iDestination->Length() > iFullPath->Length() )

        {

        iCancelled = ETrue;

        iError = KErrAccessDenied;

        }

    // Is destination path too long for file system

    else if ( iDestination->Length() > KMaxFileName )

        {