/*

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

*

*/

//  INCLUDES

#include "CIptvTestServiceStore.h"

#include "VCXTestLog.h"

#include "CIptvTestUtilities.h"

#include "CIptvService.h"

#include "CIptvServices.h"

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

// CIptvTestServiceStore::NewL

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

//

CIptvTestServiceStore* CIptvTestServiceStore::NewL( CIptvTestServiceStore* aStore, CIptvTestUtilities* aTestUtil )

    {

    VCXLOGLO1(">>>CIptvTestServiceStore::NewL");

    CIptvTestServiceStore* self = new (ELeave) CIptvTestServiceStore();

    CleanupStack::PushL(self);

    self->ConstructL( aStore, aTestUtil, NULL );

    CleanupStack::Pop(self);

    VCXLOGLO1("<<<CIptvTestServiceStore::NewL");

    return self;

    }

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

// CIptvTestServiceStore::NewL

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

//

CIptvTestServiceStore* CIptvTestServiceStore::NewL( CIptvServices* aServices )

    {

    VCXLOGLO1(">>>CIptvTestServiceStore::NewL");

    CIptvTestServiceStore* self = new (ELeave) CIptvTestServiceStore();

    CleanupStack::PushL(self);

    self->ConstructL( NULL, NULL, aServices );

    CleanupStack::Pop(self);

    VCXLOGLO1("<<<CIptvTestServiceStore::NewL");

    return self;

    }

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

// CIptvTestServiceStore::~CIptvTestServiceStore

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

//

CIptvTestServiceStore::~CIptvTestServiceStore()

    {

    VCXLOGLO1(">>>CIptvTestServiceStore::~CIptvTestServiceStore");

    iServices.ResetAndDestroy();

    iServices.Close();

    VCXLOGLO1("<<<CIptvTestServiceStore::~CIptvTestServiceStore");

    }

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

// CIptvTestServiceStore::CIptvTestServiceStore

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

//

CIptvTestServiceStore::CIptvTestServiceStore()

    {

    VCXLOGLO1(">>>CIptvTestServiceStore::CIptvTestServiceStore");

    VCXLOGLO1("<<<CIptvTestServiceStore::CIptvTestServiceStore");

    }

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

// CIptvTestServiceStore::ConstructL

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

//

void CIptvTestServiceStore::ConstructL( CIptvTestServiceStore* aStore, CIptvTestUtilities* aTestUtil, CIptvServices* aServices )

    {

    VCXLOGLO1(">>>CIptvTestServiceStore::ConstructL");

    iIptvTestUtilities = aTestUtil;

    if(aStore != NULL)

        {

        TInt i;

        for(i=0; i<aStore->ServiceCount(); i++)

            {

            CIptvService* service;

            service = aStore->GetService(i);

            if(service != NULL)

                {

                AddServiceL( *service );

                }

            }

        }

    if(aServices != NULL)

        {

        TInt i;

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

            {

            CIptvService* service;

            service = aServices->GetServiceL(i);

            CleanupStack::PushL( service );

            AddServiceL( *service );

            CleanupStack::PopAndDestroy( service );

            }

        }

    VCXLOGLO1("<<<CIptvTestServiceStore::ConstructL");

    }

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

// CIptvTestServiceStore::RefreshServicesFromDbL

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

//

void CIptvTestServiceStore::RefreshServicesFromDbL(TUint32 aFlagsFilter, CIptvServiceManagementClient::TOrder aOrder)

    {

    VCXLOGLO1(">>>CIptvTestServiceStore::RefreshServicesFromDbL");

    if(!iIptvTestUtilities)

        {

        VCXLOGLO1("No instance of CIptvTestUtilities!");

        VCXLOGLO1("<<<CIptvTestServiceStore::RefreshServicesFromDbL");

        User::Leave(KErrNotReady);

        }

    DeleteAllServices();

    TBool ok = EFalse;

    TRAPD(error, ok = iIptvTestUtilities->GetServicesFromDbL(iServices, aFlagsFilter, aOrder) );

    if(!ok || error)

        {

        iServices.ResetAndDestroy();

        VCXLOGLO3("** FAIL ** Getting services failed. ok: %d, leave: %d", ok, error);

        VCXLOGLO1("<<<CIptvTestServiceStore::RefreshServicesFromDbL");

        }

    error = (error == KErrNone && ok == EFalse) ? KErrGeneral : error;

    if(error != KErrNone)

        {

        VCXLOGLO2("CIptvTestServiceStore::RefreshServicesFromDbL ERROR %d", error);

        VCXLOGLO1("<<<CIptvTestServiceStore::RefreshServicesFromDbL");

        }

    VCXLOGLO1("<<<CIptvTestServiceStore::RefreshServicesFromDbL");

    }

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

// CIptvTestServiceStore::AddServiceL

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

//

void CIptvTestServiceStore::AddServiceL(CIptvService& aService)

    {

    VCXLOGLO1(">>>CIptvTestServiceStore::AddServiceL");

    CIptvService* service = CloneServiceL(aService);

    iServices.Append( service );

    VCXLOGLO1("<<<CIptvTestServiceStore::AddServiceL");

    }

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

// CIptvTestServiceStore::AddServicesL

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

//

void CIptvTestServiceStore::AddServicesL(RPointerArray<CIptvService>& aServiceArray)

    {

    VCXLOGLO1(">>>CIptvTestServiceStore::AddServicesL");

    TInt i;

    for(i=0; i<aServiceArray.Count(); i++)

        {

        AddServiceL(*aServiceArray[i]);

        }

    VCXLOGLO1("<<<CIptvTestServiceStore::AddServicesL");

    }

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

// CIptvTestServiceStore::ReplaceServiceL

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

//

void CIptvTestServiceStore::ReplaceServiceL(TInt aId, CIptvService& aService)

    {

    VCXLOGLO1(">>>CIptvTestServiceStore::ReplaceServiceL");

    TInt i = FindService(iServices, aId);

    if(i < KErrNone)

        {

        VCXLOGLO1("<<<CIptvTestServiceStore::ReplaceServiceL");

        User::Leave(i);

        }

    CIptvService* service = CloneServiceL(aService);

    VCXLOGLO1("Services before:");

    PrintServices();

    // Get the old service

    CIptvService* oldService = iServices[i];

    service->SetId( oldService->GetId() );

    delete oldService;

    oldService = NULL;

    iServices.Insert(service, i);

    iServices.Remove(i+1);

    VCXLOGLO1("Services now:");

    PrintServices();

    VCXLOGLO1("<<<CIptvTestServiceStore::ReplaceServiceL");

    }

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

// CIptvTestServiceStore::DeleteService

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

//

TInt CIptvTestServiceStore::DeleteService(TInt aId)

    {

    VCXLOGLO1(">>>CIptvTestServiceStore::DeleteService");

    TInt i = FindService(iServices, aId);

    if(i < KErrNone)

        {

        VCXLOGLO1("<<<CIptvTestServiceStore::DeleteService");

        return i;

        }

    CIptvService* service = iServices[i];

    if( service->GetType() == CIptvService::EServiceGroup )

        {

        /* Get groupId and delete the group */

        TInt groupID( service->GetGroupId() );

        delete service;

        service = NULL;

        iServices.Remove(i);

        /* delete services with groupID */

        TInt groupedIndex( 0 );

        groupedIndex = FindServiceByGroupId( iServices, groupID );

        while( groupedIndex != KErrNotFound )

            {

            iServices.Remove( groupedIndex );

            groupedIndex = FindServiceByGroupId( iServices, groupID );

            }

        }

    else

        {

        delete service;

        service = NULL;

        iServices.Remove(i);        

        }

    VCXLOGLO1("<<<CIptvTestServiceStore::DeleteService");

    return KErrNone;

    }

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

// CIptvTestServiceStore::Compare

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

//

TInt CIptvTestServiceStore::Compare(CIptvTestServiceStore& aStore)

    {

    VCXLOGLO1(">>>CIptvTestServiceStore::Compare");

    if( aStore.ServiceCount() != iServices.Count() )

        {

        VCXLOGLO3("Counts of services are different, %d vs. %d.", aStore.ServiceCount(), iServices.Count() );

        VCXLOGLO1("<<<CIptvTestServiceStore::Compare");

        return KErrCorrupt;

        }

    TInt i;

    for(i=0; i< aStore.ServiceCount(); i++)

        {

        CIptvService* service = aStore.GetService(i);

        if(!CompareServices(*(iServices[i]), *service ))

            {

            VCXLOGLO2("Services at index %d are different!", i);

            VCXLOGLO1("<<<CIptvTestServiceStore::Compare");

            return KErrCorrupt;

            }

        }

    VCXLOGLO1("<<<CIptvTestServiceStore::Compare");

    return KErrNone;

    }

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

// CIptvTestServiceStore::GetService

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

//

CIptvService* CIptvTestServiceStore::GetService(TInt aIndex)

    {

    CIptvService* service = NULL;

    ASSERT(aIndex >= 0 && aIndex < iServices.Count());

    service = iServices[aIndex];

    return service;

    }

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

// CIptvTestServiceStore::GetServiceById

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

//

CIptvService* CIptvTestServiceStore::GetServiceById(TInt aId)

    {

    VCXLOGLO1(">>>CIptvTestServiceStore::GetServiceById");

    CIptvService* service = NULL;

    TInt i;

    for(i=0; i< iServices.Count(); i++)

        {

        if(iServices[i]->GetId() == aId)

            {

            service = iServices[i];

            break;

            }

        }

    if(service == NULL)

        {

        VCXLOGLO2("Service not found with id: %d", aId);

        }

    VCXLOGLO1("<<<CIptvTestServiceStore::GetServiceById");

    return service;

    }

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

// CIptvTestServiceStore::GetGroupedServicesById

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

//

TInt CIptvTestServiceStore::GetGroupedServicesByGroupId(RPointerArray<CIptvService>& aServicesArray, TInt aId)

    {

    VCXLOGLO1(">>>CIptvTestServiceStore::GetGroupedServicesById");

    TInt i;

    for( i=0; i< iServices.Count(); i++ )

        {

        if( iServices[i]->GetGroupId() == aId && iServices[i]->GetType() != CIptvService::EServiceGroup )

            {

            aServicesArray.Append( iServices[i] );

            }

        }

    VCXLOGLO1("<<<CIptvTestServiceStore::GetGroupedServicesById");

    return KErrNone;

    }

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

// CIptvTestServiceStore::GetServices

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

//

TInt CIptvTestServiceStore::GetServices(RPointerArray<CIptvService>& aServicesArray)

    {

    VCXLOGLO1(">>>CIptvTestServiceStore::GetServices");

    TInt i;

    for(i=0; i< iServices.Count(); i++)

        {

        aServicesArray.Append( iServices[i] );

        }

    VCXLOGLO1("<<<CIptvTestServiceStore::GetServices");

    return KErrNone;

    }

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

// CIptvTestServiceStore::GetServicesByProviderId

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

//

TInt CIptvTestServiceStore::GetServicesByProviderId(RPointerArray<CIptvService>& aServicesArray, TDes& aProviderId)

    {

    VCXLOGLO1(">>>CIptvTestServiceStore::GetServicesByProviderId");

    TInt i;

    for(i=0; i< iServices.Count(); i++)

        {

        if(iServices[i]->GetProviderId() == aProviderId)

            {

            aServicesArray.Append( iServices[i] );

            }

        }

    VCXLOGLO1("<<<CIptvTestServiceStore::GetServicesByProviderId");

    return KErrNone;

    }

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

// CIptvTestServiceStore::ServiceCount

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

//

TInt CIptvTestServiceStore::ServiceCount()

    {

    return iServices.Count();

    }

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

// CIptvTestServiceStore::PrintServices

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

//

TInt CIptvTestServiceStore::PrintServices()

    {

    VCXLOGLO1(">>>CIptvTestServiceStore::PrintServices");

    TInt i;

    for(i=0; i< iServices.Count(); i++)

        {

        TBuf<256> name;

        TBuf<256> providerId;

        name = iServices[i]->GetName();

        providerId = iServices[i]->GetProviderId();

        VCXLOGLO4("%d, Name: %S, Provider: %S", iServices[i]->GetId(), &name, &providerId );

        }

    VCXLOGLO1("<<<CIptvTestServiceStore::PrintServices");

    return KErrNone;

    }

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

// CIptvTestServiceStore::DeleteAllServices

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

//

void CIptvTestServiceStore::DeleteAllServices()

    {

    VCXLOGLO1(">>>CIptvTestServiceStore::DeleteAllServices");

    iServices.ResetAndDestroy();

    VCXLOGLO1("<<<CIptvTestServiceStore::DeleteAllServices");

    }

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

// CIptvTestServiceStore::CompareServices

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

//

TBool CIptvTestServiceStore::CompareServices(CIptvService& aS1, CIptvService& aS2)

    {

    VCXLOGLO1(">>>CIptvTestServiceStore::CompareServices");

    TBool rv(TRUE);

    TUint8 i(0);

    VCXLOGLO3("Comparing services: ID: %d - %d", aS1.GetId(), aS2.GetId());

    VCXLOGLO3(" - Name: %S - %S", &aS1.GetName(), &aS2.GetName() );

    if(aS1.GetName() != aS2.GetName())

        {

        rv = EFalse;

        VCXLOGLO3("Name doesn't match: name1 = %S, name2 = %S",&aS1.GetName(),&aS2.GetName());

        }

    if(aS1.GetAddress() != aS2.GetAddress())

        {

         rv = EFalse;

        VCXLOGLO3("Address doesn't match: address1 = %S, address2 = %S",&aS1.GetAddress(),&aS2.GetAddress());

        }

    if(aS1.GetIconPath() != aS2.GetIconPath())

        {

         rv = EFalse;

        VCXLOGLO3("IconPath doesn't match: IconPath1 = %S, IconPath2 = %S",&aS1.GetIconPath(),&aS2.GetIconPath());

        }

    if(aS1.GetEpgPluginUid() != aS2.GetEpgPluginUid())

        {

         rv = EFalse;

        VCXLOGLO3("EpgPluginUid doesn't match: EpgPluginUid1 = %d, EpgPluginUid2 = %d",aS1.GetEpgPluginUid(),aS2.GetEpgPluginUid());

        }

    if(aS1.GetVodPluginUid() != aS2.GetVodPluginUid())

        {

         rv = EFalse;

        VCXLOGLO3("VodPluginUid doesn't match: VodPluginUid1 = %d, VodPluginUid2 = %d",aS1.GetVodPluginUid(),aS2.GetVodPluginUid());

        }

    if(aS1.GetIptvPluginUid() != aS2.GetIptvPluginUid())

        {

         rv = EFalse;

        VCXLOGLO3("IptvPluginUid doesn't match: IptvPluginUid1 = %d, IptvPluginUid2 = %d",aS1.GetIptvPluginUid(),aS2.GetIptvPluginUid());

        }

    if(aS1.GetType() != aS2.GetType())

        {

        rv = EFalse;

        VCXLOGLO3("Type doesn't match: Type1 = %d Type2 = %d", aS1.GetType(), aS2.GetType());

        }

    CIptvIapList& iapListS1 = aS1.GetIapList();

    CIptvIapList& iapListS2 = aS2.GetIapList();

    TIptvIap iapS1;

    TIptvIap iapS2;

    if(iapListS1.Count() != iapListS2.Count())

        {

        rv = EFalse;

        VCXLOGLO3("Cnt of iaps doesn't match: Service1 = %d Service2 = %d", iapListS1.Count(), iapListS2.Count());

        }

    if(rv) // Same count of iaps

        {

        for(i = 0; i < iapListS1.Count(); i++)

            {

            iapListS1.GetIap(i, iapS1);

            iapListS2.GetIap(i, iapS2);

            if(iapS1.iId != iapS2.iId || iapS1.iPriority != iapS2.iPriority)

                {

                rv = EFalse;

                VCXLOGLO2("IAP %d doesn't match", i);

                }

            }