/*

* 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:   Video list cache. Contains cached data from MDS.*

*/

// INCLUDE FILES

#include <mpxlog.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediageneralextdefs.h>

#include <mpxmediacontainerdefs.h>

#include <vcxmyvideosdefs.h>

#include <centralrepository.h>

#include <collate.h>

#include <mpxmediavideodefs.h>

#include "vcxmyvideosvideocache.h"

#include "vcxmyvideoscollectionplugin.h"

#include "vcxmyvideoscollectionutil.h"

#include "vcxmyvideoscategories.h"

#include "vcxmyvideosmessagelist.h"

#include "vcxmyvideosopenhandler.h"

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

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

// Two-phased constructor.

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

//

CVcxMyVideosVideoCache* CVcxMyVideosVideoCache::NewL(

    CVcxMyVideosCollectionPlugin& aMyVideosCollectionPlugin )

    {

    MPX_FUNC("CVcxMyVideosCollectionCache::NewL");

    CVcxMyVideosVideoCache* self = new (ELeave) CVcxMyVideosVideoCache( aMyVideosCollectionPlugin );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// Destructor.

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

//

CVcxMyVideosVideoCache::~CVcxMyVideosVideoCache()

    {

    MPX_FUNC("CVcxMyVideosVideoCache::~CVcxMyVideosVideoCache");

    delete iVideoList;

    DeletePartialList();

    }

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

// Constructor.

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

//

CVcxMyVideosVideoCache::CVcxMyVideosVideoCache(

        CVcxMyVideosCollectionPlugin& aMyVideosCollectionPlugin )

: iCollection( aMyVideosCollectionPlugin )

    {

    MPX_FUNC("CVcxMyVideosVideoCache::CVcxMyVideosVideoCache");

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CVcxMyVideosVideoCache::ConstructL ()

    {

    MPX_FUNC("CVcxMyVideosVideoCache::ConstructL");

    iVideoList          = TVcxMyVideosCollectionUtil::CreateEmptyMediaListL();

    iPartialVideoList.Reset();

    }

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

// CVcxMyVideosVideoCache::CreateVideoListByOriginL

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

//

CMPXMedia* CVcxMyVideosVideoCache::CreateVideoListByOriginL( TUint8 aOrigin )

    {

    MPX_FUNC("CVcxMyVideosVideoCache::CreateVideoListByOriginL()");

    CMPXMediaArray* allVideosArray = NULL;

    TInt allVideosArrayCount       = 0;

    if ( aOrigin == EVcxMyVideosOriginSideLoaded )

        {

        aOrigin = EVcxMyVideosOriginOther;

        }

    allVideosArray = iVideoList->Value<CMPXMediaArray>(

            KMPXMediaArrayContents);

    allVideosArrayCount = allVideosArray->Count();

    MPX_DEBUG2("CVcxMyVideosVideoCache:: iVideoList count = %d", allVideosArrayCount );

    CMPXMedia* filteredVideos =

            TVcxMyVideosCollectionUtil::CreateEmptyMediaListL();

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

    CMPXMediaArray* filteredVideosArray = filteredVideos->Value<CMPXMediaArray>(

            KMPXMediaArrayContents );

    CMPXMedia* media = NULL;

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

        {

        media = (*allVideosArray)[i];

        TUint8 mediaOrigin = EVcxMyVideosOriginOther;

        if ( media->IsSupported( KVcxMediaMyVideosOrigin ) )

            {

            mediaOrigin = *(media->Value<TUint8>( KVcxMediaMyVideosOrigin ));

            if ( mediaOrigin == EVcxMyVideosOriginSideLoaded )

                {

                mediaOrigin = EVcxMyVideosOriginOther;

                }

            }

        if ( mediaOrigin == aOrigin )

            {

            filteredVideosArray->AppendL( *media );

            }

        }

    filteredVideos->SetTObjectValueL( KMPXMediaArrayCount, filteredVideosArray->Count() );

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

    return filteredVideos;

    }

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

// CVcxMyVideosVideoCache::AppendToListL

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

//

void CVcxMyVideosVideoCache::AppendToListL( CMPXMedia& aToList, CMPXMedia& aFromList,

        TUint8 aOrigin, TInt aNewItemsStartIndex )

    {

    MPX_FUNC("CVcxMyVideosVideoCache::AppendToListL()");

    if ( aNewItemsStartIndex < 0 )

        {

        MPX_DEBUG1("CVcxMyVideosVideoCache:: aNewItemsStartIndex < 0 -> skipping");

        return;

        }

    CMPXMediaArray* toArray = aToList.Value<CMPXMediaArray>(

            KMPXMediaArrayContents );

    CMPXMediaArray* fromArray = aFromList.Value<CMPXMediaArray>(

            KMPXMediaArrayContents );

    TInt fromCount = fromArray->Count();

    TInt origin;

    CMPXMedia* media;

    for ( TInt i = aNewItemsStartIndex; i < fromCount; i++ )

        {

        media  = fromArray->AtL( i );

        origin = TVcxMyVideosCollectionUtil::OriginL( *media );

        if ( origin == aOrigin )

            {

            toArray->AppendL( *media );

            } 

        }

    }

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

// CVcxMyVideosVideoCache::FindVideoByUriL

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

//

CMPXMedia* CVcxMyVideosVideoCache::FindVideoByUriL( const TDesC& aUri )

    {    

    CMPXMediaArray* cachedVideoArray = iVideoList->Value<CMPXMediaArray>(

                                KMPXMediaArrayContents);

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

        {       

        if ( (*cachedVideoArray)[i]->ValueText( KVcxMediaMyVideosRemoteUrl ) == aUri )

            {

            return (*cachedVideoArray)[i];

            }

        }

    return NULL;

    }

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

// CVcxMyVideosVideoCache::FindVideoByMdsIdL

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

//

CMPXMedia* CVcxMyVideosVideoCache::FindVideoByMdsIdL( TUint32 aMdsId, TInt& aPos )

    {

    //MPX_FUNC("CVcxMyVideosVideoCache::FindVideoByMdsIdL()");

    //MPX_DEBUG2("CVcxMyVideosVideoCache:: looking for %d MDS ID from cache", aMdsId);

    aPos = KErrNotFound;

    if ( !iVideoList )

        {

        return NULL;

        }

    CMPXMediaArray* cachedVideoArray = iVideoList->Value<CMPXMediaArray>(

                                KMPXMediaArrayContents);

    TMPXItemId mpxItemId;

    CMPXMedia* media;

    TInt count = cachedVideoArray->Count();

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

        {

        media = cachedVideoArray->AtL( i );

        if ( media->IsSupported( KMPXMediaGeneralId ))

            {

            mpxItemId = media->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );

            if ( mpxItemId.iId1 == aMdsId && mpxItemId.iId2 == 0 )

                {

                MPX_DEBUG2("CVcxMyVideosVideoCache::FindVideoByMdsIdL() found %d from iVideoList", aMdsId );

                aPos = i;

                return media;

                }

            }

        }

    count = iPartialVideoList.Count();

    TMPXItemId mpxId;  

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

        {

        mpxId = TVcxMyVideosCollectionUtil::IdL( *(iPartialVideoList[i]) );

        if ( aMdsId ==  mpxId.iId1 )

            {

            MPX_DEBUG2("CVcxMyVideosVideoCache::FindVideoByMdsIdL() found %d from iPartialVideoList", aMdsId );

            MPX_DEBUG1("CVcxMyVideosVideoCache::FindVideoByMdsIdL() returning the pointer and setting aPos to KErrNotFound");

            aPos = KErrNotFound; // this indicates that not found from iVideoList

            return iPartialVideoList[i];

            }       

        }

    MPX_DEBUG2("CVcxMyVideosCollectionPlugin::FindVideoByMdsIdL() MDSID %d NOT FOUND", aMdsId);

    return NULL;

    }

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

// CVcxMyVideosVideoCache::GetVideosL

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

//

CMPXMedia* CVcxMyVideosVideoCache::GetVideosL( RArray<TUint32>& aMdsIds )

    {

    CMPXMessage* videoList = TVcxMyVideosCollectionUtil::CreateEmptyMediaListL();

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

    // copy from iVideoList

    TVcxMyVideosCollectionUtil::CopyFromListToListL(

            *iVideoList, *videoList, aMdsIds );

    // copy from iPartialVideoList

    TVcxMyVideosCollectionUtil::CopyFromListToListL(

            iPartialVideoList, *videoList, aMdsIds );

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

    return videoList;