/*

* 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"

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

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

// Two-phased constructor.

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

//

CVcxMyVideosAsyncFileOperations* CVcxMyVideosAsyncFileOperations::NewL(

    CVcxMyVideosCollectionPlugin& aCollection )

    {

    MPX_FUNC("CVcxMyVideosAsyncFileOperations::NewL");

    CVcxMyVideosAsyncFileOperations* self = new (ELeave) CVcxMyVideosAsyncFileOperations(

            aCollection );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// Destructor.

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

//

CVcxMyVideosAsyncFileOperations::~CVcxMyVideosAsyncFileOperations()

    {

    MPX_FUNC("CVcxMyVideosAsyncFileOperations::~CVcxMyVideosAsyncFileOperations");

    iOperationIdArray.Close();

    iOperationResult.Close();

    }

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

// Constructor.

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

//

CVcxMyVideosAsyncFileOperations::CVcxMyVideosAsyncFileOperations( CVcxMyVideosCollectionPlugin& aCollection )

: iCollection( aCollection )

    {

    MPX_FUNC("CVcxMyVideosAsyncFileOperations::CVcxMyVideosAsyncFileOperations");

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CVcxMyVideosAsyncFileOperations::ConstructL ()

    {

    MPX_FUNC("CVcxMyVideosAsyncFileOperations::ConstructL");

    }

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

// 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()

    {

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

    TBool done;

    TBool isMoveOperation = EFalse;    

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

    if ( cmdId == KVcxCommandMyVideosMove )

        {

        MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: move operation");

        isMoveOperation = ETrue;

        }

    // Start operations

    if ( iCurrentOperationIndex == 0 )

        {

        if ( !cmd.IsSupported( KMPXMediaArrayContents ) )

            {

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

            User::Leave( KErrArgument );

            }

        CMPXMediaArray* idMediaArray = cmd.Value<CMPXMediaArray>(

                KMPXMediaArrayContents );

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

            {

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

            User::Leave( KErrArgument );

            }

        iTargetDrive = cmd.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, &cmd );

        iOperationResult.Reset();

        }

    TRAPD( err, MoveOrCopyVideoL( iOperationIdArray[iCurrentOperationIndex],

            iTargetDrive, isMoveOperation ));

    iOperationResult.AppendL( err );

    iCurrentOperationIndex++;

    // End operations

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

        {

        iCurrentOperationIndex = 0;

        done                   = ETrue;

        if ( isMoveOperation )

            {

            SendOperationRespL( KVcxMessageMyVideosMoveResp );

            }

        else

            {

            SendOperationRespL( KVcxMessageMyVideosCopyResp );

            }

        }

    else

        {

        done = EFalse;

        }

    return done;

    }

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

// 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;

                break;

            case KVcxCommandMyVideosCopy:

                MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: generating KVcxMessageMyVideosCopyResp");

                messageId = KVcxMessageMyVideosCopyResp;

                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,

        TBool aMove )

    {

    MPX_FUNC("CVcxMyVideosAsyncFileOperations::MoveOrCopyVideoL");

    MPX_DEBUG2("CVcxMyVideosAsyncFileOperations:: mds id = %d", aMdsId);

    //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 );

        }

    const TInt KMaxPathLength = 255;    

    TBuf<KMaxPathLength> sourcePath( video->ValueText( KMPXMediaGeneralUri ) );

    MPX_DEBUG2("CVcxMyVideosAsyncFileOperations:: source path = %S", &sourcePath);

    if ( !DriveHasEnoughFreeSpaceL( sourcePath, aTargetDrive ) )

        {

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

        User::Leave( KErrDiskFull );

        }

    TInt sourceDrive;

    User::LeaveIfError( iCollection.iFs.CharToDrive( sourcePath[0], sourceDrive ) );

    if ( sourceDrive == aTargetDrive )

        {

        MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: source and target drives are the same, doing nothing.");

        CleanupStack::PopAndDestroy( video ); // <-1

        return;

        }

    TBuf<KMaxPathLength> targetPath;

    GenerateTargetPathForMoveOrCopyL( sourcePath, targetPath, aTargetDrive );

    MPX_DEBUG2("CVcxMyVideosAsyncFileOperations:: target path = %S", &targetPath );

    // update mds and cache

    CMPXMedia* mediaForMoveOp = NULL;

    CMPXMedia* mediaForCopyOp = NULL;

    if ( aMove )

        {

        // Update existing media.

        // Create new media object with only KMPXMediaGeneralId, and KMPXMediaGeneralUri

        // attributes set, that way update is lighter operation.

        mediaForMoveOp = CMPXMedia::NewL();

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

        mediaForMoveOp->SetTObjectValueL<TMPXItemId>( KMPXMediaGeneralId,

               video->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ) );

        mediaForMoveOp->SetTextValueL( KMPXMediaGeneralUri, targetPath );

        iCollection.SetVideoL( *mediaForMoveOp );

        }

    else

        {

        // Create new media.

        mediaForCopyOp = CMPXMedia::CopyL( *video );

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

        mediaForCopyOp->SetTextValueL( KMPXMediaGeneralUri, targetPath );

        iCollection.AddVideoToMdsAndCacheL( *mediaForCopyOp );

        }

    //copy file, delete original if move case

    TRAPD( err, BaflUtils::EnsurePathExistsL( iCollection.iFs, targetPath ) );

    TUint att = 0;

    iCollection.iFs.Att( sourcePath, att);    

    if ( aMove && (att & KEntryAttReadOnly) )

        {

        MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: move operation and source file is read only -> skipping");

        err = KErrAccessDenied;

        }

    if ( err == KErrNone )

        {

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

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

        err = BaflUtils::CopyFile( iCollection.iFs, sourcePath, targetPath );

        if ( err == KErrNone )

            {

            MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: Copy succeeded");

            if ( aMove )

                {

                MPX_DEBUG1("CVcxMyVideosAsyncFileOperations:: move case");

                err = BaflUtils::DeleteFile( iCollection.iFs, sourcePath );

                if ( err != KErrNone )