/*

* 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 <mpxmessage2.h>

#include <mpxcollectionutility.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediageneraldefs.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxcollectionmessagedefs.h>

#include <mpxcollectionpath.h>

#include <mpxmessage2.h>

#include <mpxcollectionmessage.h>

#include <mpxlog.h>

#include <mpxitemid.h>

#include <mpxmessagecontainerdefs.h>

#include <vcxmyvideosdefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include <vcxmyvideosdefs.h>

#include <vcxmyvideosuids.h>

#include "vcxnseventrouter.h"

#include "vcxnsuiengine.h"

#include "CIptvSmEvent.h"

#include "CIptvUtil.h"

#include "vcxnsserviceprovider.h"

#include "vcxnscontentprovider.h"

#include "vcxnscategoryprovider.h"

#include "vcxnsservice.h"

#include "vcxnscontent.h"

#include "vcxnscategory.h"

#include "vcxnsmpxcollectionclienthandler.h"

#include "vcxnscontentsearchhandler.h"

#include "vcxnsupdateprogresshandler.h"

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

// CVcxNsEventRouter::CVcxNsEventRouter()

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

//

CVcxNsEventRouter::CVcxNsEventRouter( CVcxNsUiEngine& aUiEngine )

    :iUiEngine( aUiEngine )

    {

    }

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

// CVcxNsEventRouter::~CVcxNsEventRouter()

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

//

CVcxNsEventRouter::~CVcxNsEventRouter( )

    {

    }

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

// CVcxNsEventRouter::NewL()

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

//

CVcxNsEventRouter* CVcxNsEventRouter::NewL( CVcxNsUiEngine& aUiEngine )

    {

    CVcxNsEventRouter* self = new ( ELeave ) CVcxNsEventRouter( aUiEngine );

    return self;

    }

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

// CVcxNsEventRouter::HandleSmEvent()

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

//

void CVcxNsEventRouter::HandleSmEvent( CIptvSmEvent& aEvent )

    {

    // check when to reset the data

    if( iUiEngine.ServiceProvider() )

         {

         iUiEngine.ServiceProvider()->RemoveServiceData();

         }

    RemoveServiceData( aEvent.iServiceId );

    if( iUiEngine.VcAppState() == EStateServiceView || 

        aEvent.iServiceId == iUiEngine.ActiveService() )

        {

        // Services can be added or deleted, so let's redraw all.

        UpdateActiveView();

        if ( aEvent.iEvent == CIptvSmEvent::EServiceAdded )

            {

            // Assume that the added is always first

            iUiEngine.ServiceProvider()->ServiceAdded( 0 );

            }

        }

    }

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

// CVcxNsEventRouter::HandleEpgManagerMsgL()

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

//

void CVcxNsEventRouter::HandleEpgManagerMsgL( 

    TInt aMsg, TInt aInfo, TIptvServiceId aServiceId )

    {

    CVcxNsUpdateProgressHandler* progressHandler = iUiEngine.GetProgressHandler();

    if ( progressHandler )

        {

        progressHandler->HandleUpdateStatusChangeL( aServiceId, aMsg, aInfo );

        }

    CVcxNsServiceProvider* serviceProvider = iUiEngine.ServiceProvider();

    User::LeaveIfNull( serviceProvider );

    switch( aMsg )

        {

        case KIptvVodUpdateNotStarted:

            {

            serviceProvider->RefreshNextPendingService();

            IPTVLOGSTRING_LOW_LEVEL("CVcxNsEventRouter::HandleEpgManagerMsgL: KIptvVodUpdateNotStarted");

            }

            break;

        case KIptvVodUpdateStarted: //Update process started

            {

            IPTVLOGSTRING_LOW_LEVEL("CVcxNsEventRouter::HandleEpgManagerMsgL: KIptvVodUpdateStarted");

            iUpdatedService = aServiceId;

            serviceProvider->UpdateServiceUpdateStatusL( aServiceId, CVcxNsService::EUpdateOngoing );

            if ( iUiEngine.VcAppState() == EStateContentView  && 

                 iUiEngine.GetContentProviderL()->GetContentsL().Count() == 0 )

                {

                UpdateActiveView();

                }

            iThumbnailCount = 0;

            iThumbnailsDownloaded = 0;

            UpdateInfoPopupL();

            }

            break;

        case KIptvContentUpdateCompleted:

            {

            IPTVLOGSTRING_LOW_LEVEL(

                "CVcxNsEventRouter::HandleEpgManagerMsgL: KIptvContentUpdateCompleted");

            // Refresh the view before thumbnails are downloaded, if there was

            // no old data. Empty category view shouldn't be ever shown.

            RPointerArray< CVcxNsCategory > categories =

                iUiEngine.GetCategoryProviderL()->GetCategorysL();

            if( ( iUiEngine.VcAppState() == EStateContentView  &&

                    categories.Count() == 0 )

                || ( iUiEngine.VcAppState() == EStateCategoryView &&

                        categories.Count() == 0 )

                || ( iUiEngine.VcAppState() == EStateCategoryView &&

                        categories.Count() == 1 &&

                        categories[0]->GetCategoryId() == KIptvRssSearchCategoryId )

                || ( iUiEngine.VcAppState() == EStateCustomView &&

                     iUiEngine.ActiveService() == aServiceId ) )

                {

                if ( !( iUiEngine.VcAppState() == EStateCustomView ) )

                    {

                    CheckAppStateL( aServiceId );

                    }

                UpdateActiveView();

                }

            iThumbnailCount = 0;

            iThumbnailsDownloaded = 0;

            UpdateInfoPopupL();

            }

            break;

        case KIptvThumbnailCount:

            {

            IPTVLOGSTRING_LOW_LEVEL(

                "CVcxNsEventRouter::HandleEpgManagerMsgL: KIptvThumbnailCount");

            // Store the tbn count even if we're in wrong service.

            iThumbnailCount = aInfo;

            UpdateInfoPopupL();

            }

            break;

        case KIptvServiceThumbnailDownloaded:

            {

            IPTVLOGSTRING_LOW_LEVEL(

                "CVcxNsEventRouter::HandleEpgManagerMsgL: KIptvServiceThumbnailDownloaded");

            serviceProvider->ReloadThumbnailPathL( aServiceId );

            if( iUiEngine.VcAppState() == EStateServiceView )

                {

                serviceProvider->UpdateService( aServiceId );

                }

            iThumbnailsDownloaded++;

            UpdateInfoPopupL();

            }

            break;

        case KIptvContentThumbnailDownloaded:

            {

            IPTVLOGSTRING_LOW_LEVEL(

                "CVcxNsEventRouter::HandleEpgManagerMsgL: KIptvContentThumbnailDownloaded");

            //When downloading group thumbnails, 

            //aInfo includes service id information for grouped service

            CVcxNsService* serviceData = serviceProvider->GetServiceDataById( aServiceId );

            if ( serviceData && serviceData->Type() == CVcxNsService::EVcxNsMainGroup )

                {

                serviceProvider->ReloadThumbnailPathL( aInfo );

                }

            // Store the tbn count even if we're in wrong service.

            iThumbnailsDownloaded++;

            UpdateInfoPopupL();

            }

            break;

        case KIptvErrorEpgUpdateStopped:

            {

            //This event comes when plugin has stopped all activities for update

            //We can start updating next service as server is not busy with last update anymore.

            IPTVLOGSTRING_LOW_LEVEL(

                "CVcxNsEventRouter::HandleEpgManagerMsgL: KIptvErrorEpgUpdateStopped");

            serviceProvider->RefreshNextPendingService();

            }

            break;

        case KIptvErrorEpgUpdateSuccessed:

            {

            IPTVLOGSTRING_LOW_LEVEL(

                "CVcxNsEventRouter::HandleEpgManagerMsgL: KIptvErrorEpgUpdateSuccessed");

            HandleEpgUpdateSucceededL( aServiceId );

            }

            break;

        case KIptvErrorEpgUpdateFailed:

            {

            IPTVLOGSTRING_LOW_LEVEL(

                "CVcxNsEventRouter::HandleEpgManagerMsgL: KIptvErrorEpgUpdateFailed");

            HandleEpgUpdateFailedL( aInfo, aServiceId );

            }

            break;

        case KIptvErrorRssSearchNoIap: //fall trough

        case KIptvErrorRssSearchStarted: //fall through

        case KIptvErrorRssSearchFailed:  //fall through

        case KIptvErrorRssSearchSucceed: //fall through

        case KIptvRssSearchContentUpdateCompleted: //fall through

        case KIptvRssSearchThumbnailCount: //fall through

        case KIptvRssSearchContentThumbnailDownloaded:

            iUiEngine.GetContentSearchHandlerL()->HandleSearchMsgL( aMsg, aInfo );

            break;

        default:

            break;

        }

    }

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

// CVcxNsEventRouter::HandleCollectionMessageL()

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

//

void CVcxNsEventRouter::HandleCollectionMessageL( CMPXMessage* aMsg, TInt /*aErr*/ )

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsEventRouter::HandleCollectionMessageL IN");

    // what the err represents?

    if( !iUiEngine.ContentProvider() )

        {

        return;

        }

    TUid colId = aMsg->ValueTObjectL<TUid>(KMPXMessageCollectionId);

    TMPXChangeEventType type = aMsg->ValueTObjectL<TMPXChangeEventType>(KMPXMessageChangeEventType);

    if( colId.iUid == KVcxUidMyVideosMpxCollection )

        {

        TMPXItemId itemId = aMsg->ValueTObjectL<TMPXItemId>( KMPXMessageMediaGeneralId );

        if ( type == EMPXItemModified )

            {

            IPTVLOGSTRING_LOW_LEVEL("CVcxNsEventRouter::HandleCollectionMessageL EMPXItemModified");

            CVcxNsContent* content = iUiEngine.GetMpxCollectionClientHandlerL()->SearchFromDownloadList( itemId );            

            if( content )

                {

                iUiEngine.ContentProvider()->UpdateContent( content );

                }

            }

        }

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsEventRouter::HandleCollectionMessageL OUT");

    }

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

// CVcxNsEventRouter::UpdateActiveView

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

//

void CVcxNsEventRouter::UpdateActiveView()

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsEventRouter::UpdateActiveView");

    if( iUiEngine.VcAppState()== EStateServiceView 

            || iUiEngine.VcAppState()== EStateCustomView )

        {

        if ( iUiEngine.ServiceProvider() )

            {

            iUiEngine.ServiceProvider()->RefreshView();

            }

        }

    else if( iUiEngine.VcAppState()== EStateContentView )

        {

        if( iUiEngine.ContentProvider() )

            {

            iUiEngine.ContentProvider()->RefreshView();

            }

        }

    else if( iUiEngine.VcAppState()== EStateCategoryView )

        {

        if( iUiEngine.CategoryProvider() )

            {

            iUiEngine.CategoryProvider()->RefreshView();

            }

        }

    }

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

// CVcxNsEventRouter::RemoveServiceData()

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

//

void CVcxNsEventRouter::RemoveServiceData( TUint32 aServiceId )

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsEventRouter::RemoveServiceData");

    CVcxNsMpxCollectionClientHandler* collectionClient( NULL );

    TRAP_IGNORE( collectionClient = iUiEngine.GetMpxCollectionClientHandlerL() );

    if ( collectionClient && iUiEngine.ActiveService() == aServiceId )

        {

        collectionClient->ResetDownloadList( ETrue );

        }

    if ( iUiEngine.ContentProvider() )

        {

        iUiEngine.ContentProvider()->RemoveServiceData( aServiceId );

        }            

    if ( iUiEngine.CategoryProvider() )

        {

        iUiEngine.CategoryProvider()->RemoveServiceData( aServiceId );

        } 

    }

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

// CVcxNsEventRouter::UpdateInfoPopupL()

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

//

void CVcxNsEventRouter::UpdateInfoPopupL()

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsEventRouter::UpdateInfoPopupL");

    CVcxNsServiceProvider* serviceProvider = iUiEngine.ServiceProvider();

    if ( !serviceProvider )

        {

        return;

        }

    CVcxNsService* service = serviceProvider->GetServiceDataById( iUpdatedService ); 

    CVcxNsService::TServiceUpdateStatus status ( CVcxNsService::ENotUpdating );

    if ( service )

        {

        status = service->GetUpdateStatus();

        }

    TBool updating = ( status == CVcxNsService::EUpdateOngoing ? ETrue : EFalse );

    if( iUiEngine.ActiveService() == iUpdatedService )

        {

        switch( iUiEngine.VcAppState() )

            {

            case EStateContentView:

                {

                if( iUiEngine.ContentProvider() )

                    {

                    iUiEngine.ContentProvider()->ShowUpdatingNoteL( 

                        updating ,iThumbnailCount, iThumbnailsDownloaded );

                    }

                break;

                }

            case EStateCategoryView:

                {

                if( iUiEngine.CategoryProvider() )

                    {

                    iUiEngine.CategoryProvider()->ShowUpdatingNoteL( 

                        updating, iThumbnailCount, iThumbnailsDownloaded );

                    }

                break;

                }

            default:

                {

                break;

                }

            }

        }

    }

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

// CVcxNsEventRouter::HandleEpgUpdateFailedL()

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

//

void CVcxNsEventRouter::HandleEpgUpdateFailedL( 

    TInt aError,

    TIptvServiceId aServiceId )

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsEventRouter::HandleEpgUpdateFailedL");

    TVcxNsAppState appState = iUiEngine.VcAppState();

    CVcxNsServiceProvider* serviceProvider = iUiEngine.ServiceProvider();

    if ( serviceProvider )

        {

        // Check if Updating manually failed, epg update still pending (EUpdatePending)

        serviceProvider->UpdateServiceUpdateStatusL( 

                aServiceId, CVcxNsService::EUpdateFailed );

        if( appState == EStateServiceView )

            {

            serviceProvider->UpdateService( aServiceId );

            }

        } 

    if ( appState == EStateCategoryView && iUiEngine.CategoryProvider() )

        {

        iUiEngine.CategoryProvider()->HandleErrorL( aError, aServiceId );

        }

    if ( appState == EStateContentView && iUiEngine.ContentProvider() )

        {

        iUiEngine.ContentProvider()->HandleErrorL( aError, ETrue, aServiceId );

        }

    if ( appState == EStateCustomView && serviceProvider )

        {

        serviceProvider->RefreshView();

        }

    iThumbnailCount = 0;

    iThumbnailsDownloaded = 0;

    UpdateInfoPopupL();

    }

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

// CVcxNsEventRouter::HandleEpgUpdateSucceededL()

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

//

void CVcxNsEventRouter::HandleEpgUpdateSucceededL( TIptvServiceId aServiceId )

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsEventRouter::HandleEpgUpdateSucceededL");

    CheckAppStateL( aServiceId );

    iUiEngine.ServiceProvider()->UpdateServiceUpdateStatusL( 

            aServiceId, CVcxNsService::ENotUpdating );

    iUiEngine.ServiceProvider()->UpdateServiceInCacheL( aServiceId );        

    if( iUiEngine.VcAppState() == EStateServiceView )

        {

        // Update just the one item

        iUiEngine.ServiceProvider()->UpdateService( aServiceId );

        }

    else if( ( iUiEngine.VcAppState() == EStateContentView ||                            

          iUiEngine.VcAppState() == EStateCategoryView  ||

          iUiEngine.VcAppState() == EStateCustomView ) &&

          iUiEngine.ActiveService() == aServiceId )

        {

        // Update whole list

        UpdateActiveView();

        }

    iThumbnailCount = 0;

    iThumbnailsDownloaded = 0;

    UpdateInfoPopupL();

    }

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

// Check, is the view switch needed

// Note that this removes old service data.

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

//

void CVcxNsEventRouter::CheckAppStateL( TIptvServiceId aServiceId )

    {

    TUint32 activeServiceId = iUiEngine.ActiveService();

    if( aServiceId == activeServiceId &&

          iUiEngine.CategoryProvider() &&

        ( iUiEngine.VcAppState() == EStateContentView ||                            

          iUiEngine.VcAppState() == EStateCategoryView ) )

        {

        RPointerArray<CVcxNsCategory> oldCategories = 

            iUiEngine.CategoryProvider()->GetCategorysL();

        TInt oldCategoryCount = oldCategories.Count();

        TBool wasSingle = oldCategoryCount == 0 || 

                          ( oldCategoryCount == 1 && 

                            oldCategories[0]->GetCategoryId() != 

                            KIptvRssSearchCategoryId ) ? ETrue : EFalse ;

        RemoveServiceData( aServiceId );

        RPointerArray<CVcxNsCategory> newCategories = 

            iUiEngine.CategoryProvider()->GetCategorysL();

        TInt newCategoryCount = newCategories.Count();

        TBool isSingle = newCategoryCount == 0 || 

                          ( newCategoryCount == 1 && 

                            newCategories[0]->GetCategoryId() != 

                            KIptvRssSearchCategoryId ) ? ETrue : EFalse ;

        TVcxNsAppState oldState = iUiEngine.VcAppState();

        // check that the old category really exists

        TBool activeCategoryExists = 

                iUiEngine.CategoryProvider()->GetActiveCategoryDataL()

                    ? ETrue : EFalse;