/*

* Copyright (c) 2002-2004 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:   Object to offer some common utility functions to Iptv engine testing*

*/

// INCLUDE FILES

#include <e32Base.h>

#include "mmf/common/mmfcontrollerpluginresolver.h"

#include "CIptvTestUtilities.h"

#include "CIptvTestSMApiUtil.h"

#include "CIptvTestMVApiUtil.h"

#include "CIptvTestVCApiUtil.h"

#include "CIptvTestVerifyData.h"

#include "CIptvService.h"

#include "TestUtilConnectionWaiter.h"

#include "VCXTestLog.h"

#include <tz.h>

#include <badesca.h>

#include "CIptvVodContentCategoryBriefDetails.h"

#include "CIptvVodContentContentFullDetails.h"

#include "CIptvVodContentContentBriefDetails.h"

#include "CIptvMediaContent.h"

#include "CIptvMyVideosVideoFullDetails.h"

#include "CIptvTestVodContentAllDetails.h"

#include "VCXTestCommon.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

const TUint32 KReservedSpaceForDriveCInPercentage(10);

_LIT(KDummyfilePathFormat, "%S:\\data\\temp");

_LIT(KDummyfileFormat, "%d.dat");

_LIT(KDoubleBacklash, "\\");

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// CIptvTestUtilities::CIptvTestUtilities

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CIptvTestUtilities::CIptvTestUtilities()

    {

    }

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

// CIptvTestUtilities::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CIptvTestUtilities::ConstructL()

    {

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

    User::LeaveIfError( iFs.Connect() );

    PrintIaps();

    iIptvTestSMApiUtil = CIptvTestSMApiUtil::NewL();

    iIptvTestMVApiUtil = CIptvTestMVApiUtil::NewL();

    iIptvTestVCApiUtil = CIptvTestVCApiUtil::NewL();

    iIptvVerifyData = CIptvTestVerifyData::NewL();

    iVideoCreator = CIptvTestVideoCreator::NewL();

    iVcxCommon = CVCXTestCommon::NewL();

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

    }

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

// CIptvServicesFromFile::NewL

// Two-phased constructor.

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

//

EXPORT_C CIptvTestUtilities* CIptvTestUtilities::NewL()

    {

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

    CIptvTestUtilities* self = new( ELeave ) CIptvTestUtilities;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

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

    return self;

    }

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

// CIptvServicesFromFile::~CIptvTestUtilities

// Destructor

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

//

CIptvTestUtilities::~CIptvTestUtilities()

    {

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

    delete iIptvTestSMApiUtil;

    iIptvTestSMApiUtil=NULL;

    delete iIptvTestMVApiUtil;

    iIptvTestMVApiUtil=NULL;

    delete iIptvTestVCApiUtil;

    iIptvTestVCApiUtil = NULL;

	delete iIptvVerifyData;

	iIptvVerifyData = NULL;

    delete iVideoCreator;

    iVideoCreator = NULL;

    iFs.Close();

    delete iVcxCommon;

    iVcxCommon = NULL;

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

    }

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

// CIptvTestUtilities::PrintIptvService()

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

//

EXPORT_C void CIptvTestUtilities::PrintIptvService(CIptvService *aIptvService)

	{

	VCXLOGLO1(">>>CIptvTestUtilities::PrintIptvService");

	TUint8 i;

	VCXLOGLO1("");

	VCXLOGLO1("---- CIptvService Print ----");

	VCXLOGLO2("Service ID: %d", aIptvService->GetId());

	VCXLOGLO2("Service groupID: %d", aIptvService->GetGroupId());

	VCXLOGLO2("Service name: %S", &aIptvService->GetName());

	VCXLOGLO2("Service address: %S", &aIptvService->GetAddress());

	VCXLOGLO2("Service search url: %S", &aIptvService->SearchUrl());

	VCXLOGLO2("Service icon path: %S", &aIptvService->GetIconPath());

	VCXLOGLO2("Service EPG plugin UID: %x", aIptvService->GetEpgPluginUid());

	VCXLOGLO2("Service VOD plugin UID: %x", aIptvService->GetVodPluginUid());

	VCXLOGLO2("Service IPTV Plugin UID: %x", aIptvService->GetIptvPluginUid());

	VCXLOGLO2("Service Type: %d", aIptvService->GetType());

	VCXLOGLO2("Service provider id: %S", &aIptvService->GetProviderId());

	VCXLOGLO2("Service account management url: %S", &aIptvService->GetAccountManagementUrl());

	CIptvIapList& iapList = aIptvService->GetIapList();

	//TIptvIapList iapList;

	//iapList.SetL(aIptvService->GetIapList());

	TIptvIap iap;

	VCXLOGLO2("Service AP count: %d", iapList.Count());

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

		{

		TInt err = iapList.GetIap(i, iap);

		VCXLOGLO2("GetIap ret: %d", err);

		VCXLOGLO4("AP %d: ID %d PRIO: %d", i, iap.iId, iap.iPriority);

		}

	VCXLOGLO2("Service user name: %S", &aIptvService->GetUserName());

	VCXLOGLO2("Service password: %S", &aIptvService->GetPassword());

	VCXLOGLO2("Service desc: %S", &aIptvService->GetDesc());

	VCXLOGLO2("ESelected Flag = %d", aIptvService->GetFlags() & 1);

	VCXLOGLO2("EReadOnly Flag = %d", (aIptvService->GetFlags() & 2)>>1);

	VCXLOGLO2("EMainService Flag = %d", (aIptvService->GetFlags() & 4)>>2);

	VCXLOGLO2("EConnectionApproved Flag = %d", (aIptvService->GetFlags() & 8)>>3);

	VCXLOGLO2("Service application uid: %d", aIptvService->GetApplicationUid());

	VCXLOGLO2("Service display order: %d", aIptvService->GetDisplayOrder());

	TTime time = aIptvService->GetEpgUpdateTimeL();

	_LIT(KDateTimeString,"%D%M%Y%/0%1%/1%2%/2%3%/3 %-B%:0%H%:1%T%:2%S%.%*C2%:3%-B");

	TBuf<256> timeString;

	time.FormatL(timeString, KDateTimeString);

	VCXLOGLO2("Service EPG update: %S", &timeString);

	VCXLOGLO2("Service update time: %S", &timeString);

	TUint scheduleDlTime = aIptvService->ScheduleDlTime();

	VCXLOGLO2("ScheduleDlTime: %d", scheduleDlTime);

	TUint scheduleDlType = aIptvService->ScheduleDlType();

	VCXLOGLO2("ScheduleDlType: %d", scheduleDlType);

	TUint scheduleDlNetwork = aIptvService->ScheduleDlNetwork();

	VCXLOGLO2("ScheduleDlNetwork: %d", scheduleDlNetwork);

	time = aIptvService->GetScheduledLastDownloadTime();

	time.FormatL(timeString, KDateTimeString);

	VCXLOGLO2("Service scheduled last download time: %S", &timeString);

	VCXLOGLO1("<<<CIptvTestUtilities::PrintIptvService");

	}

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

// CIptvTestUtilities::PrintIptvService()

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

//

EXPORT_C void CIptvTestUtilities::WriteVerifyIptvService(TDes& aCaseId, CIptvService *aIptvService)

	{

	VCXLOGLO1(">>>CIptvTestUtilities::WriteVerifyIptvService");

	TUint8 i;

	WriteVerifyData(aCaseId, _L("---- CIptvService Print ----"));

	WriteVerifyData(aCaseId, _L("----------------------------"));

	WriteVerifyData(aCaseId, _L("Service ID: %d"), aIptvService->GetId());

	WriteVerifyData(aCaseId, _L("Service groupID: %d"), aIptvService->GetGroupId());

	WriteVerifyData(aCaseId, _L("Service name: %S"), &aIptvService->GetName());

	WriteVerifyData(aCaseId, _L("Service address: %S"), &aIptvService->GetAddress());

	WriteVerifyData(aCaseId, _L("Service search url: %S"), &aIptvService->SearchUrl());

	WriteVerifyData(aCaseId, _L("Service icon path: %S"), &aIptvService->GetIconPath());

	WriteVerifyData(aCaseId, _L("Service EPG plugin UID: %x"), aIptvService->GetEpgPluginUid());

	WriteVerifyData(aCaseId, _L("Service VOD plugin UID: %x"), aIptvService->GetVodPluginUid());

	WriteVerifyData(aCaseId, _L("Service IPTV Plugin UID: %x"), aIptvService->GetIptvPluginUid());

	WriteVerifyData(aCaseId, _L("Service Type: %d"), aIptvService->GetType());

	WriteVerifyData(aCaseId, _L("Service provider id: %S"), &aIptvService->GetProviderId());

	WriteVerifyData(aCaseId, _L("Service account management url: %S"), &aIptvService->GetAccountManagementUrl());

	CIptvIapList& iapList = aIptvService->GetIapList();

	//TIptvIapList iapList;

	//iapList.SetL(aIptvService->GetIapList());

	TIptvIap iap;

	WriteVerifyData(aCaseId, _L("Service AP count: %d"), iapList.Count());

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

		{

		iapList.GetIap(i, iap);

		WriteVerifyData(aCaseId, _L("AP %d: ID %d PRIO: %d"), i, iap.iId, iap.iPriority);

		}

	WriteVerifyData(aCaseId, _L("Service user name: %S"), &aIptvService->GetUserName());

	WriteVerifyData(aCaseId, _L("Service password: %S"), &aIptvService->GetPassword());

	WriteVerifyData(aCaseId, _L("Service desc: %S"), &aIptvService->GetDesc());

	WriteVerifyData(aCaseId, _L("ESelected Flag = %d"), aIptvService->GetFlags() & 1);

	WriteVerifyData(aCaseId, _L("EReadOnly Flag = %d"), (aIptvService->GetFlags() & 2)>>1);

	WriteVerifyData(aCaseId, _L("EMainService Flag = %d"), (aIptvService->GetFlags() & 4)>>2);

	WriteVerifyData(aCaseId, _L("EConnectionApproved Flag = %d"), (aIptvService->GetFlags() & 8)>>3);

	WriteVerifyData(aCaseId, _L("Service application uid: %d"), aIptvService->GetApplicationUid());

	WriteVerifyData(aCaseId, _L("Service display order: %d"), aIptvService->GetDisplayOrder());

	WriteVerifyData(aCaseId, _L("---- CIptvService Print ----"));

	VCXLOGLO1("<<<CIptvTestUtilities::WriteVerifyIptvService");

	}

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

// CIptvTestUtilities::CreateIptvServiceInstanceL()

// Creates CIptvServiceInstance from parameters

// returns CIptvService* and the ownership is moved to caller

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

//

EXPORT_C CIptvService* CIptvTestUtilities::CreateIptvServiceInstanceL(

                                                            CIptvServiceInfo& aService

                                                            )

    {

    VCXLOGLO1(">>>CIptvTestUtilities::CreateIptvServiceInstanceL");

    CIptvService* iptvService = CIptvService::NewL();

    TUint32 flags(0);

    TInt err = KErrNone;

    iptvService->SetId(0); //new id is generated anyways in DB, no matter what this is

    iptvService->SetName(aService.iName);

    iptvService->SetAddress(aService.iAddress);

    iptvService->SetIconPath(aService.iIconPath);

    iptvService->SetEpgPluginUid(aService.iEpgPluginUid);

    iptvService->SetVodPluginUid(aService.iVodPluginUid);

    iptvService->SetIptvPluginUid(aService.iIptvPluginUid);

    iptvService->SetType(aService.iServiceType);

    if(aService.iIapList)

    	{

    	err = iptvService->SetIapListL(*aService.iIapList);

	    if(err != KErrNone)

	    	{

	    	delete iptvService;

	    	User::Leave(err);

	    	}

    	}

    iptvService->SetUserName(aService.iUserName);

    iptvService->SetPassword(aService.iPassWord);

    iptvService->SetDesc(aService.iDesc);

    iptvService->SetProviderId(aService.iProviderId);

    iptvService->SetAccountManagementUrl(aService.iAccountManagementUrl);

    //flags

    if(aService.iSelectedFlag)

        {

        flags = flags | CIptvService::ESelected;

        }

    if(aService.iReadOnlyFlag)

        {

        flags = flags | CIptvService::EReadOnly;

        }

    if(aService.iMainServiceFlag)

        {

        flags = flags | CIptvService::EMainService;

        }

    if(aService.iConnectionApprovedFlag)

        {

        flags = flags | CIptvService::EConnectionApproved;

        }

    iptvService->SetFlags(flags);

    iptvService->SetApplicationUid(aService.iApplicationUid);

    iptvService->SetDisplayOrder(aService.iDisplayOrder);

    VCXLOGLO1("<<<CIptvTestUtilities::CreateIptvServiceInstanceL");

    return iptvService;

    }

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

// CIptvTestUtilities::VerifyServices

// Creates CIptvServiceInstance from parameters

// returns TRUE if services are equal, othervise false

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

//

EXPORT_C TBool CIptvTestUtilities::VerifyServices(CIptvService& aS1, CIptvService& aS2)

{

	VCXLOGLO1(">>>CIptvTestUtilities::VerifyServices");

	TBool rv(TRUE);

	TUint8 i(0);

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

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

	//ids can't be verified now

	/*if(aS1.GetId() != aS2.GetId())

	{

		rv = FALSE;

		VCXLOGLO3("Id doesn't match: id1 = %d, id2 = %d", aS1.GetId(), aS2.GetId() );

	}*/

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

	    {

	    rv = FALSE;

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

	    }

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

	    {

	     rv = FALSE;

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

	    }

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

	    {

	     rv = FALSE;

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

	    }

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

	    {

	     rv = FALSE;

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

	    }

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

	    {

	     rv = FALSE;

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

	    }

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

	    {

	     rv = FALSE;

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

	    }

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

            {

            rv = FALSE;

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

            }

        //iaplist

    	//TIptvIapList iapListS1;

    	//TIptvIapList iapListS2;

    	CIptvIapList& iapListS1 = aS1.GetIapList();

    	CIptvIapList& iapListS2 = aS2.GetIapList();

	    TIptvIap iapS1;

	    TIptvIap iapS2;

       // iapListS1 = aS1.GetIapList();

    	//iapListS2 = aS2.GetIapList();

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

	        {

	        rv = FALSE;

            VCXLOGLO3("Count 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++)

        		{

        		TInt err = iapListS1.GetIap(i,  iapS1);

        		VCXLOGLO2("GetIap ret: %d", err);

        		User::LeaveIfError(err);

        		err = iapListS2.GetIap(i, iapS2);

        		VCXLOGLO2("GetIap ret: %d", err);

        		User::LeaveIfError(err);

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

        		    {

        		    rv = FALSE;

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

        		    }

        		}

	        }

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

            {

            rv = FALSE;

            VCXLOGLO3("UserName doesn't match: UserName1 = %S, UserName2 = %S",&aS1.GetUserName() ,&aS2.GetUserName());

            }

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

            {

            rv = FALSE;

            VCXLOGLO3("Password doesn't match:Password1 = %S, Password2 = %S",&aS1.GetPassword() ,&aS2.GetPassword());

            }

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

            {

            rv = FALSE;

            VCXLOGLO3("Desription doesn't match: Desription1 = %S, Desription2 = %S",&aS1.GetDesc() ,&aS2.GetDesc());

            }

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

            {

            rv = FALSE;

            VCXLOGLO3("Flags doesn't match: 0x%x & 0x%x", aS1.GetFlags(), aS2.GetFlags() );

            VCXLOGLO1("Service1 flags: ");

            if(aS1.GetFlags() & CIptvService::ESelected)

            	{

            	VCXLOGLO1("ESelected");

            	}

            if(aS1.GetFlags() & CIptvService::EReadOnly)

            	{

            	VCXLOGLO1("EReadOnly");

            	}

            if(aS1.GetFlags() & CIptvService::EMainService)

            	{

            	VCXLOGLO1("EMainService");

            	}

            if(aS1.GetFlags() & CIptvService::EConnectionApproved)

            	{

            	VCXLOGLO1("EConnectionApproved");

            	}

            if(aS1.GetFlags() & CIptvService::EReadOnlyIaps)

            	{

            	VCXLOGLO1("EReadOnlyIaps");

            	}

			VCXLOGLO1("Service2 flags: ");

            if(aS2.GetFlags() & CIptvService::ESelected)

            	{

            	VCXLOGLO1("ESelected");

            	}

            if(aS2.GetFlags() & CIptvService::EReadOnly)

            	{

            	VCXLOGLO1("EReadOnly");

            	}

            if(aS2.GetFlags() & CIptvService::EMainService)

            	{

            	VCXLOGLO1("EMainService");

            	}

            if(aS2.GetFlags() & CIptvService::EConnectionApproved)