/*

* 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:    Categories related functionality*

*/

// INCLUDE FILES

#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 "vcxmyvideoscollectionplugin.h"

#include "vcxmyvideoscategories.h"

#include "vcxmyvideoscollectionutil.h"

#include "vcxmyvideosvideocache.h"

#include "vcxmyvideosmessagelist.h"

_LIT(KVcxMyVideosAllVideosCategoryText, "All videos");

_LIT(KVcxMyVideosDownloadsCategoryText, "Downloads");

_LIT(KVcxMyVideosTvRecordingsCategoryText, "TV recordings");

_LIT(KVcxMyVideosCapturedVideosCategoryText, "Captured videos");

_LIT(KVcxMyVideosOtherCategoryText, "Other");

const TInt KVcxMyVideosAllVideosCategoryIndex    = 0;

const TInt KVcxMyVideosDownloadsCategoryIndex    = 1;

const TInt KVcxMyVideosTvRecordingsCategoryIndex = 2;

const TInt KVcxMyVideosCapturedCategoryIndex     = 3;

const TInt KVcxMyVideosOtherCategoryIndex        = 4;

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

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

// Two-phased constructor.

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

//

CVcxMyVideosCategories* CVcxMyVideosCategories::NewL(

    CVcxMyVideosCollectionPlugin& aCollection )

    {

    MPX_FUNC("CVcxMyVideosCategories::NewL");

    CVcxMyVideosCategories* self = new (ELeave) CVcxMyVideosCategories( aCollection );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// Destructor.

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

//

CVcxMyVideosCategories::~CVcxMyVideosCategories()

    {

    MPX_FUNC("CVcxMyVideosCategories::~CVcxMyVideosCategories");

    delete iList;

    iModifiedCategories.Close();

    }

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

// Constructor.

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

//

CVcxMyVideosCategories::CVcxMyVideosCategories( CVcxMyVideosCollectionPlugin& aCollection )

: iCollection( aCollection )

    {

    MPX_FUNC("CVcxMyVideosCategories::CVcxMyVideosCategories");

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CVcxMyVideosCategories::ConstructL ()

    {

    MPX_FUNC("CVcxMyVideosCategories::ConstructL");

    iList      = CreateCategoryListL();

    iListArray = iList->Value<CMPXMediaArray>( KMPXMediaArrayContents );   

    TInt categoryCount = iListArray->Count();

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

        {

        iModifiedCategories.Append( EFalse );

        }

    }

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

// CVcxMyVideosCategories::CreateCategoryListL

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

//

CMPXMedia* CVcxMyVideosCategories::CreateCategoryListL()

    {

    //first level

    CMPXMedia* entries = TVcxMyVideosCollectionUtil::CreateEmptyMediaListL();

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

    entries->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, 0 /*aPath.Id( 0 )*/);

    CMPXMediaArray* entryArray = entries->Value<CMPXMediaArray>( KMPXMediaArrayContents );

    AppendCategoryToArrayL( KVcxMyVideosAllVideosCategoryText,

            TMPXItemId( KVcxMvcCategoryIdAll, 1), *entryArray );

    AppendCategoryToArrayL( KVcxMyVideosDownloadsCategoryText,

            TMPXItemId( KVcxMvcCategoryIdDownloads, 1 ), *entryArray );

    AppendCategoryToArrayL( KVcxMyVideosTvRecordingsCategoryText,

            TMPXItemId( KVcxMvcCategoryIdTvRecordings, 1 ), *entryArray );

    AppendCategoryToArrayL( KVcxMyVideosCapturedVideosCategoryText,

            TMPXItemId( KVcxMvcCategoryIdCaptured, 1), *entryArray );

    AppendCategoryToArrayL( KVcxMyVideosOtherCategoryText,

            TMPXItemId( KVcxMvcCategoryIdOther, 1 ), *entryArray );

    entries->SetTObjectValueL( KMPXMediaArrayCount, entryArray->Count() );

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

    return entries;

    }

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

// CVcxMyVideosCategories::AppendCategoryToArrayL

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

//

void CVcxMyVideosCategories::AppendCategoryToArrayL( const TDesC& aTitle, TMPXItemId aId,

        CMPXMediaArray& aCategoryArray )

    {

    RArray<TInt> supportedIds;

    CleanupClosePushL( supportedIds ); // 1->

    supportedIds.AppendL( KMPXMediaIdGeneral );

    CMPXMedia* category = CMPXMedia::NewL( supportedIds.Array() );

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

    category->SetTextValueL( KMPXMediaGeneralTitle, aTitle );

    category->SetTObjectValueL( KMPXMediaGeneralId, aId );

    category->SetTObjectValueL( KMPXMediaGeneralType, EMPXGroup );

    category->SetTObjectValueL( KMPXMediaGeneralCategory, EMPXNoCategory );

    category->SetTObjectValueL( KVcxMediaMyVideosCategoryItemCount, 0 );

    category->SetTObjectValueL( KVcxMediaMyVideosCategoryNewItemCount, 0 );

    aCategoryArray.AppendL( category );

    CleanupStack::Pop( category );                // <-2

    CleanupStack::PopAndDestroy( &supportedIds ); // <-1

    }

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

// CVcxMyVideosCategories::UpdateCategoriesL

// Called by iCollection when fetching the video list from mds incrementally.

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

//

void CVcxMyVideosCategories::UpdateCategoriesL( CMPXMedia& aVideoList,

        TInt aNewItemsStartIndex )

    {    

    CMPXMediaArray* categoryArray = iList->Value<CMPXMediaArray>( KMPXMediaArrayContents );

    TInt categoryCount            = categoryArray->Count();

    RArray<TInt> videosIncrements;

    videosIncrements.Reset();

    CleanupClosePushL( videosIncrements ); // 1->

    RArray<TInt> newVideosIncrements;

    newVideosIncrements.Reset();

    CleanupClosePushL( newVideosIncrements ); // 2->

    TInt i;

    videosIncrements.ReserveL( categoryCount );

    newVideosIncrements.ReserveL( categoryCount );

    for ( i = 0; i < categoryCount; i++ )

        {

        videosIncrements.AppendL( 0 );

        newVideosIncrements.Append( 0 );

        }

    CMPXMediaArray* videoListArray = aVideoList.Value<CMPXMediaArray>( KMPXMediaArrayContents );

    TInt videoListCount            = videoListArray->Count();

    videosIncrements[KVcxMyVideosAllVideosCategoryIndex] = videoListCount - aNewItemsStartIndex;

    CMPXMedia* media;

    for ( i = aNewItemsStartIndex; i < videoListCount; i++ )

        {

        TUint8 origin = EVcxMyVideosOriginOther;

        media = videoListArray->AtL( i );

        origin = TVcxMyVideosCollectionUtil::OriginL( *media );

        TBool newVideo = EFalse;

        TUint32 flags  = 0;

        if ( media->IsSupported( KMPXMediaGeneralFlags ) )

            {

            flags = media->ValueTObjectL<TUint32>( KMPXMediaGeneralFlags );

            if ( flags & EVcxMyVideosVideoNew )

                {

                newVideo = ETrue;

                newVideosIncrements[KVcxMyVideosAllVideosCategoryIndex]++;

                }

            }

        switch ( origin )

            {

            case EVcxMyVideosOriginDownloaded:

                videosIncrements[KVcxMyVideosDownloadsCategoryIndex]++;

                if ( newVideo )

                    {

                    newVideosIncrements[KVcxMyVideosDownloadsCategoryIndex]++;

                    }

                break;

            case EVcxMyVideosOriginCapturedWithCamera:

                videosIncrements[KVcxMyVideosCapturedCategoryIndex]++;

                if ( newVideo )

                    {

                    newVideosIncrements[KVcxMyVideosCapturedCategoryIndex]++;

                    }

                break;

            case EVcxMyVideosOriginTvRecording:

                videosIncrements[KVcxMyVideosTvRecordingsCategoryIndex]++;

                if ( newVideo )

                    {

                    newVideosIncrements[KVcxMyVideosTvRecordingsCategoryIndex]++;

                    }

                break;

            case EVcxMyVideosOriginSideLoaded:                

            case EVcxMyVideosOriginOther:

            default:

                videosIncrements[KVcxMyVideosOtherCategoryIndex]++;

                if ( newVideo )

                    {

                    newVideosIncrements[KVcxMyVideosOtherCategoryIndex]++;

                    }

                break;

            }

        }

    // Update videos counts

    CleanupStack::PopAndDestroy( &newVideosIncrements ); // <-1

    CleanupStack::PopAndDestroy( &videosIncrements ); // <-1

    }

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

// CVcxMyVideosCategories::UpdateVideosCountL

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

//

void CVcxMyVideosCategories::UpdateVideosCountL( CMPXMediaArray& aCategoryArray,

    {

    TBool modified = EFalse;

    TInt categoryCount = aCategoryArray.Count();

    CMPXMedia* category;

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

        {

            {

            category = aCategoryArray.AtL( i );

            //codescanner warning: aVideosIncrements count is same as aCategoryArray count, so the range is checked

            UpdateVideosCountL( *category, aVideosIncrements[i],

                    KVcxMediaMyVideosCategoryItemCount, EVcxMyVideosListNoInfo );

            modified = ETrue;

            }

        //codescanner warning: aNewVideosIncrements count is same as aCategoryArray count, so the range is checked

            {

            category = aCategoryArray.AtL( i );

            UpdateVideosCountL( *category, aNewVideosIncrements[i],

                    KVcxMediaMyVideosCategoryNewItemCount, EVcxMyVideosListNoInfo );

            modified = ETrue;

            }

        }

    if ( modified )

        {

        iCollection.iMessageList->SendL();

        }

    }

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

// CVcxMyVideosCategories::UpdateVideosCountL

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

//

void CVcxMyVideosCategories::UpdateVideosCountL( CMPXMedia& aCategory,

    TInt aIncrement, TMPXAttributeData aCountAttribute, TInt aEventInfo )

    {

    if ( aIncrement != 0 )

        {

        AddToTUint32AttributeL( aCategory, aIncrement, aCountAttribute );

        }

    }

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

// CVcxMyVideosCategories::VideosAddedL

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

//

void CVcxMyVideosCategories::VideosAddedL( RArray<TUint32>& aIds )

    {

    VideosAddedOrRemovedL( aIds, ETrue );

    }

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

// CVcxMyVideosCategories::VideosRemovedL

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

//

void CVcxMyVideosCategories::VideosRemovedL( RArray<TUint32>& aIds )

    {

    VideosAddedOrRemovedL( aIds, EFalse );

    }

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

// CVcxMyVideosCategories::VideoAddedL

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

//

void CVcxMyVideosCategories::VideoAddedL( TUint32 aMdsId )

    {

    TInt pos( KErrNotFound );

    CMPXMedia* video = iCollection.iCache->FindVideoByMdsIdL( aMdsId, pos );

    if ( pos != KErrNotFound )

        {

        VideoAddedOrRemovedL( *video, ETrue );

        }

    }

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

// CVcxMyVideosCategories::VideoAddedL

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

//

void CVcxMyVideosCategories::VideoAddedL( CMPXMedia& aVideo )

    {

    VideoAddedOrRemovedL( aVideo, ETrue );

    }

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

// CVcxMyVideosCategories::VideoRemovedL

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

//

void CVcxMyVideosCategories::VideoRemovedL( TUint32 aMdsId )

    {

    TInt pos( KErrNotFound );

    CMPXMedia* video = iCollection.iCache->FindVideoByMdsIdL( aMdsId, pos );

    if ( pos != KErrNotFound )

        {

        VideoAddedOrRemovedL( *video, EFalse );

        }

    }

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

// CVcxMyVideosCategories::VideoRemovedL

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

//

void CVcxMyVideosCategories::VideoRemovedL( CMPXMedia& aVideo )

    {

    VideoAddedOrRemovedL( aVideo, EFalse );

    }

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

// CVcxMyVideosCategories::VideosAddedOrRemovedL

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

//

void CVcxMyVideosCategories::VideosAddedOrRemovedL(

        RArray<TUint32>& aIds, TBool aAdded )

    {

    TInt count = aIds.Count();

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

        {

        VideoAddedOrRemovedL( aIds[i], aAdded );

        }

    }

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

// CVcxMyVideosCategories::VideoAddedOrRemovedL

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

//

void CVcxMyVideosCategories::VideoAddedOrRemovedL( TUint32 aMdsId, TBool aAdded )

    {    

    TInt pos( KErrNotFound );

    CMPXMedia* video = iCollection.iCache->FindVideoByMdsIdL( aMdsId, pos );

    if ( pos != KErrNotFound )

        {

        VideoAddedOrRemovedL( *video, aAdded );

        }

    }

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

// CVcxMyVideosCategories::VideoAddedOrRemovedL

// All remove&add calls eventually come here.

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

//

void CVcxMyVideosCategories::VideoAddedOrRemovedL( CMPXMedia& aVideo, TBool aAdded )

    {

    MPX_FUNC("CVcxMyVideosCategories::VideoAddedOrRemovedL()");

    ResetModifiedCategoriesArray();

    TInt categoryIndex  = CategoryIndex( TVcxMyVideosCollectionUtil::OriginL( aVideo ) );

    CMPXMedia* category = iListArray->AtL( categoryIndex );

    // every event updates always 2 categories, all and something else

    UpdateCategoryL( *category, categoryIndex, aVideo, aAdded );

    //iMessageArray will discard duplicates

    AddEventsFromModifiedCategoriesArrayL();

    }

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

// CVcxMyVideosCategories::UpdateCategoryL

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

//

void CVcxMyVideosCategories::UpdateCategoryL( CMPXMedia& aCategory, TInt aCategoryIndex,

        CMPXMedia& aVideo, TBool aAdded )

    {

    MPX_FUNC("CVcxMyVideosCategories::UpdateCategoryL");

    TInt addition = 0;

    if ( aAdded )

        {

        MPX_DEBUG1("CVcxMyVideosCategories:: video added");

        if ( TVcxMyVideosCollectionUtil::FlagsL( aVideo ) & EVcxMyVideosVideoNew )

            {

            TInt64 newItemsDate = TVcxMyVideosCollectionUtil::CreationDateL( aVideo );

            TInt64 prevNewDate  = TVcxMyVideosCollectionUtil::CreationDateL( aCategory );

            if ( static_cast<TInt64>(newItemsDate) > static_cast<TInt64>(prevNewDate) )

                {                    

                MPX_DEBUG1("CVcxMyVideosCategories:: EMPXItemInserted -> changing new video name");

                aCategory.SetTextValueL( KVcxMediaMyVideosCategoryNewItemName,

                        aVideo.ValueText( KMPXMediaGeneralTitle ) );

                aCategory.SetTObjectValueL( KMPXMediaGeneralDate, newItemsDate ); 

                iListArray->AtL( KVcxMyVideosAllVideosCategoryIndex)->SetTextValueL(

                        KVcxMediaMyVideosCategoryNewItemName,

                        aVideo.ValueText( KMPXMediaGeneralTitle ) );

                iListArray->AtL( KVcxMyVideosAllVideosCategoryIndex)->SetTObjectValueL(

                        KMPXMediaGeneralDate, newItemsDate );

                iModifiedCategories[aCategoryIndex]                     = ETrue;

                iModifiedCategories[KVcxMyVideosAllVideosCategoryIndex] = ETrue;

                }

            }

        addition = 1;

        }

    else

        {

        MPX_DEBUG1("CVcxMyVideosCategories:: video deleted");

        TBool modified = EFalse;

        RArray<TUint32> ignoredIds;

        ignoredIds.Reset();

        CleanupClosePushL( ignoredIds ); // 1->

        if ( !aAdded )

            {

            ignoredIds.AppendL( TVcxMyVideosCollectionUtil::IdL( aVideo ) );

            }

        UpdateCategoryNewVideoNameAndDateL( -1 /* -1 origin resolves to All category */,

                modified, ignoredIds );

        UpdateCategoryNewVideoNameAndDateL( TVcxMyVideosCollectionUtil::OriginL( aVideo ),

                modified, ignoredIds );

        CleanupStack::PopAndDestroy( &ignoredIds ); // <-1

        if ( modified )

            {

            iModifiedCategories[aCategoryIndex]                     = ETrue;

            iModifiedCategories[KVcxMyVideosAllVideosCategoryIndex] = ETrue;

            }

        addition = -1;

        }

    if ( addition != 0 )

        {

        AddToTUint32AttributeL( aCategory, addition, KVcxMediaMyVideosCategoryItemCount );

        AddToTUint32AttributeL( *(iListArray->AtL( KVcxMyVideosAllVideosCategoryIndex) ),

                addition, KVcxMediaMyVideosCategoryItemCount );

        if ( TVcxMyVideosCollectionUtil::FlagsL( aVideo ) & EVcxMyVideosVideoNew )

            {

            AddToTUint32AttributeL( aCategory, addition, KVcxMediaMyVideosCategoryNewItemCount );

            AddToTUint32AttributeL( *(iListArray->AtL( KVcxMyVideosAllVideosCategoryIndex) ),

                    addition, KVcxMediaMyVideosCategoryNewItemCount );

            }

        iModifiedCategories[aCategoryIndex]                     = ETrue;

        iModifiedCategories[KVcxMyVideosAllVideosCategoryIndex] = ETrue;

        }

    }

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

// CVcxMyVideosCategories::AddToTUint32AttributeL

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

//

void CVcxMyVideosCategories::AddToTUint32AttributeL( CMPXMedia& aCategory, TInt aAddition,

        TMPXAttributeData aAttribute )

    {

    TUint32 previousCount = 0;

    if ( aCategory.IsSupported( aAttribute ) )

        {

        previousCount = aCategory.ValueTObjectL<TUint32>( aAttribute );

        }