/*

* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:    Implementation for MPX My Videos Collection Move, Copy and Delete operations.*

*/

// INCLUDE FILES

#include <e32cmn.h>

#include <s32mem.h>

#include <mpxlog.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediageneraldefs.h>

#include <mpxcollectionpluginobserver.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include <mpxmessagecontainerdefs.h>

#include <vcxmyvideosuids.h>

#include <drmutility.h>

#include <bautils.h>

#include "vcxmyvideoscollectionplugin.h"

#include "vcxmyvideoscollection.hrh"

#include "vcxmyvideoscollectionutil.h"

#include "vcxmyvideosdownloadutil.h"

#include "vcxmyvideosvideocache.h"

#include "vcxmyvideoscategories.h"

#include "vcxmyvideosmessagelist.h"

#include "vcxmyvideosasyncfileoperations.h"

#include "vcxmyvideosasyncfilecopy.h"

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

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

// Two-phased constructor.

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

//

CVcxMyVideosAsyncFileOperations* CVcxMyVideosAsyncFileOperations::NewL(

    CVcxMyVideosCollectionPlugin& aCollection )

    {

    CVcxMyVideosAsyncFileOperations* self = new (ELeave) CVcxMyVideosAsyncFileOperations(

            aCollection );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// Destructor.

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

//

CVcxMyVideosAsyncFileOperations::~CVcxMyVideosAsyncFileOperations()

    {        

    iOperationIdArray.Close();

    iOperationResult.Close();

    delete iFileCopier;

    delete iMediaForMoveOp;

    delete iMediaForCopyOp;

    }

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

// Constructor.

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

//

CVcxMyVideosAsyncFileOperations::CVcxMyVideosAsyncFileOperations( CVcxMyVideosCollectionPlugin& aCollection )

: iCollection( aCollection )

    {

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CVcxMyVideosAsyncFileOperations::ConstructL ()

    {

    iFileCopier = CVcxMyVideosAsyncFileCopy::NewL( iCollection.iFs );

    }

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

// CVcxMyVideosCollectionPlugin::DeleteVideoL

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

//

void CVcxMyVideosAsyncFileOperations::DeleteVideoL( TUint32 aMdsId, TBool aForce )

    {

    MPX_FUNC("CVcxMyVideosAsyncFileOperations::DeleteVideoL");

    TInt pos;

    CMPXMedia* videoInCache = iCollection.iCache->FindVideoByMdsIdL( aMdsId, pos );

    if ( !videoInCache )

        {

        MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: delete failed, MPX item not found from cache.");

        User::Leave( KErrNotFound );

        }

    TUint32 downloadId = TVcxMyVideosCollectionUtil::DownloadIdL( *videoInCache );            

    if ( downloadId )

        {

        TVcxMyVideosDownloadState dlState =

                TVcxMyVideosCollectionUtil::DownloadStateL( *videoInCache );

        if ( aForce )

            {

            MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: aForce is ETrue, the video will be deleted even if download is ongoing");

            }

        else if ( dlState != EVcxMyVideosDlStateNone )

            {

            MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: delete failed since there is download going on.");

            MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: use download cancel instead.");

            User::Leave( KErrArgument );

            }

        else

            {

            MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: download id was != 0 but download state was EVcxMyVideosDlStateNone");

            MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: -> we delete the video, it is prob gone from Download Manager already.");

            }        

        }

    if ( !videoInCache->IsSupported( KMPXMediaGeneralUri ) )

        {

        MPX_DEBUG1("CVcxMyVideosAsyncFileOperations::DeleteVideoL() KMPXMediaGeneralUri attribute missing -> leaving");

        User::Leave( KErrArgument );

        }

    MPX_DEBUG2("CVcxMyVideosAsyncFileOperations:: trying to delete: %S",

            &videoInCache->ValueText( KMPXMediaGeneralUri ));

    TInt err = iCollection.iFs.Delete( videoInCache->ValueText( KMPXMediaGeneralUri ) );

    if ( err != KErrNone )

        {

        MPX_DEBUG2("CVcxMyVideosAsyncFileOperations:: file delete failed: %d", err );

        if ( err == KErrNotFound || err == KErrPathNotFound )

            {

            MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: file was not found, trying to remove mds object anyways");

            TInt result = iCollection.iMyVideosMdsDb->RemoveVideo( aMdsId );

            if ( result == KErrNone )

                {

                MPX_DEBUG2("CVcxMyVideosAsyncFileOperations:: %d removed from mds", aMdsId); 

                //mds events will clean cache

                }

            else

                {

                if ( result == KErrNotFound )

                    {

                    // file is gone, and mds item is gone -> try to delete from cache

                    MPX_DEBUG2("CVcxMyVideosAsyncFileOperations:: %d not found from MDS, trying to delete from cache", aMdsId );

                    TInt result = iCollection.iCache->RemoveL( aMdsId );

                    if ( result == KErrNone )

                        {

                        MPX_DEBUG2("CVcxMyVideosAsyncFileOperations:: %d deleted from cache, generating event", aMdsId );

                        iCollection.iMessageList->AddEventL( TMPXItemId( aMdsId, 0),

                                EMPXItemDeleted, EVcxMyVideosListNoInfo );

                        iCollection.iMessageList->SendL();

                        } 

                    }

                else

                    {

                    //file is gone, mds item and cache are still present, couldnt remove them

                    MPX_DEBUG3("CVcxMyVideosAsyncFileOperations:: failed to remove %d from mds (%d)", aMdsId, result);

                    User::Leave( result );

                    }

                }

            }            

        else

            {

            // file delete failed and file still exists

            MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: leaving mds object intact");

            User::Leave( err );

            }

        }

    else

        {

        MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: file delete successful, deleting item from MDS also to speed things up");

        TInt result = iCollection.iMyVideosMdsDb->RemoveVideo( aMdsId );

        if ( result == KErrNone )

            {

            MPX_DEBUG2("CVcxMyVideosAsyncFileOperations:: %d removed from mds", aMdsId);

            //mds events will clean cache

            }

        else

            {

            if ( result == KErrNotFound )

                {

                // file is gone, and mds item is gone -> try to delete from cache

                MPX_DEBUG2("CVcxMyVideosAsyncFileOperations:: %d not found from MDS, trying to delete from cache", aMdsId );

                TInt result = iCollection.iCache->RemoveL( aMdsId );

                if ( result == KErrNone )

                    {

                    MPX_DEBUG2("CVcxMyVideosAsyncFileOperations:: %d deleted from cache, generating event", aMdsId );

                    iCollection.iMessageList->AddEventL( TMPXItemId( aMdsId, 0),

                            EMPXItemDeleted, EVcxMyVideosListNoInfo );

                    iCollection.iMessageList->SendL();

                    }

                }

            else

                {

                //mds item and cache are still present, couldnt remove them

                MPX_DEBUG3("CVcxMyVideosAsyncFileOperations:: failed to remove %d from mds (%d)", aMdsId, result);

                User::Leave( result );

                }

            }

        }   

    }

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

// CVcxMyVideosAsyncFileOperations::HandleMoveOrCopyStepL

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

//

TBool CVcxMyVideosAsyncFileOperations::HandleMoveOrCopyStepL()

    {

    // Reset inactivity timer. This will prevent ThumbAGDaemon start running while

    // Move/copy is ongoing and failing the operation due to locked file handle.

    User::ResetInactivityTime();

    CMPXMedia& cmd = iCollection.iActiveTask->GetCommand();

    TBool done;

    if ( iCurrentOperationIndex == 0 && !iFileCopier->CopyIsOngoing() )

        {

        InitMoveOrCopyOperationsL( cmd );        

        }

    TRAPD( err, MoveOrCopyVideoL( iOperationIdArray[iCurrentOperationIndex],

            iTargetDrive ));

    if ( iFileCopier->CopyIsOngoing() && err == KErrNone )

        {

        // copy didnt finish yet, lets do some more steps before jumping to next file

        return EFalse;

        }

    iOperationResult.AppendL( err );

    iCurrentOperationIndex++;

    // End operations

    if ( iCurrentOperationIndex > (iOperationIdArray.Count() - 1) )

        {

        iCurrentOperationIndex = 0;

        done                   = ETrue;

        if ( iIsMoveOperation )

            {

            SendOperationRespL( KVcxMessageMyVideosMoveResp );

            }

        else

            {

            SendOperationRespL( KVcxMessageMyVideosCopyResp );

            }

        }

    else

        {

        done = EFalse;

        }

    return done;

    }

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

// CVcxMyVideosAsyncFileOperations::InitMoveOrCopyOperationsL

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

//

void CVcxMyVideosAsyncFileOperations::InitMoveOrCopyOperationsL( CMPXMedia& aCmd )

    {

    if ( !aCmd.IsSupported( KMPXMediaArrayContents ) )

        {

        MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: error, no array defined");

        User::Leave( KErrArgument );

        }

    CMPXMediaArray* idMediaArray = aCmd.Value<CMPXMediaArray>(

            KMPXMediaArrayContents );

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

        {

        MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: error, no items in array ");

        User::Leave( KErrArgument );

        }

    TUint32 cmdId = aCmd.ValueTObjectL<TUint32>( KVcxMediaMyVideosCommandId );    

    if ( cmdId == KVcxCommandMyVideosMove )

        {

        MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: move operation");

        iIsMoveOperation = ETrue;

        }

    else

        {

        iIsMoveOperation = EFalse;

        }

    iTargetDrive = aCmd.ValueTObjectL<TInt32>( KVcxMediaMyVideosInt32Value );

    TMPXItemId mpxId;    

    iOperationIdArray.Reset();

    TInt count = idMediaArray->Count();

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

        {

        mpxId = idMediaArray->AtL( i )->

                        ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );

        MPX_DEBUG3("CVcxMyVideosAsyncFileOperations:: MPX ID: (%d, %d) will be moved ",

                mpxId.iId1,

                mpxId.iId2);

        iOperationIdArray.AppendL( idMediaArray->AtL( i )->

                ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId ).iId1 );

        }

    iCollection.SendMyVideosMessageL( KVcxMessageMyVideosMoveOrCopyStarted, &aCmd );

    iOperationResult.Reset();

    }

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

// CVcxMyVideosAsyncFileOperations::CancelOperationL

// Called when leave or cancel occurs for the operation, generates resp msg.

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

//

void CVcxMyVideosAsyncFileOperations::CancelOperationL( TInt aErr )

    {    

    if ( iCollection.iActiveTask->IsActive() )

        {

        TInt mvCmdId = -1;

        CMPXMedia& cmd = iCollection.iActiveTask->GetCommand();

        TMPXCommandId commandId = *cmd.Value<TMPXCommandId>( KMPXCommandGeneralId );

        if ( commandId == KVcxCommandIdMyVideos )

            {

            mvCmdId = cmd.ValueTObjectL<TUint32>( KVcxMediaMyVideosCommandId );

            }

        TInt messageId; 

        switch ( mvCmdId )

            {

            case KVcxCommandMyVideosMove:

                MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: generating KVcxMessageMyVideosMoveResp");

                messageId = KVcxMessageMyVideosMoveResp;

                if ( iFileCopier->CopyIsOngoing() )

                    {

                    //these have to be in this order, otherwise wrong item gets removed from mds

                    TRAP_IGNORE( HandleFileCopyCompletedL( aErr ) ); // rolls mds back

                    iFileCopier->Cancel(); // removes generated file and resets variables

                    }

                break;

            case KVcxCommandMyVideosCopy:

                MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: generating KVcxMessageMyVideosCopyResp");

                messageId = KVcxMessageMyVideosCopyResp;

                if ( iFileCopier->CopyIsOngoing() )

                    {

                    TRAP_IGNORE( HandleFileCopyCompletedL( aErr ) ); // rolls mds back

                    iFileCopier->Cancel(); // removes generated file and resets variables

                    }

                break;

            case KVcxCommandMyVideosDelete:

                MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: generating KVcxMessageMyVideosDeleteResp");

                messageId = KVcxMessageMyVideosDeleteResp;

                break;

            default:

                MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: no resp msg for this operation");

                return;

            }

        // generates response array and resp message

        for ( TInt i = iCurrentOperationIndex; i < iOperationIdArray.Count(); i++ )

            {

            iOperationResult.Append( aErr );

            }

        iCurrentOperationIndex = 0;

        SendOperationRespL( messageId );

        }

    else

        {

        MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: no move,copy or delete operations were going on (nor anything else)");

        User::Leave( KErrNotFound );

        }

    }

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

// CVcxMyVideosAsyncFileOperations::SendOperationRespL

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

//

void CVcxMyVideosAsyncFileOperations::SendOperationRespL( TInt aCmdId )

    {

    CMPXMessage* message = TVcxMyVideosCollectionUtil::CreateEmptyMediaListL();

    CleanupStack::PushL( message ); // 1->

    CMPXMediaArray* messageArray = message->Value<CMPXMediaArray>(

            KMPXMediaArrayContents );

    message->SetTObjectValueL<TUid>(KMPXMessageCollectionId,

            TUid::Uid(KVcxUidMyVideosMpxCollection));        

    // Add results

    CMPXMedia* media;

    TInt count = iOperationIdArray.Count();

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

        {

        MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: item added to array");

        media = CMPXMedia::NewL();

        CleanupStack::PushL( media ); // 2->

        media->SetTObjectValueL<TMPXItemId>( KMPXMediaGeneralId,

                TMPXItemId( iOperationIdArray[i], 0) );

        media->SetTObjectValueL<TInt32>( KVcxMediaMyVideosInt32Value,

                iOperationResult[i] );

        messageArray->AppendL( media );

        CleanupStack::Pop( media ); // <-2                            

        }

    // Set message attributes

    //

    message->SetTObjectValueL<TMPXMessageId>( KMPXMessageGeneralId,

            TMPXItemId( KVcxCommandIdMyVideos, 0 ));

    message->SetTObjectValueL<TInt>( KVcxMediaMyVideosCommandId, aCmdId );

    iCollection.iMessageList->AddL( message );

    CleanupStack::Pop( message ); // <-1

    iCollection.iMessageList->SendL();

    }

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

// CVcxMyVideosAsyncFileOperations::MoveOrCopyVideoL

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

//

void CVcxMyVideosAsyncFileOperations::MoveOrCopyVideoL( TUint32 aMdsId, TInt aTargetDrive )

    {

    if ( iFileCopier->CopyIsOngoing() )

        {

        TInt err = iFileCopier->DoNextBlockCopy();

        if ( err != KErrNone || !iFileCopier->CopyIsOngoing() )

            {

            HandleFileCopyCompletedL( err );

            }

        return;

        }

    //New file copy starts -> do sanity checks and mds and collection preparations

    InitSingleMoveOrCopyL( aMdsId, aTargetDrive );

    MPX_DEBUG2("CVcxMyVideosAsyncFileOperations:: copying: %S", &iSourcePath);

    MPX_DEBUG2("CVcxMyVideosAsyncFileOperations:: to     : %S", &iTargetPath);

    TBool completed = ETrue; // set to avoid warning

    TRAPD( err, completed = iFileCopier->CopyL( iSourcePath, iTargetPath ) );

    if ( completed || err )

        {

        HandleFileCopyCompletedL( err );

        }

    }    

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

// CVcxMyVideosAsyncFileOperations::InitSingleMoveOrCopyL

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

//

void CVcxMyVideosAsyncFileOperations::InitSingleMoveOrCopyL( TUint32 aMdsId, TInt aTargetDrive )

    {

    //get media from cache or mds

    TInt pos;

    CMPXMedia* videoInCache = iCollection.iCache->FindVideoByMdsIdL( aMdsId, pos );

    CMPXMedia* video = NULL;

    if ( videoInCache )

        {

        video = CMPXMedia::NewL( *videoInCache );

        }

    if ( !video )

        {

        video = iCollection.iMyVideosMdsDb->CreateVideoL( aMdsId, EFalse /* brief details */ );

        }

    if ( !video )

        {

        MPX_DEBUG2("CVcxMyVideosAsyncFileOperations:: mds id %d not found from mds or cache", aMdsId);

        User::Leave( KErrNotFound );

        }

    CleanupStack::PushL( video ); // 1->

    // sanity checks

    if ( video->ValueTObjectL<TUint32>( KVcxMediaMyVideosDownloadId ) != 0 )

        {

        MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: file is being downloaded, fail, leaving with KErrInUse code.");

        User::Leave( KErrInUse );

        }

    iSourcePath = video->ValueText( KMPXMediaGeneralUri );

    if ( !DriveHasEnoughFreeSpaceL( iSourcePath, aTargetDrive ) )

        {

        MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: target drive full -> skipping");

        User::Leave( KErrDiskFull );

        }

    TUint att = 0;

    iCollection.iFs.Att( iSourcePath, att);    

    if ( iIsMoveOperation && (att & KEntryAttReadOnly) )

        {