/*

* Copyright (c) 2002 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:   ?Description*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include "IptvServiceManagementApiTest.h"

#include "CIptvServiceManagementSync.h"

#include "CIptvTestUtilities.h"

#include "CIptvTestMobilecrashWatcher.h"

#include "VCXTestLog.h"

#include <f32file.h>

#include <S32FILE.H>

#include "IptvTestUtilALR.h"

#include <mmf/common/mmfcontrollerpluginresolver.h>

#include "../../../server/IptvScheduledDownload/inc/iptvvodscheduleddownloaddefinitions.h"

#include "CIptvTestServiceStore.h"

//#include <commdb.h>

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CIptvServiceManagementApiTest::Delete

// Delete here all resources allocated and opened from test methods.

// Called from destructor.

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

//

void CIptvServiceManagementApiTest::Delete()

    {

    DeAllocateResources();

    }

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

// CIptvServiceManagementApiTest::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

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

//

TInt CIptvServiceManagementApiTest::RunMethodL(

    CStifItemParser& aItem )

    {

    static TStifFunctionInfo const KFunctions[] =

        {

        // Copy this line for every implemented function.

        // First string is the function name used in TestScripter script file.

        // Second is the actual implementation member function.

        ENTRY( "Create", CIptvServiceManagementApiTest::CreateL ),

        ENTRY( "AddHardCodedService", CIptvServiceManagementApiTest::AddHardCodedServiceL ),

        ENTRY( "UpdateService", CIptvServiceManagementApiTest::UpdateServiceL ),

        ENTRY( "UpdateServiceField", CIptvServiceManagementApiTest::UpdateServiceFieldL ),

        ENTRY( "DeleteService", CIptvServiceManagementApiTest::DeleteServiceL ),

        ENTRY( "DeleteAllServices", CIptvServiceManagementApiTest::DeleteAllServicesL ),

        ENTRY( "GetServices", CIptvServiceManagementApiTest::GetServicesL ),

        ENTRY( "GetServicesByProviderId", CIptvServiceManagementApiTest::GetServicesByProviderIdL ),

        ENTRY( "GetAllSelectedServices", CIptvServiceManagementApiTest::GetAllSelectedServicesL ), // GetFilteredServices should be used

        ENTRY( "GetServicesFiltered", CIptvServiceManagementApiTest::GetServicesFilteredL ),

        ENTRY( "GetServicesByType", CIptvServiceManagementApiTest::GetServicesByTypeL ),

        ENTRY( "ShutdownServer", CIptvServiceManagementApiTest::ShutdownServerL ),

        ENTRY( "SetUsedIap", CIptvServiceManagementApiTest::SetUsedIap ),

        ENTRY( "GetUsedIap", CIptvServiceManagementApiTest::GetUsedIap ),

        ENTRY( "ClearUsedIap", CIptvServiceManagementApiTest::ClearUsedIapL ),

        ENTRY( "SetAllIaps", CIptvServiceManagementApiTest::SetAllIapsL ),

        ENTRY( "SetConnectionAllowed", CIptvServiceManagementApiTest::SetConnectionAllowedL ),

        ENTRY( "IsConnectionAllowed", CIptvServiceManagementApiTest::IsConnectionAllowedL ),

        ENTRY( "VerifyServerIsShutdown", CIptvServiceManagementApiTest::VerifyServerIsShutdownL ),

        ENTRY( "SetSpecialAction", CIptvServiceManagementApiTest::SetSpecialAction),

        ENTRY( "RepeatNextRequest", CIptvServiceManagementApiTest::RepeatNextRequest),

        ENTRY( "DeleteServicesDb", CIptvServiceManagementApiTest::Dummy),

        ENTRY( "Cleanup", CIptvServiceManagementApiTest::Dummy),

        ENTRY( "Initialize", CIptvServiceManagementApiTest::Dummy),

        ENTRY( "Destroy", CIptvServiceManagementApiTest::DestroyL ),

        };

    const TInt count = sizeof( KFunctions ) /

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

/*****************************************************/

/***************        Test methods *****************/

/*****************************************************/

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

// CIptvServiceManagementApiTest::CreateL

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

//

TInt CIptvServiceManagementApiTest::CreateL( CStifItemParser& /* aItem */ )

    {

    VCXLOGLO1(">>>CIptvServiceManagementApiTest::CreateL");

    // Print to UI

    _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );

    _LIT( KCreate, "In Create" );

    TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KCreate );

    // Print to log file

    iLog->Log( KCreate );

    TInt err = KErrNone;

    TRAP(err, iIptvTestMobilecrashWatcher = CIptvTestMobilecrashWatcher::NewL() );

    if(KErrNone != err)//Leave

        {

        if(iIptvTestMobilecrashWatcher)

            {

            delete iIptvTestMobilecrashWatcher;

            iIptvTestMobilecrashWatcher = NULL;

            }

        VCXLOGLO1("Leave in creating iIptvTestMobilecrashWatcher instance");

        return err;

        }

    TRAP(err, iIptvServiceManagementSync = CIptvServiceManagementSync::NewL() );

    if(err != KErrNone)

        {

        VCXLOGLO1("CIptvServiceManagementApiTest:: ** FAIL ** Creating CIptvServiceManagementSync failed!");

        VCXLOGLO1("<<<CIptvServiceManagementApiTest::CreateL");

        return err;

        }

    CDesC8ArraySeg* servicesArrayDesc = NULL;

    // This will execute the possible provisioning of services.xml

    TRespStatus respStatus = iIptvServiceManagementSync->CallGetServices(CIptvServiceManagementSync::EIptvSmTestSync, 0, 10, &servicesArrayDesc);

    if(respStatus == ESucceeded)

        {

        servicesArrayDesc->Reset();

        delete servicesArrayDesc;

        servicesArrayDesc = NULL;

        }

    // Wait for the provisioning events

    iIptvServiceManagementSync->WaitForProvisioningEvents();

    TRAP(err, iIptvTestUtilities = CIptvTestUtilities::NewL() );

    if(err != KErrNone)

        {

        VCXLOGLO1("CIptvServiceManagementApiTest:: ** FAIL ** Creating CIptvTestUtilities failed!");

        VCXLOGLO1("<<<CIptvServiceManagementApiTest::CreateL");

        return err;

        }

    iServiceStore = CIptvTestServiceStore::NewL(NULL, iIptvTestUtilities);

    // Construct list of iaps

    iIapNumList = new (ELeave) CArrayFixFlat<TUint32>(30);

    TBuf<1024> iapName;

    for(TInt id=0;id<20;id++)

        {

        // If there's iap with the id then add it

        iapName.Zero();

        if(iIptvTestUtilities->GetIapNameById(iapName, id) )

            {

            iIapNumList->AppendL(id);

            }

        }

    iAlrUtil = CIptvTestUtilALR::NewL();

    VCXLOGLO1("<<<CIptvServiceManagementApiTest::CreateL");

    return KErrNone;

    }

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

// CIptvServiceManagementApiTest::DestroyL

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

//

TInt CIptvServiceManagementApiTest::DestroyL( CStifItemParser& /*aItem*/ )

    {

    VCXLOGLO1(">>>CIptvServiceManagementApiTest::DestroyL");

    // Print to UI

    _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );

    _LIT( KDestroy, "In Destroy" );

    TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KDestroy );

    // Print to log file

    iLog->Log( KDestroy );

    DeAllocateResources();

    VCXLOGLO1("<<<CIptvServiceManagementApiTest::DestroyL");

    return KErrNone;

    }

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

// CIptvServiceManagementApiTest::Dummy

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

//

TInt CIptvServiceManagementApiTest::Dummy( CStifItemParser& /*aItem*/ )

    {

    return KErrNone;

    }

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

// CIptvServiceManagementApiTest::AddHardCodedServiceL

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

//

TInt CIptvServiceManagementApiTest::AddHardCodedServiceL( CStifItemParser& aItem )

    {

    VCXLOGLO1(">>>CIptvServiceManagementApiTest::AddHardCodedServiceL");

    // Print to UI

    _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );

    _LIT( KAddHardCodedService, "In AddHardCodedService" );

    TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KAddHardCodedService );

    // Print to log file

    iLog->Log( KAddHardCodedService );

    TInt msgTypeInt = 0;

    TPtrC serviceToAdd;

    TInt loopCnt = 1; // Default loop once

    TInt iapsToAdd = 0;

    TInt expectedServiceId = -1;

    TBool iapNameSpecified = EFalse;

    TPtrC iapName;

    TRespStatus respStatus = ESucceeded;

    TRespStatus expectedRespStatus = ESucceeded;

    TInt rv = KErrNone;

    CIptvService* iptvService = NULL;

    // Read parameters

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    aItem.GetNextInt(msgTypeInt);

    aItem.GetNextString(serviceToAdd);

    if(KErrNone != aItem.GetNextString(iapName) )

        {

        VCXLOGLO1("** FAIL ** Invalid testcase parameter! Iap name or count was not specified.");

        VCXLOGLO1("<<<CIptvServiceManagementApiTest::AddHardCodedServiceL");

        return KErrArgument;

        }

    TLex lex(iapName);

    if( KErrNone != lex.Val(iapsToAdd) )

        {

        iapNameSpecified = ETrue;

        }

    aItem.GetNextInt(loopCnt);

    VCXLOGLO2("MsgType: %d", msgTypeInt);

    VCXLOGLO2("ServiceNumberToAdd: %S", &serviceToAdd);

    VCXLOGLO2("IapsToAdd: %d", iapsToAdd);

    VCXLOGLO2("IapName: %d", &iapName);

    VCXLOGLO2("LoopCount: %d", loopCnt);

    VCXLOGLO2("ExpectedServiceId: %d", expectedServiceId);

    if(loopCnt < 0 || msgTypeInt < 0 || msgTypeInt > 1)

        {

        VCXLOGLO1("** FAIL **Invalid testcase parameter!");

        VCXLOGLO1("<<<CIptvServiceManagementApiTest::AddHardCodedServiceL");

        return KErrArgument;

        }

    CIptvServiceManagementSync::TIptvSmTestConnection msgType = static_cast<CIptvServiceManagementSync::TIptvSmTestConnection>(msgTypeInt);

    // No full verifying when request is repeated

    TUint repeatRequest = iIptvServiceManagementSync->GetRepeatNextRequestCount();

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

        {

        VCXLOGLO2("loop %d",i);

        // Create service

        if(iapNameSpecified)

            iptvService = GetHardcodedService(serviceToAdd, iapName);

        else

            iptvService = GetHardcodedService(serviceToAdd, iapsToAdd);

        if(iptvService == NULL)

            {

            VCXLOGLO1("** FAIL ** Invalid params? GetHardcodedService failed");

            rv = KErrArgument;

            break;

            }

        CleanupStack::PushL(iptvService);

        // Check provider ID

        TBuf<512> newProviderId(iptvService->GetProviderId());

        iServiceStore->RefreshServicesFromDbL(KNoFilter, KNoSort);

        RPointerArray<CIptvService> services;

        iServiceStore->GetServicesByProviderId(services, newProviderId);

        // If there's already service(s) with the provider ID, create an unique ID

        if(services.Count() > 0)

            {

            TUint32 lastServiceId (0);

            if(iServiceStore->ServiceCount() >= 1)

                {

                lastServiceId = iServiceStore->GetService( iServiceStore->ServiceCount()-1 )->GetId();

                newProviderId.AppendNum(lastServiceId);

                }

            iptvService->SetProviderId(newProviderId);

            }

        services.Reset();

        // Do the request

        respStatus = iIptvServiceManagementSync->CallAddService(msgType, *iptvService);

        if(respStatus != expectedRespStatus)

            {

            rv = respStatus;

            break;

            }

        // Verify

        CIptvTestServiceStore* oldServices = CIptvTestServiceStore::NewL( iServiceStore );

        CleanupStack::PushL(oldServices);

        oldServices->AddServiceL( *iptvService );

        iServiceStore->RefreshServicesFromDbL(KNoFilter, KNoSort);

        iServiceStore->PrintServices();

        rv = iServiceStore->Compare( *oldServices );

        if(rv != KErrNone)

            {

            break;

            }

        CleanupStack::PopAndDestroy(oldServices);

        CleanupStack::PopAndDestroy(iptvService);

        }

    VCXLOGLO1("<<<CIptvServiceManagementApiTest::AddHardCodedServiceL");

    return rv;

    }

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

// CIptvServiceManagementApiTest::UpdateServiceL

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

//

TInt CIptvServiceManagementApiTest::UpdateServiceL( CStifItemParser& aItem )

    {

    VCXLOGLO1(">>>CIptvServiceManagementApiTest::UpdateServiceL");

    // Print to UI

    _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );

    _LIT( KUpdateService, "In UpdateService" );

    TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KUpdateService );

    // Print to log file

    iLog->Log( KUpdateService );

    TInt msgTypeInt(0);

    TInt destinationId(0);

    TInt sourceId(0);

    TBuf<256> destinationName;

    TBuf<256> sourceName;

    TInt rv = KErrNone;

    TPtrC service1, service2;

    // Read parameters

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    aItem.GetNextInt(msgTypeInt);

    rv = GetServiceIdFromParam(aItem, destinationId, destinationName);

    if(rv != KErrNone)

        {

        VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceL");

        return rv;

        }

    rv = GetServiceIdFromParam(aItem, sourceId, sourceName);

    if(rv != KErrNone)

        {

        VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceL");

        return rv;

        }

    iServiceStore->RefreshServicesFromDbL(KNoFilter, KNoSort);

    if(sourceId == KLastServiceInDb)

        {

        sourceId = iServiceStore->GetService( iServiceStore->ServiceCount()-1 )->GetId();

        sourceName = iServiceStore->GetService( iServiceStore->ServiceCount()-1 )->GetName();

        }

    VCXLOGLO2("destinationId = %d", destinationId );

    VCXLOGLO2("destinationName = %S", &destinationName );

    VCXLOGLO2("sourceId = %d", sourceId );

    VCXLOGLO2("sourceName = %S", &sourceName );

    if(destinationId < 0 || sourceId < 0 || msgTypeInt < 0 || msgTypeInt > 1)

        {

        VCXLOGLO1("** FAIL ** Invalid testcase parameter!");

        VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceL");

        return KErrArgument;

        }

    CIptvServiceManagementSync::TIptvSmTestConnection msgType = static_cast<CIptvServiceManagementSync::TIptvSmTestConnection>(msgTypeInt);

    // Do the request

    rv = TestUpdateService(msgType, destinationId, sourceId);

    if(rv == KErrNone)

        {

        // Verify

        CIptvTestServiceStore* oldServices = CIptvTestServiceStore::NewL( iServiceStore );

        CleanupStack::PushL(oldServices);

        iServiceStore->RefreshServicesFromDbL(KNoFilter, KNoSort);

        VCXLOGLO1("Services before: ");

        oldServices->PrintServices();

        VCXLOGLO1("Services after: ");

        iServiceStore->PrintServices();

        CIptvService* sourceService;

        CIptvService* destService;

        sourceService = oldServices->GetServiceById( sourceId );

        destService = oldServices->GetServiceById( destinationId );

        if( sourceService && destService )

            {

            oldServices->ReplaceServiceL( destService->GetId(), *sourceService );

            rv = iServiceStore->Compare( *oldServices );

            }

        CleanupStack::PopAndDestroy(oldServices);

        }

    VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceL");

    return rv;

    }

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

// CIptvServiceManagementApiTest::UpdateServiceFieldL

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

//

TInt CIptvServiceManagementApiTest::UpdateServiceFieldL( CStifItemParser& aItem )

    {

    VCXLOGLO1(">>>CIptvServiceManagementApiTest::UpdateServiceFieldL");

    // Print to UI

    _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );

    _LIT( KUpdateServiceField, "In UpdateServiceFieldL" );

    TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KUpdateServiceField );

    // Print to log file

    iLog->Log( KUpdateServiceField );

    TInt msgTypeInt(0);

    TInt fieldIdInt(0);

    TInt serviceId(-1);

    TBuf<256> serviceName;

    TInt rv = KErrNone;

    // Read parameters

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    aItem.GetNextInt(msgTypeInt);

    rv = GetServiceIdFromParam(aItem, serviceId, serviceName);

    if(rv != KErrNone)

        {

        VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceFieldL");

        return rv;

        }

    aItem.GetNextInt(fieldIdInt);

    VCXLOGLO3("serviceId, Name = %d, %S", serviceId, &serviceName );

    VCXLOGLO2("fieldId = %d", fieldIdInt );

    iServiceStore->RefreshServicesFromDbL(KNoFilter, KNoSort);

    if(iServiceStore->ServiceCount() <= 0)

        {

        VCXLOGLO1("** FAIL ** No services in db, Cannot update!");

        VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceFieldL");

        return KErrArgument;

        }