/*

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

#include "vcxmyvideosalbums.h"

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

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

// constructor.

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

//

TVcxMyVideosVideo::TVcxMyVideosVideo()

:iMdsId( 0 ), iVideo( NULL ), iPos( KErrNotFound )

    {

    }

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

// TVcxMyVideosVideo::operator=

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

//                

TVcxMyVideosVideo& TVcxMyVideosVideo::operator=( const TVcxMyVideosVideo& aVideo )

    {

    Set( aVideo.iMdsId, aVideo.iPos, aVideo.iVideo );

    return *this;

    }

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

// TVcxMyVideosVideo::Set

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

//

void TVcxMyVideosVideo::Set( TUint32 aMdsId, TInt aPos, CMPXMedia* aVideo )

    {

    iMdsId = aMdsId;

    iPos   = aPos;

    iVideo = aVideo;

    }

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

// CVcxMyVideosVideoListIndex::NewL

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

//

CVcxMyVideosVideoListIndex* CVcxMyVideosVideoListIndex::NewL()

    {

    CVcxMyVideosVideoListIndex* self = new (ELeave) CVcxMyVideosVideoListIndex();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;    

    }

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

// CVcxMyVideosVideoListIndex::CVcxMyVideosVideoListIndex

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

//

CVcxMyVideosVideoListIndex::CVcxMyVideosVideoListIndex()

    {

    }

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

// CVcxMyVideosVideoListIndex::ConstructL

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

//

void CVcxMyVideosVideoListIndex::ConstructL ()

    {

    iVideoArray.Reset();

    }

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

// CVcxMyVideosVideoListIndex::~CVcxMyVideosVideoListIndex

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

//

CVcxMyVideosVideoListIndex::~CVcxMyVideosVideoListIndex()

    {

    iVideoArray.Close();

    }

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

// CVcxMyVideosVideoListIndex::~CVcxMyVideosVideoListIndex

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

//

void CVcxMyVideosVideoListIndex::SetL( const CMPXMedia& aVideoList )

    {

    CMPXMediaArray* mediaArray = TVcxMyVideosCollectionUtil::MediaArrayL( aVideoList );

    TInt count = mediaArray->Count();

    iVideoArray.Reset();

    iVideoArray.ReserveL( count );

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

        {

        AddL( mediaArray->AtL( i ), i );

        }

    }

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

// CVcxMyVideosVideoListIndex::Find

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

//

TInt CVcxMyVideosVideoListIndex::Find( TUint32 aMdsId, TVcxMyVideosVideo& aVideo )

    {

    const TLinearOrder<TVcxMyVideosVideo> KOrderByMdsId(

            CVcxMyVideosVideoListIndex::CompareVideosByMdsId );

    TInt index;

    TVcxMyVideosVideo video;

    video.iMdsId = aMdsId;

    TInt err = iVideoArray.FindInOrder( video, index, KOrderByMdsId );

    if ( err != KErrNone )

        {

        return KErrNotFound;

        }

    aVideo = iVideoArray[index];

    return KErrNone;

    }

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

// CVcxMyVideosVideoListIndex::Remove

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

//

TInt CVcxMyVideosVideoListIndex::Remove( TUint32 aMdsId, TBool aCompress )

    {

    const TLinearOrder<TVcxMyVideosVideo> KOrderByMdsId(

            CVcxMyVideosVideoListIndex::CompareVideosByMdsId );

    TVcxMyVideosVideo video;

    video.iMdsId = aMdsId;

    TInt pos;

    TInt posInVideoList;

    TInt err = iVideoArray.FindInOrder( video, pos, KOrderByMdsId );

    if ( err == KErrNone )

        {

        posInVideoList = iVideoArray[pos].iPos;

        iVideoArray.Remove( pos );

        // update all indexes which are bigger than posInVideoList

        TInt count = iVideoArray.Count();

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

            {

            if ( iVideoArray[i].iPos > posInVideoList )

                {

                iVideoArray[i].iPos--;

                }

            }

        }

    if ( aCompress )

        {

        iVideoArray.Compress();

        }

    return err;

    }

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

// CVcxMyVideosVideoListIndex::AddL

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

//

void CVcxMyVideosVideoListIndex::AddL( CMPXMedia* aVideo, TInt aPos )

    {

    TVcxMyVideosVideo video;

    video.Set( TVcxMyVideosCollectionUtil::IdL( *aVideo ).iId1, aPos, aVideo );

    const TLinearOrder<TVcxMyVideosVideo> KOrderByMdsId(

            CVcxMyVideosVideoListIndex::CompareVideosByMdsId );

    // update indexes

    TInt count = iVideoArray.Count();

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

        {

        if ( iVideoArray[i].iPos >= aPos )

            {

            iVideoArray[i].iPos++;

            }

        }

    iVideoArray.InsertInOrderAllowRepeatsL( video, KOrderByMdsId );

    }

#ifdef _DEBUG

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

// CVcxMyVideosVideoListIndex::VideoArray

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

//

const RArray<TVcxMyVideosVideo>& CVcxMyVideosVideoListIndex::VideoArray()

    {

    return iVideoArray;

    }

#endif

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

// CVcxMyVideosVideoListIndex::Sort

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

//

void CVcxMyVideosVideoListIndex::Sort()

    {

    const TLinearOrder<TVcxMyVideosVideo> KOrderByMdsId(

            CVcxMyVideosVideoListIndex::CompareVideosByMdsId );

    iVideoArray.Sort( KOrderByMdsId );    

    }

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

// CVcxMyVideosVideoListIndex::CompareVideosByMdsId

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

//

TInt CVcxMyVideosVideoListIndex::CompareVideosByMdsId( const TVcxMyVideosVideo& aVideo1,

            const TVcxMyVideosVideo& aVideo2 )

    {

    if ( aVideo1.iMdsId == aVideo2.iMdsId )

        {

        return 0;

        }

    if ( aVideo1.iMdsId < aVideo2.iMdsId )

        {

        return -1;

        }

    return 1;    

    }

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

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

    delete iVideoListIndex;

    }

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

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

    SetComplete( EFalse );

    iPartialVideoList.Reset();

    iVideoListIndex = CVcxMyVideosVideoListIndex::NewL();

    }

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

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

        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;

        }

    if ( IsComplete() )

        {

        TVcxMyVideosVideo video;

        TInt pos = iVideoListIndex->Find( aMdsId, video );

        if ( pos != KErrNotFound )

            {

            aPos = video.iPos;

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

            return video.iVideo;

            }

        }

    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;

    }

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

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