/*

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

//       If video list fetching is going on and at the same time add/delete events

//       arrive from mds, what to do?

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

    iVideoListIsPartial = ETrue;

    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

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

//

    {

    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;

    }

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

// CVcxMyVideosVideoCache::AddVideosFromMdsL

// Called when item inserted events arrive from mds or from

// KVcxCommandMyVideosGetMediasByMpxId cmd handler.

// If mpx item is already in cache, or MDS does not contain the item (or was not video item),

// then it is removed from aMdsIds. Ie after this function call aMdsIds contains

// only IDs which are actually added to cache. aNonVideoIds will contain IDs

// which were not video objects.

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

//    

void CVcxMyVideosVideoCache::AddVideosFromMdsL( RArray<TUint32>& aMdsIds,

        TBool& aListFetchingWasCanceled, RArray<TUint32>* aNonVideoIds  )

    {

    MPX_FUNC("CVcxMyVideosVideoCache::AddVideosFromMdsL");

    TVcxMyVideosSortingOrder sortingOrder = SortingOrderL();

    aListFetchingWasCanceled = EFalse;

    MPX_DEBUG2("CVcxMyVideosVideoCache:: adding %d items", aMdsIds.Count());

    for ( TInt j = aMdsIds.Count()-1; j >= 0 ; j-- )

        {

        CMPXMedia* videoToCache;

        TInt pos;

        if ( !FindVideoByMdsIdL( aMdsIds[j], pos ) )

            {

            MPX_DEBUG2("CVcxMyVideosVideoCache:: MDSID(%d) not found from cache, ok", aMdsIds[j]);

            //TODO: This doesnt work with new mds cmd queue. Cancel must be done if there is _any_ async req going on.

            //      Maybe the fetching could be changed to asynchronous...

            if ( iCollection.iMyVideosMdsDb->iVideoListFetchingIsOngoing )

                {

                // If list fetching is not canceled, CreateVideoObjectL will leave with KErrNotReady.

                MPX_DEBUG1("CVcxMyVideosVideoCache:: video list fetching is ongoing, canceling it to be able to fetch single items!");

                iCollection.iMyVideosMdsDb->Cancel();

                aListFetchingWasCanceled = ETrue;

                }

            videoToCache = iCollection.iMyVideosMdsDb->CreateVideoL( 

                    aMdsIds[j], EFalse /* brief details */);

            if ( videoToCache )

                {

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

                TInt err = AddL( videoToCache, sortingOrder );

                if ( err == KErrNone )

                    {

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

                    }

                else

                    {

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

                    }

                MPX_DEBUG3("CVcxMyVideosVideoCache:: %d (pointer = %x) added to cache", aMdsIds[j], videoToCache);

                }

            else

                {

                MPX_DEBUG2("CVcxMyVideosVideoCache:: video with %d ID not found from MDS -> prob non video object, skipping add to cache", aMdsIds[j] );

                aMdsIds.Remove( j );

                if ( aNonVideoIds )

                    {

                    aNonVideoIds->AppendL( j );

                    }

                }

            }

        else

            {

            MPX_DEBUG2("CVcxMyVideosVideoCache:: %d was already in cache -> skipping add", aMdsIds[j]);

            aMdsIds.Remove( j );

            }

        }

    }

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

// CVcxMyVideosVideoCache::AddL()

// This is for single adds, video list fetching does not call this.

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

//

TInt CVcxMyVideosVideoCache::AddL( CMPXMedia* aVideo, TVcxMyVideosSortingOrder aSortingOrder )

    {

    MPX_FUNC("CVcxMyVideosVideoCache::AddL");

    if ( iVideoListIsPartial )

        {

        MPX_DEBUG1("CVcxMyVideosVideoCache:: iVideoList is partial, adding to iPartialVideoList");

        return AddToPartialListL( aVideo );

        }

    else

        {

        MPX_DEBUG1("CVcxMyVideosVideoCache:: iVideoList is complete, adding to iVideoList");

        return AddToCorrectPlaceL( *aVideo, aSortingOrder );

        }

    }

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

// CVcxMyVideosVideoCache::CheckForPartialVideoListItemsL()

// This is called by iCollection during video list fetching.

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

//

void CVcxMyVideosVideoCache::CheckForPartialVideoListItemsL( TInt aNewItemsStartIndex )

    {

    // Replace items in iVideoList with iPartialVideoList items.

    if ( !iVideoList || !iVideoList->IsSupported( KMPXMediaArrayContents ) )

        {

        return;

        }

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

                                KMPXMediaArrayContents);

    TInt videoArrayCount = videoArray->Count();

    MPX_DEBUG2("  videoArrayCount           = %d", videoArrayCount);

    MPX_DEBUG2("  iPartialVideoList.Count() = %d", iPartialVideoList.Count());

    for ( TInt i = iPartialVideoList.Count()-1; i >= 0 ; i-- )

        {

        for ( TInt j = aNewItemsStartIndex; j < videoArrayCount; j++ )

            {

            if ( TVcxMyVideosCollectionUtil::IdL( *(iPartialVideoList[i]) )

                    == TVcxMyVideosCollectionUtil::IdL( *(videoArray->AtL( j )) ) )

                {

                // Replace item in iVideoList with item from iPartialVideoList

                MPX_DEBUG2( "CVcxMyVideosVideoCache:: replacing %d, in iVideoList with item from iPartialVideoList",

                        TVcxMyVideosCollectionUtil::IdL( *(iPartialVideoList[i]) ).iId1 );

                if ( j == videoArray->Count() -1 )

                    {

                    videoArray->Remove( j );

                    videoArray->AppendL( iPartialVideoList[i] );

                    }

                else

                    {

                    videoArray->Remove( j );

                    videoArray->Insert( iPartialVideoList[i], j );

                    }

                iPartialVideoList.Remove( i );

                iPartialVideoList.Compress();                    

                break; // found -> break from for loop

                }

            }

        }    

    }

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

// CVcxMyVideosVideoCache::PosOnPartialVideoListL()

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

//

TInt CVcxMyVideosVideoCache::PosOnPartialVideoListL( CMPXMedia& aVideo )

    {

    TInt count    = iPartialVideoList.Count();

    TUint32 mdsId = TVcxMyVideosCollectionUtil::IdL( aVideo );

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

        {

        if ( TVcxMyVideosCollectionUtil::IdL( *(iPartialVideoList[i]) ).iId1 == mdsId )

            {

            return i;

            }        

        }

    return KErrNotFound;

    }

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

// CVcxMyVideosVideoCache::PosOnVideoListL()

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

//

TInt CVcxMyVideosVideoCache::PosOnVideoListL( CMPXMedia& aVideo )

    {

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

            KMPXMediaArrayContents);

    TInt count    = videoArray->Count();

    TUint32 mdsId = TVcxMyVideosCollectionUtil::IdL( aVideo );

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

        {

        if ( TVcxMyVideosCollectionUtil::IdL( *(videoArray->AtL( i )) ).iId1 == mdsId )

            {

            return i;

            }        

        }

    return KErrNotFound;

    }

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

// CVcxMyVideosVideoCache::AddToPartialListL()

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

//

TInt CVcxMyVideosVideoCache::AddToPartialListL( CMPXMedia* aVideo )

    {

    TInt pos = PosOnPartialVideoListL( *aVideo );

    TInt result;

    if ( pos == KErrNotFound )

        {

        iPartialVideoList.Append( aVideo );

        result = KErrNone;

        }

    else

        {

        result = KErrAlreadyExists;

        }

    return result;

    }

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

// CVcxMyVideosVideoCache::DeletePartialList()

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

//

void CVcxMyVideosVideoCache::DeletePartialList()

    {

    TInt count( iPartialVideoList.Count() );

    for ( TInt i = count -1; i >= 0; i-- )

        {

        delete iPartialVideoList[i];

        iPartialVideoList[i] = NULL;

        }

    iPartialVideoList.Close();

    }

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

// CVcxMyVideosVideoCache::CreateVideoListL

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

//

void CVcxMyVideosVideoCache::CreateVideoListL( TBool aForce )

    {

    MPX_FUNC("CVcxMyVideosVideoCache::CreateVideoListL");

    MPX_DEBUG2("CVcxMyVideosVideoCache:: aForce = %d", aForce );

    TVcxMyVideosSortingOrder sortingOrder = SortingOrderL();

    if ( IsFetchingVideoList

            && sortingOrder == iLastSortingOrder && !aForce )

        {