/*

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

*/

#include <aknmessagequerydialog.h>

#include <StringLoader.h>

#include <vcxhgvodui.rsg>

#include <ganes/HgScroller.h>

#include <ganes/HgItem.h>

#include <ganes/HgDoubleGraphicList.h>

#include "vcxnsserviceproviderif.h"

#include "vcxhgvodservicelistmodelhandler.h"

#include "vcxhgvodmainview.h"

#include "vcxhgvodmainviewcontainer.h"

#include "vcxhgvodui.hrh"

#include "vcxhgvodutils.h"

#include "vcxhgvodthumbnailmanager.h"

#include "vcxnsuiengine.h"

#include "vcxnsservice.h"

#include "vcxhgvodservicelistimpl.h"

#include "IptvDebug.h"

TInt FindServiceIndex( TUint32 aId, RPointerArray<CVcxNsService>* aArray )

    {

    TInt index( KErrNotFound );

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

        {

        if ( (*aArray)[i]->GetServiceId() == aId )

            {

            index = i;

            break;

            }

        }

    return index;

    }

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

// CVcxHgVodServiceListModelHandler::~CVcxHgVodServiceListModelHandler()

// Destructor

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

//

CVcxHgVodServiceListModelHandler::~CVcxHgVodServiceListModelHandler()

    {

    if ( iServiceProvider )

        {

        iServiceProvider->DeRegisterObserver( this );

        }

    delete iTnManager;

    }

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

// CVcxHgVodServiceListImpl::NewL()

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

//

CVcxHgVodServiceListModelHandler* CVcxHgVodServiceListModelHandler::NewL( 

    CVcxNsUiEngine& aDataProviderIf,

    CVcxHgVodMainView& aView, 

    CHgScroller& aScroller,

    CVcxHgVodServiceListImpl& aServiceListImpl )

    {

    CVcxHgVodServiceListModelHandler* self = 

        CVcxHgVodServiceListModelHandler::NewLC(  

                aDataProviderIf, 

                aView,

                aScroller,

                aServiceListImpl );

    CleanupStack::Pop( self );

    return self;

    }

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

// CVcxHgVodServiceListModelHandler::NewLC()

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

//

CVcxHgVodServiceListModelHandler* CVcxHgVodServiceListModelHandler::NewLC(

    CVcxNsUiEngine& aDataProviderIf,

    CVcxHgVodMainView& aView, 

    CHgScroller& aScroller,

    CVcxHgVodServiceListImpl& aServiceListImpl )

    {

    CVcxHgVodServiceListModelHandler* self = 

        new (ELeave) CVcxHgVodServiceListModelHandler(  

                aDataProviderIf,

                aView,

                aScroller, 

                aServiceListImpl );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CVcxHgVodServiceListModelHandler::CVcxHgVodServiceListModelHandler()

// Constructor

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

//

CVcxHgVodServiceListModelHandler::CVcxHgVodServiceListModelHandler( 

    CVcxNsUiEngine& aDataProviderIf, 

    CVcxHgVodMainView& aView, 

    CHgScroller& aScroller,

    CVcxHgVodServiceListImpl& aServiceListImpl )

    : iDataProviderIf ( aDataProviderIf ),

      iScroller ( aScroller ),

      iView ( aView ),

      iServiceListImpl ( aServiceListImpl )

    {

    }

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

// CVcxHgVodServiceListModelHandler::ConstructL()

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

//

void CVcxHgVodServiceListModelHandler::ConstructL()

    {

    iServiceProvider = iDataProviderIf.GetServiceProviderL();

    iProgressHandler = iDataProviderIf.ProgressHandlerL();

    iTnManager = CVcxHgVodThumbnailManager::NewL( iView.EikonEnv().FsSession() );

    }

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

// 

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

// 

void CVcxHgVodServiceListModelHandler::ServiceAdded( TInt aIndex )

    {

    IPTVLOGSTRING_LOW_LEVEL(">>>CVcxHgVodServiceListModelHandler::ServiceAdded");

    SetSelected( aIndex );

    IPTVLOGSTRING_LOW_LEVEL("<<<CVcxHgVodServiceListModelHandler::ServiceAdded");

    }

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

// 

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

// 

void CVcxHgVodServiceListModelHandler::ServiceUpdated( TInt aIndex )

    {

    IPTVLOGSTRING_LOW_LEVEL(">>>CVcxHgVodServiceListModelHandler::ServiceUpdated");

    TRAP_IGNORE( UpdateListItemL( aIndex ) );

    IPTVLOGSTRING_LOW_LEVEL("<<<CVcxHgVodServiceListModelHandler::ServiceUpdated");

    }

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

// Refresh view, update all services.

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

// 

void CVcxHgVodServiceListModelHandler::RefreshView()

    {

    IPTVLOGSTRING_LOW_LEVEL(">>>CVcxHgVodServiceListModelHandler::RefreshView");

    if ( iDataProviderIf.VcAppState() == EStateServiceView )

        {

        TRAP_IGNORE( iServices = &(iServiceProvider->GetSubscribedServicesL()) );

        TRAP_IGNORE( RefreshViewL() );

        TRAP_IGNORE( iServiceListImpl.CheckSoftkeysL() );

        }

    IPTVLOGSTRING_LOW_LEVEL("<<<CVcxHgVodServiceListModelHandler::RefreshView");

    }

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

// Application state change initialized by data provider.

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

// 

void CVcxHgVodServiceListModelHandler::HandleAppStateChangedL()

    {

    IPTVLOGSTRING_LOW_LEVEL(">>>CVcxHgVodServiceListModelHandler::HandleAppStateChangedL");

    iView.ChangeListViewL();

    IPTVLOGSTRING_LOW_LEVEL("<<<CVcxHgVodServiceListModelHandler::HandleAppStateChangedL");

    }

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

// Open defined browser link

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

// 

void CVcxHgVodServiceListModelHandler::OpenBrowserLinkL( const TDesC& aUri )

    {

    iServiceListImpl.OpenEmbeddedBrowserL( aUri );

    }

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

// Open player for streaming ( no implementation )

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

// 

    void CVcxHgVodServiceListModelHandler::OpenStreamingLinkL( const TDesC& /*aUri*/ )

    {

    }

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

// Service removed

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

// 

void CVcxHgVodServiceListModelHandler::ServiceRemoved( 

    TInt aIndex, 

    RPointerArray<CVcxNsService>& aUpdatedServiceList )

    {

    IPTVLOGSTRING_LOW_LEVEL(">>>CVcxHgVodServiceListModelHandler::ServiceRemoved");

    if ( iScroller.ItemCount() > 0 

            && iScroller.ItemCount() > aIndex )

        {

        iScroller.RemoveItem( aIndex );

        iScroller.RefreshScreen( aIndex );

        }

    iServices = NULL;

    iServices = &aUpdatedServiceList;

    IPTVLOGSTRING_LOW_LEVEL("<<<CVcxHgVodServiceListModelHandler::ServiceRemoved");

    }

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

// Activate model

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

// 

void CVcxHgVodServiceListModelHandler::DoActivateModelL( )

    {

    IPTVLOGSTRING_LOW_LEVEL(">>>CVcxHgVodServiceListModelHandler::DoActivateModelL");

    iServiceProvider->RegisterObserver( this );

    if ( iProgressHandler )

        {

        iProgressHandler->RegisterObserver( this );

        }

    iScroller.EnableScrollBufferL( *this, KScrollerBufferSize, KScrollerBufferTreshold ); 

    iScroller.Reset();

    RefreshView();

    iScroller.SetSelectedIndex( iHighlight );

    iScroller.ControlEnv()->WsSession().ClearAllRedrawStores();

    iScroller.MakeVisible( ETrue );

    iScroller.DrawDeferred();

    IPTVLOGSTRING_LOW_LEVEL("<<<CVcxHgVodServiceListModelHandler::DoActivateModelL");

    }

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

// Deactivate model

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

// 

void CVcxHgVodServiceListModelHandler::DoDeActivateModel( )

    {

    IPTVLOGSTRING_LOW_LEVEL(">>>CVcxHgVodServiceListModelHandler::DoDeActivateModel");

    if ( iServiceProvider )

        {

        iServiceProvider->DeRegisterObserver( this );

        }

    if ( iProgressHandler )

        {

        iProgressHandler->DeRegisterObserver( this );

        }

    iTnManager->Reset();

    iHighlight = iScroller.SelectedIndex();

    iScroller.DisableScrollBuffer();

    iScroller.MakeVisible( EFalse );

    IPTVLOGSTRING_LOW_LEVEL("<<<CVcxHgVodServiceListModelHandler::DoDeActivateModel");

    }

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

// Get pointer to service provider 

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

// 

MVcxNsServiceProviderIf* CVcxHgVodServiceListModelHandler::ServiceProvider() 

    {

    return iServiceProvider;   

    }

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

//  

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

// 

TInt CVcxHgVodServiceListModelHandler::GetSelected() 

    {

    return iScroller.SelectedIndex();

    }

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

//  

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

// 

void CVcxHgVodServiceListModelHandler::SetSelected( TInt aIndex )

    {

    if( aIndex >= 0 && iScroller.ItemCount() > aIndex )

        {

        iScroller.SetSelectedIndex( aIndex ); 

        }

    }

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

// CVcxHgVodServiceListModelHandler::IsEmptyModel

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

//

TBool CVcxHgVodServiceListModelHandler::IsEmptyModel()

    {

    return iScroller.ItemCount() <= 0;

    }

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

// CVcxHgVodServiceListModelHandler::GenerateServiceInfoTextLC

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

//

HBufC* CVcxHgVodServiceListModelHandler::GenerateServiceInfoTextLC( 

    CVcxNsService::TServiceUpdateStatus aUpdateStatus,

    TTime aUpdateTime )

    {    

    IPTVLOGSTRING_LOW_LEVEL(">>>CVcxHgVodServiceListModelHandler::GenerateServiceInfoTextLC");

    HBufC* serviceInfo;

    if ( aUpdateStatus == CVcxNsService::EUpdateFailed )

        {

        serviceInfo = CVcxHgVodUtils::LoadStringFromResourceLC( R_VCXHG_FEED_UPDATE_FAILED );

        }

    else if ( aUpdateTime == 0 )

        {

        serviceInfo = KVcxNsSpaceString().AllocLC();

        }

    else

        {

        TBuf<KVcxNsMaxDateBufSize + KVcxNsMaxTimeBufSize + 1> datetimebuf;

        CVcxHgVodUtils::FormatDateAndTimeL( aUpdateTime, datetimebuf );

        serviceInfo = CVcxHgVodUtils::LoadStringFromResourceLC( R_VCXHG_LAST_UPDATE, datetimebuf );

        }

    IPTVLOGSTRING_LOW_LEVEL("<<<CVcxHgVodServiceListModelHandler::GenerateServiceInfoTextLC");

    return serviceInfo;    

    }

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

// Show selected feed's details

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

// 

void CVcxHgVodServiceListModelHandler::ShowFeedDetailsL( TInt aSelected )

    {

    IPTVLOGSTRING_LOW_LEVEL(">>>CVcxHgVodServiceListModelHandler::ShowFeedDetailsL");

    if ( aSelected >= 0 && aSelected < iServices->Count() )

        {

        if ( iServiceProvider->GetServiceData( aSelected )->GetDesc().Length() > 0 )

            {

            const TDesC& feedDesc = iServiceProvider->GetServiceData( aSelected )->GetDesc();

            HBufC* context = HBufC::NewLC( feedDesc.Length() );

            context->Des().Append( feedDesc );

            CAknMessageQueryDialog* dlg = CAknMessageQueryDialog::NewL( *context );

            dlg->ExecuteLD( R_VCXHGVOD_FEED_DETAILS_MESSAGE_QUERY );

            if ( context )

                {

                CleanupStack::PopAndDestroy( context );

                }

            }

        }

    IPTVLOGSTRING_LOW_LEVEL("<<<CVcxHgVodServiceListModelHandler::ShowFeedDetailsL");

    }

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

// Update progress

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

// 

void CVcxHgVodServiceListModelHandler::HandleFeedUpdateProgressL( 

    TInt aIndex, 

    TInt aProgress )

    {

    IPTVLOGSTRING_LOW_LEVEL(">>>CVcxHgVodServiceListModelHandler::HandleFeedUpdateProgressL");

    if ( aIndex < iScroller.ItemCount() 

          && aIndex < iServices->Count() 

          && aIndex >= 0 )

        {

        // need to add progress, when loc string is available. 

        // For now only remove the compiler warning

        aProgress = aProgress;

        HBufC* info = CVcxHgVodUtils::LoadStringFromResourceLC( R_VCXHG_UPDATING_FEED );

        if ( info->Length() > 0 )

            {

            CHgItem& item = iScroller.ItemL( aIndex );

            item.SetTextL( *info );

            iScroller.RefreshScreen( aIndex );

            }

        CleanupStack::PopAndDestroy( info );

        }

    IPTVLOGSTRING_LOW_LEVEL("<<<CVcxHgVodServiceListModelHandler::HandleFeedUpdateProgressL");

    }

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

// 

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

// 

void CVcxHgVodServiceListModelHandler::MarkItem( TInt aIndex )

    {

    if ( aIndex >= 0 && aIndex < iScroller.ItemCount() )

        {

        TRAP_IGNORE( 

                {

                CHgItem& item = iScroller.ItemL( aIndex ); 

                item.SetFlags( CHgItem::EHgItemFlagMarked );

                iScroller.RefreshScreen( aIndex );

                } );

        }

    }

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

// 

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

// 

void CVcxHgVodServiceListModelHandler::UnmarkItem( TInt aIndex )

    {

    if ( aIndex >= 0 && aIndex < iScroller.ItemCount() )

        {

        TRAP_IGNORE( 

                {

                CHgItem& item = iScroller.ItemL( aIndex ); 

                item.ClearFlags( CHgItem::EHgItemFlagMarked );

                iScroller.RefreshScreen( aIndex );

                } );

        }

    }

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

// 

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

// 

void CVcxHgVodServiceListModelHandler::MoveItemL( TInt aSourceIndex, TInt aTargetIndex )

    {

    if ( aSourceIndex == aTargetIndex ||

         aSourceIndex < 0 || 

         aTargetIndex < 0 ||

         aSourceIndex >= iScroller.ItemCount() ||

         aTargetIndex >= iScroller.ItemCount() )

        {

        return;

        }

    CHgItem& oldItem = iScroller.ItemL( aSourceIndex );

    CGulIcon* newIcon = NULL;

    if ( oldItem.Icon() )

        {

        newIcon = CVcxHgVodUtils::DuplicateGulIconL( oldItem.Icon() );

        }

    CHgItem* newItem = CHgItem::NewL( oldItem.Flags(), newIcon, 

            oldItem.Title(), oldItem.Text() );

    newItem->SetTime( oldItem.Time() );

    iScroller.RemoveItem( aSourceIndex );

    iScroller.InsertItem( newItem, aTargetIndex );

    iScroller.DrawDeferred();

    }

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

// 

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

// 

TInt CVcxHgVodServiceListModelHandler::ItemCount()

    {

    return iScroller.ItemCount();

    }

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

// 

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

// 

TInt CVcxHgVodServiceListModelHandler::LastItemSelected()

    {

    return iScroller.SelectedIndex() == iScroller.ItemCount() - 1;

    }

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

// 

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

// 

void CVcxHgVodServiceListModelHandler::MvtoThumbnailReady( 

    CGulIcon* aIcon,

    TInt64 aClientId )

    {

    // error ignored, as there is no error handling that can be done if this leaves

    TRAP_IGNORE( DoThumbnailReadyL( aIcon, aClientId ) );

    }

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

// 

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

// 

void CVcxHgVodServiceListModelHandler::RefreshViewL()

    {

    TInt highlight = iScroller.SelectedIndex();

    iScroller.Reset();

    if ( iServices && iServices->Count() > 0 )

        {

        iScroller.ResizeL( iServices->Count() );

        if ( highlight < 0 )

            {