/*

* Copyright (c) 2009 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: 

*

*/

// INCLUDES

#include "VCXTestMyVideosCollectionClient.h"

#include "VCXTestCommon.h"

#include "VCXTestLog.h"

#include "CIptvTestTimer.h"

#include "CIptvTestActiveWait.h"

#include <mpxcollectionutility.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediageneraldefs.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxcollectionmessagedefs.h>

#include <mpxcollectionpath.h>

#include <mpxmessage2.h>

#include <mpxcollectionmessage.h>

#include <mpxmessagecontainerdefs.h>

#include <mpxmediabase.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include <vcxmyvideosdefs.h>

#include <vcxmyvideosuids.h>

// CONSTANTS

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

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

// CVCXTestMyVideosCollectionClient::NewL

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

//

EXPORT_C CVCXTestMyVideosCollectionClient* CVCXTestMyVideosCollectionClient::NewL( MVCXTestMyVideosObserver* aObserver )

    {

    CVCXTestMyVideosCollectionClient* self = new (ELeave) CVCXTestMyVideosCollectionClient( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CVCXTestMyVideosCollectionClient::~CVCXTestMyVideosCollectionClient

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

//

CVCXTestMyVideosCollectionClient::~CVCXTestMyVideosCollectionClient()

     {

     VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::~CVCXTestMyVideosCollectionClient");

     if( iTimer )

         {

         iTimer->CancelTimer();

         delete iTimer;

         iTimer = NULL;

         }

     if( iCollectionUtility )

         {

         iCollectionUtility->Close();

         }

     iCollectionUtility = NULL;

     delete iCurrentEntries;

     iCurrentEntries = NULL;

     if( iMediaArray )

         {

         iMediaArray->Reset();

         delete iMediaArray;

         iMediaArray = NULL;

         }

     iFs.Close();

     iActiveWait->Stop();

     delete iActiveWait;

     iActiveWait = NULL;

     delete iTestCommon;

     iTestCommon = NULL;

     if( iDownloads )

         {

         iDownloads->Reset();

         delete iDownloads;

         iDownloads = NULL;

         }

     if( iVideos ) 

         {

         iVideos->Reset();

         delete iVideos;

         iVideos = NULL;

         }

     iInsertedVideoMdsIds.Reset();

     iOngoingDownloads.Reset();

     iCompletedDownloads.Reset();

     VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::~CVCXTestMyVideosCollectionClient");

     }

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

 // CVCXTestMyVideosCollectionClient::CVCXTestMyVideosCollectionClient

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

 //

CVCXTestMyVideosCollectionClient::CVCXTestMyVideosCollectionClient( MVCXTestMyVideosObserver* aObserver )

 : iObserver( aObserver )

    {

    }

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

// CVCXTestMyVideosCollectionClient::ConstructL

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

//

void CVCXTestMyVideosCollectionClient::ConstructL( )

    {

    VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::ConstructL");

    User::LeaveIfError( iFs.Connect() );

    iCollectionUtility = MMPXCollectionUtility::NewL( this, KMcModeIsolated );

    iTestCommon = CVCXTestCommon::NewL();

    iActiveWait = CIptvTestActiveWait::NewL();

    iTimer = CIptvTestTimer::NewL( *this, 0 );

    iCollectionUid = KVcxUidMyVideosMpxCollection;

    iOpenLevelIndex = -1;

    OpenCollectionL();

    VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::ConstructL");

    }

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

// CVCXTestMyVideosCollectionClient::OpenCollectionL

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

//

EXPORT_C void CVCXTestMyVideosCollectionClient::OpenCollectionL( )

    {

    VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::OpenCollectionL =----->");

    TInt levels = LevelsL();

    if( levels == KVCXTestMpxLevelRoot || levels == 0 )

        {

        VCXLOGLO1("CVCXTestMyVideosCollectionClient:: Opening collection.");

        // Open collection.

        CMPXCollectionPath* path = CMPXCollectionPath::NewL();

        CleanupStack::PushL( path );

        path->AppendL( iCollectionUid );

        iCollectionUtility->Collection().OpenL( *path );

        CleanupStack::PopAndDestroy( path );

        }

    VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::OpenCollectionL");

    }

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

// CVCXTestMyVideosCollectionClient::OpenCollectionLevelL

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

//

EXPORT_C void CVCXTestMyVideosCollectionClient::OpenCollectionLevelL( TUint32 aIndex )

    {

    VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::OpenLevelL =----->");

    TInt levels = LevelsL();

    if( levels == KVCXTestMpxLevelCategory )

        {

        VCXLOGLO1("CVCXTestMyVideosCollectionClient:: Opening category.");

        // Open all videos.

        iOpenLevelIndex = aIndex;

        iCollectionUtility->Collection().OpenL( iOpenLevelIndex );

        }

    VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::OpenLevelL");

    }

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

// CVCXTestMyVideosCollectionClient::RefreshCollectionL

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

//

EXPORT_C void CVCXTestMyVideosCollectionClient::RefreshCollectionL( )

    {

    VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::RefreshCollectionL =----->");

    TInt levels = LevelsL();

    if( levels >= KVCXTestMpxLevelCategory )

        {

        VCXLOGLO1("CVCXTestMyVideosCollectionClient:: Refreshing collection.");

        // Just refresh

        iCollectionUtility->Collection().OpenL();

        }

    VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::RefreshCollectionL");

    }

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

// CVCXTestMyVideosCollectionClient::LevelsL

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

//

EXPORT_C TInt CVCXTestMyVideosCollectionClient::LevelsL()

    {

    if ( iCollectionUtility )

        {

        CMPXCollectionPath* path = iCollectionUtility->Collection().PathL();

        TInt levels = path->Levels();

        delete path;

        VCXLOGLO2("CVCXTestMyVideosCollectionClient:: levels: %d", levels);

        return levels;

        }    

    return KErrNotFound;

    }

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

// CVCXTestMyVideosCollectionClient::UpdateVideoListL

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

//

EXPORT_C void CVCXTestMyVideosCollectionClient::UpdateVideoListL( TBool aComplete )

    {

    if( !iCurrentEntries ) return;

    VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::UpdateVideoListL =----->");

    // Create new list.    

    delete iVideos;

    iVideos = CMPXMediaArray::NewL();        

    TBool isCategoryList( EFalse );

    // Add videos to the list.

    for( TInt i = 0; i < iMediaArray->Count(); i++ )

        {

        CMPXMedia* media = (*iMediaArray)[i];

        TMPXItemId itemId = *(media->Value<TMPXItemId>( KMPXMediaGeneralId ));

        if( itemId.iId2 != 0 )

            {

            isCategoryList = ETrue;

            }

        // Add non downloads and completed downloads to the list.

        if( media->IsSupported( KVcxMediaMyVideosDownloadState ) )

            {

            TUint8 state = 0; 

            state = media->ValueTObjectL<TUint8>( KVcxMediaMyVideosDownloadState );

            if( state == EVcxMyVideosDlStateDownloaded )

                {

                iVideos->AppendL( *media );

                VCXLOGLO3("CVCXTestMyVideosCollectionClient::UpdateVideoListL media is completed download, id: %d, state: %d", itemId.iId1, state);

                }

            else

                {

                VCXLOGLO3("CVCXTestMyVideosCollectionClient::UpdateVideoListL media is downloading, id: %d, state: %d", itemId.iId1, state);

                }

            }

        else

            {

            VCXLOGLO2("CVCXTestMyVideosCollectionClient::UpdateVideoListL media is video, id: %d", itemId.iId1);

            iVideos->AppendL( *media );

            // Send add video event if the video has been just added.

            if( iInsertedVideoMdsIds.Find( itemId.iId1 ) != -1 )

                {

                iObserver->VideoEventL( MVCXTestMyVideosObserver::EVCXTestVideoVideoAdded, itemId.iId1, 0, KErrNone );

                }

            }

        }

    iInsertedVideoMdsIds.Reset();

    if( isCategoryList )

        {

        VCXLOGLO2("CVCXTestMyVideosCollectionClient::UpdateVideoListL Categories (%d): =----->", iVideos->Count());

        }

    else

        {

        VCXLOGLO2("CVCXTestMyVideosCollectionClient::UpdateVideoListL Videos (%d): =----->", iVideos->Count());

        }

    PrintMediasL( iVideos );

    if( aComplete )

        {

        if( !isCategoryList )

            {

            iObserver->VideoEventL( MVCXTestMyVideosObserver::EVCXTestVideoListRefreshed, 0, 0, KErrNone );

            }

        // Open category.

        if( LevelsL() == KVCXTestMpxLevelCategory ) 

            {

            OpenCollectionLevelL( 0 );

            }        

        }

    VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::UpdateVideoListL");

    }

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

// CVCXTestMyVideosCollectionClient::UpdateDownloadListL

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

//

EXPORT_C void CVCXTestMyVideosCollectionClient::UpdateDownloadListL()

    {

    if( LevelsL() != KVCXTestMpxLevelVideo || !iCurrentEntries ) return;

    VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::UpdateDownloadListL =----->");

    TBool ongoingDownloadsChanged( EFalse );    

    TInt iCompletedDownloadsBefore = iCompletedDownloads.Count();

    TInt downloadCountBefore( 0 );

    if( iDownloads )

        {

        downloadCountBefore = iDownloads->Count(); 

        }

    // Create new list.

    delete iDownloads;

    iDownloads = NULL;

    iDownloads = CMPXMediaArray::NewL();

    // Add videos to the list.    

    for( TInt i = 0; i < iMediaArray->Count(); i++ )

        {

        CMPXMedia* media = (*iMediaArray)[i];

        TMPXItemId itemId = *(media->Value<TMPXItemId>( KMPXMediaGeneralId ));

        // Add only downloads which are not complete to the list.

        if( media->IsSupported( KVcxMediaMyVideosDownloadState ) )

            {

            TUint8 state = 0; 

            state = media->ValueTObjectL<TUint8>( KVcxMediaMyVideosDownloadState );

            VCXLOGLO3("CVCXTestMyVideosCollectionClient::UpdateDownloadListL: media mpx id: %d, state: %d", itemId.iId1, state);

            if( state != EVcxMyVideosDlStateDownloaded )

                {

                iDownloads->AppendL( *media );

                }

            if( UpdateDownloadL( media ) )

                {

                ongoingDownloadsChanged = ETrue;

                }

            }

        else

            {

            VCXLOGLO2("CVCXTestMyVideosCollectionClient::UpdateDownloadListL: media mpx id %d is not a download.", itemId.iId1);

            }

        }

    VCXLOGLO4("CVCXTestMyVideosCollectionClient::UpdateDownloadListL: ongoing downloads changed: %d, completed downloads before: %d and now: %d", ongoingDownloadsChanged, iCompletedDownloadsBefore, iCompletedDownloads.Count());

    // Update video list if more downloads have been completed.

    if( iCompletedDownloadsBefore != iCompletedDownloads.Count() )

        {

        UpdateVideoListL( ETrue );

        // Inform client about new video(s).

        TInt newCompletedDownloads = iCompletedDownloads.Count() - iCompletedDownloadsBefore;

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

            {

            TInt index = ( iCompletedDownloads.Count() - 1 ) - i;

            TInt32 mdsId = iCompletedDownloads[ index ].iMdsId;

            iObserver->VideoEventL( MVCXTestMyVideosObserver::EVCXTestVideoVideoAdded, mdsId, 0, KErrNone );

            }

        }

    // Print downloads if they have changed.

    if( ongoingDownloadsChanged || downloadCountBefore != iDownloads->Count())

        {

        VCXLOGLO3("CVCXTestMyVideosCollectionClient:: Downloads (%d, ongoing: %d): =----->", iDownloads->Count(), iOngoingDownloads.Count());

        PrintMediasL( iDownloads );

        if( iOngoingDownloads.Count() == 0 && downloadCountBefore > 0 )

            {

            iObserver->VideoEventL( MVCXTestMyVideosObserver::EVCXTestVideoAllDownloadsCompleted, 0, 0, KErrNone );

            }

        }

    // Start download update timer if there's downloads.

    if( iDownloads->Count() > 0 )

        {

        iTimer->After( 1000000 );

        }

    else

        {

        iTimer->Cancel();

        }

    VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::UpdateDownloadListL");

    }

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

// CVCXTestMyVideosCollectionClient::UpdateMediaArrayL

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

//

EXPORT_C void CVCXTestMyVideosCollectionClient::UpdateMediaArrayL() 

    {

    if( !iCurrentEntries ) return;

    // Reset old medias.

    if( iMediaArray )

        {

        iMediaArray->Reset();

        delete iMediaArray;

        iMediaArray = NULL;

        }

    // Create copies of the current medias.    

    iMediaArray = CMPXMediaArray::NewL();

    CMPXMediaArray* medias = iCurrentEntries->Value<CMPXMediaArray>( KMPXMediaArrayContents );

    // Make copies of the medias.

    for( TInt i=0; i<medias->Count(); i++ )

        {

        CMPXMedia* media(NULL);

        media = (*medias)[i];

        TBool isOnRom( EFalse );

        if( media->IsSupported( KMPXMediaGeneralUri ) )

            {

            const TDesC& url = media->ValueText( KMPXMediaGeneralUri );

            if( url.FindC( _L("z:" ) ) != KErrNotFound )

                {

                isOnRom = ETrue;

                }

            }

        if( !isOnRom )

            {

            iMediaArray->AppendL( *media );

            }

        }

    VCXLOGLO2("CVCXTestMyVideosCollectionClient::UpdateMediaArrayL: iMediaCount: %d", iMediaArray->Count());

    }

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

// CVCXTestMyVideosCollectionClient::PrintMediasL

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

//

EXPORT_C void CVCXTestMyVideosCollectionClient::PrintMediasL( CMPXMediaArray* aMediaArray ) 

    {

    for( TInt i = 0; i < aMediaArray->Count(); i++ )

        {

        CMPXMedia* media = (*aMediaArray)[i];

        TMPXItemId itemId = *(media->Value<TMPXItemId>( KMPXMediaGeneralId ));

        // Category.

        if( itemId.iId2 != 0 )

            {

            TBuf<256> title;

            if( media->IsSupported( KMPXMediaGeneralTitle ) )

                {

                title = media->ValueText( KMPXMediaGeneralTitle );

                }

            TInt itemCount(0);

            TInt newItemCount(0);

            TBuf<256> newItemName;

            if( media->IsSupported( KVcxMediaMyVideosCategoryNewItemName ) )

                {

                newItemName = media->ValueText( KVcxMediaMyVideosCategoryNewItemName );

                }

            if( media->IsSupported( KVcxMediaMyVideosCategoryItemCount ) )

                 {

                 itemCount = *(media->Value<TUint32>( KVcxMediaMyVideosCategoryItemCount ));

                 }

            if( media->IsSupported( KVcxMediaMyVideosCategoryNewItemCount ) )

                 {

                 newItemCount = *(media->Value<TUint32>( KVcxMediaMyVideosCategoryNewItemCount ));

                 }

            VCXLOGLO5("CVCXTestMyVideosCollectionClient: title: %S, medias: %d, new: %d, new media: %S", &title, itemCount, newItemCount, &newItemName);

            }

        // Media.

        else

            {

            HBufC* pathBuff = NULL;

            HBufC* titleBuff = NULL;        

            TInt size(0);

            TInt origin(-1);

            // Download specific.

            HBufC* urlBuff = NULL;        

            TUint8 state = 0; 

            TInt8 progress = 0;

            TUint32 downloadId = 0;

            TInt32 downloadError = 0;

            TInt32 globalError = 0;

            if( media->IsSupported( KVcxMediaMyVideosDownloadState ) )

                {

                state = media->ValueTObjectL<TUint8>( KVcxMediaMyVideosDownloadState );

                }

            if( media->IsSupported( KVcxMediaMyVideosDownloadId ) )

                {

                downloadId = media->ValueTObjectL<TUint32>( KVcxMediaMyVideosDownloadId );