/*

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

*

*/

// INCLUDE FILES

#include <bldvariant.hrh>

#include "IptvDebug.h"

#include "CIptvMediaContent.h"

#include "IptvLiveDataStructures.h"

#include <mpxmediageneraldefs.h>

#include <mpxitemid.h>

#include <mpxmedia.h>

#include "CIptvUtil.h" 

#include "CIptvMyVideosGlobalFileId.h"

#include "MIptvVodContentClientObserver.h"

#include "CIptvVodContentContentBriefDetails.h"

#include "CIptvVodContentContentFullDetails.h"

#include "CIptvVodContentClient.h"

#include "vcxnsserviceprovider.h"

#include "vcxnscontentproviderobserver.h"

#include "vcxnscontentclienthandler.h"

#include "vcxnsmpxcollectionclienthandler.h"

#include "vcxnscontentprovider.h"

#include "vcxnscategoryprovider.h"

#include "vcxnsuiengine.h"

#include "vcxnscontent.h"

#include "vcxnscontentaccess.h"

#include "vcxnsdatalist.h"

// CONSTS

const TInt KMaxContentHistory = 50; 

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

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

// CVcxNsContentProvider::CVcxNsContentProvider()

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

//

CVcxNsContentProvider::CVcxNsContentProvider( CVcxNsUiEngine& aUiEngine ) :

    iUiEngine( aUiEngine )

    {

    }

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

// CVcxNsContentProvider::NewL()

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

//

CVcxNsContentProvider* CVcxNsContentProvider::NewL( CVcxNsUiEngine& aUiEngine )

    {

    IPTVLOGSTRING_HIGH_LEVEL("UI Engine ## CVcxNsContentProvider::NewL()");

    return new (ELeave) CVcxNsContentProvider( aUiEngine );

    }

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

// CVcxNsContentProvider::~CVcxNsContentProvider()

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

//

CVcxNsContentProvider::~CVcxNsContentProvider()

    {

    iContentObservers.Reset();

    iContentListList.ResetAndDestroy();

    }

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

// Get contents for active service and active category

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

//

RPointerArray<CVcxNsContent>& CVcxNsContentProvider::GetContentsL( TInt& aHighlight )

    {

    //Check if current state is content state and last state was category state:

    if ( iUiEngine.CategoryProvider() )

        {

        aHighlight = iUiEngine.CategoryProvider()->GetCurrentHighlightL();

        }

    else

        {

        aHighlight = 0;

        }

    return GetContentsL();

    }

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

// CVcxNsContentProvider::GetContentsL()

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

//

RPointerArray<CVcxNsContent>& CVcxNsContentProvider::GetContentsL()

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsContentProvider::GetContentsL");

    //  Dl list does not need to be updated, if fetching same old list again. 

    if( iPreviousList &&

        iPreviousList->iServiceId == iUiEngine.ActiveService() &&

        iPreviousList->iCategoryId == iUiEngine.ActiveCategory() )

        {

        return iPreviousList->iArray;

        }

    CVcxNsContentList* list = NULL;    

    list = GetListFromCache();

    if( !list )

        {

        // Reset old download list, items might not be visible anymore.

        iUiEngine.GetMpxCollectionClientHandlerL()->ResetDownloadList(

                EFalse /* don't reset commands from content items */);

        list = LoadEpgDataL();

        BuildDownloadListL( list->iArray );

        iUiEngine.GetMpxCollectionClientHandlerL()->LoadMpxMediaObjectsL();

        }

    else

        {

        // Reset old download list, items might not be visible anymore.

        iUiEngine.GetMpxCollectionClientHandlerL()->ResetDownloadList(

                ETrue /* reset commands from content items */);

        BuildDownloadListL( list->iArray );

        }

    iPreviousList = list;

    return list->iArray;

    }

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

// CVcxNsContentProvider::RefreshContentsL()

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

//

TInt CVcxNsContentProvider::RefreshContentsL()

    {

    return iUiEngine.GetContentClientHandlerL()->UpdateEcgL( iUiEngine.ActiveService() );

    }

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

// CVcxNsContentProvider::StartDownloadL()

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

//

TInt CVcxNsContentProvider::StartDownloadL( TInt aIndex )

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsContentProvider::StartDownloadL");

    CVcxNsService* service = ( iUiEngine.GetServiceProviderL()->GetActiveServiceData() );

    CVcxNsContent* content = NULL;

    RPointerArray<CVcxNsContent>& contents = GetContentsL();

    if( service && aIndex >= 0 && aIndex < contents.Count() )

	    {

	    content = contents[aIndex];

	    }

    else

        {

        return KErrArgument;

        }

    TInt retVal( KErrNotFound );

    if( service && content )

        {

        retVal = iUiEngine.GetMpxCollectionClientHandlerL()->DownloadL( *service, *content );

        }

    return retVal;

    }

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

// CVcxNsContentProvider::PauseDownloadL()

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

//

TInt CVcxNsContentProvider::PauseDownloadL( TInt aIndex )

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsContentProvider::PauseDownloadL");

    CVcxNsContent* content = NULL;

    RPointerArray<CVcxNsContent>& contents = GetContentsL();

    if( aIndex >= 0 && aIndex < contents.Count() )

        {

        content = contents[aIndex];

        }

    else

        {

        return KErrArgument;

        }

    TInt retVal( KErrNotFound );

    if( content )

        {

        retVal = iUiEngine.GetMpxCollectionClientHandlerL()->PauseDownloadL( *content );

        }

    return retVal;

    }

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

// CVcxNsContentProvider::ResumeDownloadL()

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

//

TInt CVcxNsContentProvider::ResumeDownloadL( TInt aIndex )

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsContentProvider::ResumeDownloadL");

    CVcxNsContent* content = NULL;

    RPointerArray<CVcxNsContent>& contents = GetContentsL();

    if( aIndex >= 0 && aIndex < contents.Count() )

        {

        content = contents[aIndex];

        }

    else

        {

        return KErrArgument;

        }

    TInt retVal( KErrNotFound );

    if( content )

        {

        retVal = iUiEngine.GetMpxCollectionClientHandlerL()->ResumeDownloadL( *content );

        }

    return retVal;

    }

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

// CVcxNsContentProvider::ResumeDownloadL()

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

//

TInt CVcxNsContentProvider::ResumeDownloadL( CVcxNsContent& aContent )

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsContentProvider::ResumeDownloadL()");

    if ( iUiEngine.ServiceProvider() )

        {

        return iUiEngine.GetMpxCollectionClientHandlerL()->ResumeDownloadL( aContent );

        }

    return KErrGeneral;

    }

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

// CVcxNsContentProvider::CancelDownloadL()

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

//

TInt CVcxNsContentProvider::CancelDownloadL( TInt aIndex )

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsContentProvider::CancelDownloadL");

    CVcxNsContent* content = NULL;

    RPointerArray<CVcxNsContent>& contents = GetContentsL();

    if( aIndex >= 0 && aIndex < contents.Count() )

        {

        content = contents[aIndex];

        }

    else

        {

        return KErrArgument;

        }

    TInt retVal( KErrNotFound );

    if( content )

        {

        retVal = iUiEngine.GetMpxCollectionClientHandlerL()->CancelDownloadL( *content );

        }

    return retVal;

    }

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

// CVcxNsContentProvider::RemoveServiceData

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

//

void CVcxNsContentProvider::RemoveServiceData( TUint32 aServiceId )

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsContentProvider::RemoveServiceData");

    if( iPreviousList && iPreviousList->iServiceId == aServiceId )

        {

        iPreviousList = NULL;

        }

    for( TInt k = 0; k < iContentListList.Count(); k++ )

        {

        if( (iContentListList[k])->iServiceId == aServiceId )

            {

            delete (iContentListList[k]);

            iContentListList.Remove( k );

            iContentListList.Compress();

            }

        }

    }

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

// CVcxNsContentProvider::RemoveCategoryData

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

//

void CVcxNsContentProvider::RemoveCategoryData( 

    TUint32 aServiceId, 

    TUint32 aCategoryId )

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsContentProvider::RemoveCategoryData");

    if( iPreviousList && iPreviousList->iServiceId == aServiceId )

        {

        iPreviousList = NULL;

        }

    for( TInt k = 0; k < iContentListList.Count(); k++ )

        {

        if( (iContentListList[k])->iServiceId == aServiceId

                && (iContentListList[k])->iCategoryId == aCategoryId )

            {

            delete (iContentListList[k]);

            iContentListList.Remove( k );

            iContentListList.Compress();

            }

        }

    }

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

// CVcxNsContentProvider::RegisterObserver()

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

//

void CVcxNsContentProvider::RegisterObserver( MVcxNsContentProviderObserver* aObserver )

    {

    for ( TInt i = 0; i < iContentObservers.Count(); i++ )

        {

        if( iContentObservers[i] == aObserver )

            {

            return;

            }

        }

    iContentObservers.Append( aObserver );

    }

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

// CVcxNsContentProvider::DeRegisterObserver()

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

//

void CVcxNsContentProvider::DeRegisterObserver( MVcxNsContentProviderObserver* aObserver )

    {

    for ( TInt i = 0; i < iContentObservers.Count(); i++ )

        {

        if( iContentObservers[i] == aObserver )

            {

            iContentObservers.Remove( i );

            iContentObservers.Compress();

            }

        }

    }

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

// CVcxNsContentProvider::ContentUpdated()

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

//

void CVcxNsContentProvider::ContentUpdated( TInt aIndex )

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsContentProvider::ContentUpdated");

    for ( TInt i = 0; i < iContentObservers.Count(); i++ )

        {

        if( iContentObservers[i] )

            {

            iContentObservers[i]->ContentUpdated( aIndex );

            }

        }

    }

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

// CVcxNsContentProvider::RefreshView()

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

//

void CVcxNsContentProvider::RefreshView()

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsContentProvider::RefreshView");

    for ( TInt i = 0; i < iContentObservers.Count(); i++ )

        {

        if( iContentObservers[i] )

            {

            iContentObservers[i]->RefreshView();

            }

        }

    }

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

// CVcxNsContentProvider::UpdateIconsPathL()

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

//

void CVcxNsContentProvider::UpdateIconsPathL()

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsContentProvider::UpdateIconsPathL");

    CVcxNsContentList* list = NULL; 

    list = LoadEpgDataL();

    if ( list && iPreviousList )

        {

        for ( TInt i = 0; i < list->iArray.Count(); i++ )

            {

            for ( TInt j = 0; j < iPreviousList->iArray.Count(); j++ )

                {

                if ( ( iPreviousList->iArray[j]->GetContentId() == list->iArray[i]->GetContentId() ) && 

                     ( iPreviousList->iArray[j]->GetServiceId() == list->iArray[i]->GetServiceId() ) )

                    {

                    iPreviousList->iArray[j]->SetIconPathL( list->iArray[i]->GetIconPath() );        

                    break;

                    }

                }       

            }

        }

    }

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

// CVcxNsContentProvider::HandleAppStateChanged()

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

//

void CVcxNsContentProvider::HandleAppStateChangedL()

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsContentProvider::HandleAppStateChangedL");

    for ( TInt i = 0; i < iContentObservers.Count(); i++ )

        {

        if( iContentObservers[i] )

            {

            iContentObservers[i]->HandleAppStateChangedL();

            }

        }

    }

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

// CVcxNsContentProvider::SearchContentByUri()

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

//

CVcxNsContent* CVcxNsContentProvider::SearchContentByUri( const TDesC& aUri )

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsContentProvider::SearchContentByUri IN");

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

        {

        // improve nested loops

        for( TInt j = (iContentListList[i])->iArray.Count()-1; j >= 0 ; j-- )

            {

            TPtrC contentUri = TPtrC( ((iContentListList[i])->iArray[j])->GetUrl( CVcxNsContent::EVcxContentTypeVideo ) );

            if ( contentUri.CompareF( aUri ) == 0 )

                {

                IPTVLOGSTRING_LOW_LEVEL("CVcxNsContentProvider::SearchContentByUri OUT");

                return (iContentListList[i])->iArray[j];

                }

            }

        }

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsContentProvider::SearchContentByUri OUT");

    return NULL;

    }

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

// CVcxNsContentProvider::SearchContentByMpxId()

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

//

CVcxNsContent* CVcxNsContentProvider::SearchContentByMpxId( TMPXItemId aItemId )

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsContentProvider::SearchContentByMpxId IN");

    CVcxNsContent* content = NULL;

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

        {

        for( TInt j = (iContentListList[i])->iArray.Count()-1; j >= 0 ; j-- )

            {

            CMPXMedia* media = ((iContentListList[i])->iArray[j])->GetMpxMedia( CVcxNsContent::EVcxContentTypeVideo );

            TUint32 mediaId = aItemId.iId1;

            if( media )

                {

                TUint32 contentsId = media->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ).iId1;

                if ( mediaId == contentsId )

                    {

                    content = (iContentListList[i])->iArray[j];

                    IPTVLOGSTRING_LOW_LEVEL("CVcxNsContentProvider::SearchContentByMpxId OUT, id found from mpx data");

				    return content;

                    }

                }

            else if ( ((iContentListList[i])->iArray[j])->GetMpxId( CVcxNsContent::EVcxContentTypeVideo ) && 

                      ((iContentListList[i])->iArray[j])->GetMpxId( CVcxNsContent::EVcxContentTypeVideo ) == mediaId )

                {

                content = (iContentListList[i])->iArray[j];

                IPTVLOGSTRING_LOW_LEVEL("CVcxNsContentProvider::SearchContentByMpxId OUT, found by stored mpx id ");

                return content;

                }

            }

        }

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsContentProvider::SearchContentByMpxId OUT");

    return NULL;

    }

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

// CVcxNsContentProvider::SearchContentById()

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

//

CVcxNsContent* CVcxNsContentProvider::SearchContentById( TUint32 aServiceId, 

                                                         TUint32 aContentId )

    {

    // improve nested loops