/*
* 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 "CIptvIapList.h"

#include "CIptvServiceManagementClient.h"
#include "vcxnsservicesettings.h"

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

// -----------------------------------------------------------------------------
// CVcxNsServiceSettings::CVcxNsServiceSettings()
// 
// -----------------------------------------------------------------------------
//
CVcxNsServiceSettings::CVcxNsServiceSettings( )
    {
    }

// -----------------------------------------------------------------------------
// CVcxNsServiceSettings::CVcxNsServiceSettings()
// 
// -----------------------------------------------------------------------------
//
CVcxNsServiceSettings::~CVcxNsServiceSettings( )
    {
    delete iIptvServiceManagementClient;
    }

// -----------------------------------------------------------------------------
// CVcxNsServiceSettings::NewL()
// 
// -----------------------------------------------------------------------------
//
EXPORT_C CVcxNsServiceSettings* CVcxNsServiceSettings::NewL( )
    {
    IPTVLOGSTRING_HIGH_LEVEL("UI Engine ## CVcxNsServiceSettings::NewL()");
    
    return new (ELeave) CVcxNsServiceSettings();
    }

// -----------------------------------------------------------------------------
// CVcxNsServiceSettings::GetAllServicesL()
// Note: Returns NULL if an error occurs.
// -----------------------------------------------------------------------------
//
EXPORT_C CDesC8ArraySeg* CVcxNsServiceSettings::GetAllServicesL()
    {
    IPTVLOGSTRING_HIGH_LEVEL("UI Engine ## CVcxNsServiceSettings::GetAllServicesL()");

    MIptvServiceManagementClientObserver::TRespStatus respStatus;
    CDesC8ArraySeg* services = NULL;

    TInt error = GetServiceManagementClientL()->GetServicesL( 0, 
                                                              CIptvServiceManagementClient::EDisplayOrderDescending,
                                                              services,
                                                              respStatus );
    if ( error == KErrNone )
        {
        return services;
        }
    else
        {
        return NULL;
        }
    }

// -----------------------------------------------------------------------------
// CVcxNsServiceSettings::GetAllSelectedServicesL()
// Note: Returns NULL if an error occurs.
// -----------------------------------------------------------------------------
//
EXPORT_C CDesC8ArraySeg* CVcxNsServiceSettings::GetAllSelectedServicesL( TInt& aError )
    {
    IPTVLOGSTRING_HIGH_LEVEL("UI Engine ## CVcxNsServiceSettings::GetAllSelectedServicesL()");
    
    MIptvServiceManagementClientObserver::TRespStatus respStatus;
    CDesC8ArraySeg* services = NULL;
    
    aError = GetServiceManagementClientL()->GetServicesL( CIptvServiceManagementClient::ESelectedServices, 
                                                          CIptvServiceManagementClient::EDisplayOrderDescending,
                                                          services,
                                                          respStatus );
    if ( aError == KErrNone )
        {
        return services;
        }
    else
        {
        return NULL;
        }
    }

// -----------------------------------------------------------------------------
// CVcxNsServiceSettings::GetServicesByTypeL()
// Note: Returns NULL if an error occurs.
// -----------------------------------------------------------------------------
//
EXPORT_C CDesC8ArraySeg* CVcxNsServiceSettings::GetServicesByTypeL( CIptvService::TServiceType aServiceType )
    {
    IPTVLOGSTRING_HIGH_LEVEL("UI Engine ## CVcxNsServiceSettings::GetServicesByTypeL()");

    MIptvServiceManagementClientObserver::TRespStatus respStatus;
    CDesC8ArraySeg* services = NULL;

    CIptvServiceManagementClient::TSearchLimitFlag flag = (CIptvServiceManagementClient::TSearchLimitFlag) 0;

    switch ( aServiceType )
        {
        case CIptvService::EVod:
            // using flag EVodServices to also include service groups and vodcasts.
            flag = CIptvServiceManagementClient::EVodServices;
            break;
        case CIptvService::ELiveTv:
            flag = CIptvServiceManagementClient::ELiveTv;
            break;
        case CIptvService::EVodCast:
            flag = CIptvServiceManagementClient::EVodCast;
            break;
        case CIptvService::EBrowser:
            flag = CIptvServiceManagementClient::EBrowser;
            break;
        case CIptvService::EVideoRemote:     
            flag = CIptvServiceManagementClient::EVideoRemote;
            break;               
        case CIptvService::EApplication:
            flag = CIptvServiceManagementClient::EApplication;
            break;        
        case CIptvService::EMobileTv:
            flag = CIptvServiceManagementClient::EMobileTv;
            break;
        case CIptvService::EOther:
            flag = CIptvServiceManagementClient::EOther;
            break;        
        default:     
            flag = (CIptvServiceManagementClient::TSearchLimitFlag) 0;
            break;
        }

    TInt error = GetServiceManagementClientL()->GetServicesL( flag, 
                                                              CIptvServiceManagementClient::EDisplayOrderDescending,
                                                              services,
                                                              respStatus );                                                             
    if ( error == KErrNone )
        {
        return services;
        }
    else
        {
        return NULL;
        }
    }

// -----------------------------------------------------------------------------
// CVcxNsServiceSettings::GetIapListForNewServiceL()
// Gathers list of IAPs from other user defined services.
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CVcxNsServiceSettings::GetIapListForNewServiceL( CIptvIapList& aIapList )
    {
    CDesC8ArraySeg* services = GetAllServicesL();
    
    if ( services )
        {
        CleanupStack::PushL( services );

        CIptvService* service = CIptvService::NewL();
        CleanupStack::PushL( service );

        // Go through all services.
        for (TInt i = 0; i < services->Count(); i++)
            {
            service->SetL( services->MdcaPoint(i) );

            TUint32 flags = service->GetFlags();

            // Only copy IAPs from user modifiable services (not provisioned).
            if ( ! (flags & CIptvService::EReadOnlyIaps) )
                {
                // Go through all IAPs for this service.
                for ( TUint8 j = 0; j < service->iIapList->Count(); j++ )
                    {
                    TIptvIap& existingIap = service->iIapList->IapL( j ); 

                    // Check that this IAP is not already on user's list.
                    TBool bFound = EFalse;
                    for ( TUint8 k = 0; k < aIapList.Count(); k++ )
                        {
                        TIptvIap& userIap = aIapList.IapL( k );
                        
                        if ( userIap.iId == existingIap.iId )
                            {
                            bFound = ETrue;
                            break;
                            }
                        }
                      
                    // Add IAP to user's list.  
                    if ( ! bFound )
                        {
                        aIapList.AddIap( existingIap );
                        }
                    }
                }
            }

        CleanupStack::PopAndDestroy( service );
        services->Reset();
        CleanupStack::PopAndDestroy( services );

        if (aIapList.Count() > 0)
            {
            return KErrNone;            
            }
        }

    return KErrNotFound;
    }
// -----------------------------------------------------------------------------
// CVcxNsServiceSettings::AddServiceL()
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CVcxNsServiceSettings::AddServiceL( const TDesC& aServiceName,
                                             const TDesC& aAddress,
                                             const TDesC& aDescription,
                                             CIptvIapList& aIapList,
                                             CIptvService::TServiceType aServiceType,
                                             const TUid& aEpgPluginUid,
                                             const TUid& aIptvPluginUid,
                                             const TUid& aVodPluginUid )
    {
    IPTVLOGSTRING_HIGH_LEVEL("UI Engine ## CVcxNsServiceSettings::AddServiceL()");

    if ( aServiceName.Length() == 0 || aAddress.Length() == 0 )
        {
        return KErrArgument;
        }

    MIptvServiceManagementClientObserver::TRespStatus respStatus;
    CIptvService*                                     iptvService = CIptvService::NewL();
    CleanupStack::PushL( iptvService );

    iptvService->SetId( 0 );
    iptvService->SetName( aServiceName );
    iptvService->SetAddress( aAddress );
    iptvService->SetIconPath( KNullDesC );
    iptvService->SetType( aServiceType );
    iptvService->SetDesc( aDescription );
    iptvService->SetFlags( CIptvService::ESelected );
    iptvService->SetApplicationUid( 0 );
    iptvService->SetDisplayOrder( 0 );
    iptvService->iIapList->SetL( aIapList );
    
    iptvService->SetEpgPluginUid(aEpgPluginUid);
    iptvService->SetIptvPluginUid(aIptvPluginUid);
    iptvService->SetVodPluginUid(aVodPluginUid);

    TInt error = GetServiceManagementClientL()->AddServiceL( *iptvService, respStatus );



    CleanupStack::PopAndDestroy( iptvService );
    return error;
    }

// -----------------------------------------------------------------------------
// CVcxNsServiceSettings::UpdateServiceL()
// -----------------------------------------------------------------------------
//
EXPORT_C void CVcxNsServiceSettings::UpdateServiceL( CIptvService& aIptvService )
    {
    IPTVLOGSTRING_HIGH_LEVEL("UI Engine ## CVcxNsServiceSettings::UpdateServiceL()");
    
    MIptvServiceManagementClientObserver::TRespStatus respStatus;
    
    GetServiceManagementClientL()->UpdateServiceL( aIptvService, respStatus );
    }

// -----------------------------------------------------------------------------
// CVcxNsServiceSettings::DeleteServiceL()
// -----------------------------------------------------------------------------
//
EXPORT_C void CVcxNsServiceSettings::DeleteServiceL( TUint32 aItemId )
    {
    IPTVLOGSTRING_HIGH_LEVEL("UI Engine ## CVcxNsServiceSettings::DeleteServiceL()");

    MIptvServiceManagementClientObserver::TRespStatus respStatus;

    GetServiceManagementClientL()->DeleteServiceL( aItemId, respStatus );
    }

// -----------------------------------------------------------------------------
// CVcxNsServiceSettings::GetServiceL()
// Note: Method is not efficient, so use only if absolutely necessary.
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CVcxNsServiceSettings::GetServiceL( TUint32 aServiceId, CIptvService& aIptvService )
    {
    /*CDesC8ArraySeg* services = NULL;
    MIptvServiceManagementClientObserver::TRespStatus respStatus;

    if ( ! iIptvServiceManagementClient )
        {
        iIptvServiceManagementClient = CIptvServiceManagementClient::NewL( *this );
        }

    TInt error = iIptvServiceManagementClient->GetServicesL( aServiceId, aServiceId, services, respStatus );

    if ( error == KErrNone && services->MdcaCount() > 0)
        {
        CleanupStack::PushL( services );
        aIptvService.SetL( services->MdcaPoint(0) );
        CleanupStack::PopAndDestroy( services );
        return KErrNone;
        }

    return KErrNotFound;
    */

    //Get only this specified service   
    CDesC8ArraySeg* services = GetAllServicesL();
    TInt            error    = KErrNotFound;

    if ( services )
        {
        CleanupStack::PushL( services );

        CIptvService* service = CIptvService::NewL();
        CleanupStack::PushL( service );

        // Go through all services.
        for ( TInt i = 0; i < services->Count(); i++ )
            {
            service->SetL( services->MdcaPoint(i) );
            
            if ( service->GetId() == aServiceId )
                {
                aIptvService.SetL( services->MdcaPoint(i) );
                error = KErrNone;
                }
            }

        CleanupStack::PopAndDestroy( service );
        CleanupStack::PopAndDestroy( services );
        }
    
    return error;    
    
    }

// -----------------------------------------------------------------------------
// CVcxNsServiceProvider::GetServiceManagementClientL()
// -----------------------------------------------------------------------------
//
CIptvServiceManagementClient* CVcxNsServiceSettings::GetServiceManagementClientL()
    {
    if ( ! iIptvServiceManagementClient )
        {
        iIptvServiceManagementClient = CIptvServiceManagementClient::NewL( *this );
        }
    
    return iIptvServiceManagementClient;    
    }


// -----------------------------------------------------------------------------
// CVcxNsServiceSettings::GetScheduledDownloadSettingsL
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CVcxNsServiceSettings::GetScheduledDownloadSettingsL(
    TIptvServiceId aServiceId,
    TIptvVodScheduleDownloadtimeCombination& aDownloadTime,
    TIptvVodScheduleConnectionCondition& aCondition,
    TIptvVodScheduleDownloadTypeCombination& aType )
    {
    CIptvService* service = CIptvService::NewL();
    CleanupStack::PushL( service );
    
    TInt err = GetServiceL( aServiceId, *service );
    
    if ( err == KErrNone )
        {
        aDownloadTime = service->ScheduleDlTime();
        aCondition = static_cast<TIptvVodScheduleConnectionCondition>(
                        service->ScheduleDlNetwork() );
        aType = service->ScheduleDlType();
        }
    
    CleanupStack::PopAndDestroy( service );
    
    return err;
    }

// -----------------------------------------------------------------------------
// CVcxNsServiceSettings::SetScheduledDownloadSettingsL
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CVcxNsServiceSettings::SetScheduledDownloadSettingsL(
    TIptvServiceId aServiceId,
    TIptvVodScheduleDownloadtimeCombination aDownloadTime,
    TIptvVodScheduleConnectionCondition aCondition,
    TIptvVodScheduleDownloadTypeCombination aType )
    {
    CIptvService* service = CIptvService::NewL();
    CleanupStack::PushL( service );
    
    TInt err = GetServiceL( aServiceId, *service );

    if ( err == KErrNone )
        {
        service->SetScheduleDlTime( aDownloadTime );
        service->SetScheduleDlNetwork( aCondition );
        service->SetScheduleDlType( aType );

        //  If this is the first time scheduling for this service.
        if ( service->GetScheduledLastDownloadTime().Int64() == 0 &&
             aCondition != EManual &&
             aDownloadTime != ENoSchedule )
            {
            TTime current;
            current.UniversalTime();
            service->SetScheduledLastDownloadTime( current );
            }
        // If we move back to manual download state, let's reset the 'last
        // scheduled download time' so that old scheduling for service does
        // not confuse user when he later on sets scheduling on again.
        else if ( aCondition == EManual )
            {
            TTime zero( 0 );
            
            service->SetScheduledLastDownloadTime( zero );
            }

        UpdateServiceL( *service );
        }

    CleanupStack::PopAndDestroy( service );

    return err;
    }