/*

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

#include <tz.h>

#include <badesca.h>

#include <commdb.h>

#include <mmf/common/mmfcontrollerpluginresolver.h>

#include "VCXTestCommon.h"

#include "CIptvTestVerifyData.h"

#include "TestUtilConnectionWaiter.h"

#include "VCXTestLog.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

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

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

_LIT(KDoubleBacklash, "\\");

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// CVCXTestCommon::CVCXTestCommon

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

// might leave.

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

//

CVCXTestCommon::CVCXTestCommon()

    {

    }

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

// CVCXTestCommon::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CVCXTestCommon::ConstructL()

    {

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

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

    PrintIaps(); 

    PrintDriveInfo( _L("C") );

    PrintDriveInfo( _L("E") );

    PrintDriveInfo( _L("D") );

    PrintDriveInfo( _L("F") );

    //ListDir( _L("C:\\"), 0 );

    //ListDir( _L("E:\\"), 0 );

    iIptvVerifyData = CIptvTestVerifyData::NewL();

    iVideoCreator = CIptvTestVideoCreator::NewL();

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

    }

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

// CIptvServicesFromFile::~CVCXTestCommon

// Destructor

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

//

CVCXTestCommon::~CVCXTestCommon()

    {

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

    delete iIptvVerifyData;

    iIptvVerifyData = NULL;

    delete iVideoCreator;

    iVideoCreator = NULL;

    iFs.Close();

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

    }

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

// CVCXTestCommon::NewL

// Two-phased constructor.

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

//

EXPORT_C CVCXTestCommon* CVCXTestCommon::NewL()

    {

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

    CVCXTestCommon* self = new( ELeave ) CVCXTestCommon;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

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

    return self;

    }

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

// CVCXTestCommon::GetFileSize

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

//

EXPORT_C TBool CVCXTestCommon::GetFileSize(TDesC& aFullPath, TUint32& aFileSize)

    {

    VCXLOGLO1(">>>CVCXTestCommon::GetFileSize");

    TBool rv = FALSE;

    TEntry entry;

    TInt err = KErrNone;

    aFileSize=0;

    err = iFs.Entry( aFullPath, entry );

    if(KErrNone == err && !entry.IsDir())

        {

        aFileSize = entry.iSize;

        rv = TRUE;

        }

    VCXLOGLO1("<<<CVCXTestCommon::GetFileSize");

    return rv;

    }

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

// CVCXTestCommon::GetIapIdL

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

//

EXPORT_C TBool CVCXTestCommon::GetIapIdL(const TDesC& aIapName, TUint32& aIapId)

    {

    VCXLOGLO1(">>>CVCXTestCommon::GetIapIdL");

    TBool found( EFalse );

#ifdef __WINSCW__

    if( aIapName != KIptvTestBadIapName && aIapName != _L("invalidiap") )

        {

        _LIT(KEmulatorIap, "Ethernet with Daemon Dynamic IP");

        found = GetIapIdByNameL(KEmulatorIap, aIapId);

        VCXLOGLO1("<<<CVCXTestCommon::GetIapIdL");

        return found;

        }

#endif

    VCXLOGLO2("CVCXTestCommon:: Searching IAP: %S", &aIapName);

    found = GetIapIdByNameL(aIapName, aIapId);

    // Iap with exact name found

    if( found )

        {

        VCXLOGLO1("<<<CVCXTestCommon::GetIapIdL");

        return found;

        }

    else

    if(aIapName == KIptvTestBadIapName) // Search bad iap only for a name.

        {

        VCXLOGLO2("CVCXTestCommon:: Iap with name %S not found!", &aIapName);

        VCXLOGLO1("<<<CVCXTestCommon::GetIapIdL");

        return found;

        }

    VCXLOGLO1("<<<CVCXTestCommon:: Iap with exact name was not found.");

    TBuf<128> searchFor(aIapName);

    searchFor.LowerCase();

    if(searchFor == _L("invalidiap") )

        {

        aIapId = 6000;

        VCXLOGLO1("<<<CVCXTestCommon::GetIapIdL");

        return ETrue;

        }

    TBool isWlanIapName( EFalse );

    if( aIapName == _L("wlan") )

        {

        found = GetIapIdByTypeL(CVCXTestCommon::EWlanIap, aIapId, 0);

        isWlanIapName = ETrue;

        }

    else

    if( aIapName == _L("wlan2") )

        {

        found = GetIapIdByTypeL(CVCXTestCommon::EWlanIap, aIapId, 1);

        isWlanIapName = ETrue;

        }

    else

    if( aIapName == _L("internet") )

        {

        found = GetIapIdByTypeL(CVCXTestCommon::EGprsIap, aIapId, 0);

        }

    else

    if( aIapName == _L("internet2") )

        {

        found = GetIapIdByTypeL(CVCXTestCommon::EGprsIap, aIapId, 1);

        }

    if( !found && !isWlanIapName )

        {

        VCXLOGLO1("<<<CVCXTestCommon:: Trying to find alternative IAP.");

        // Try search other known GPRS IAPs

        _LIT(KIapElisaInternet, "elisa internet");

        _LIT(KIapElisaMMS, "elisa mms");

        _LIT(KIapInternet, "internet");

        _LIT(KIapProinternet, "prointernet");

        _LIT(KGprsInternet, "gprs internet");

        if( GetIapIdByNameL(KIapElisaInternet, aIapId) ||

            GetIapIdByNameL(KIapElisaMMS, aIapId) ||

            GetIapIdByNameL(KIapInternet, aIapId) ||

            GetIapIdByNameL(KIapProinternet, aIapId) ||

            GetIapIdByNameL(KGprsInternet, aIapId) )

            {

            found = ETrue;

            }

        if( !found )

            {

            VCXLOGLO1("<<<CVCXTestCommon:: Any GPRS IAP is good...");

            found = GetIapIdByTypeL(CVCXTestCommon::EGprsIap, aIapId, 0);

            }

        }

    else

        {

        VCXLOGLO1("<<<CVCXTestCommon:: WLAN IAP wanted. Not found.");

        }

    VCXLOGLO1("<<<CVCXTestCommon::GetIapIdL");

    return found;

    }

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

// CVCXTestCommon::GetIapIdByNameL

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

//

EXPORT_C TBool CVCXTestCommon::GetIapIdByNameL(const TDesC& aIapName, TUint32& aIapId)

    {

    VCXLOGLO1(">>>CVCXTestCommon::GetIapIdByNameL");

    TBool found = EFalse;

    aIapId = 0;

    TBuf<128> searchFor(aIapName);

    searchFor.LowerCase();

    // Get IAP names and ids from the database

    CCommsDatabase* cdb( NULL );

    TRAPD( err, cdb = CCommsDatabase::NewL( EDatabaseTypeIAP ) );

    if( err != KErrNone )

        {

        VCXLOGLO2("CVCXTestCommon::GetIapIdByNameL: CCommsDatabase::NewL left: %d, leaving", err);

        User::Leave( err );

        }

    CleanupStack::PushL( cdb );

    cdb->ShowHiddenRecords();

    CCommsDbTableView* view( NULL );

    TRAP( err, view = cdb->OpenTableLC( TPtrC(IAP) ); CleanupStack::Pop( view ); );

    CleanupStack::PushL( view );

    if( err != KErrNone )

        {

        VCXLOGLO2("CVCXTestCommon::GetIapIdByNameL: CCommsDatabase::OpenTableLC left: %d, leaving", err);

        User::Leave( err );

        }

    TBuf<40> name;

    TUint32 id;

    TInt res = view->GotoFirstRecord();

    while( res == KErrNone )

        {

        TRAP( err, view->ReadTextL( TPtrC(COMMDB_NAME), name ) );

        if( err != KErrNone ) continue;

        TRAP( err, view->ReadUintL( TPtrC(COMMDB_ID), id ) );

        if( err != KErrNone ) continue;

        name.LowerCase();

        if(searchFor == name)

            {

            aIapId = id;

            VCXLOGLO3("CVCXTestCommon:: Found IAP: %d, %S", aIapId, &aIapName);

            found = ETrue;

            break;

            }

        res = view->GotoNextRecord();

        }

    CleanupStack::PopAndDestroy( view );

    CleanupStack::PopAndDestroy( cdb );

    VCXLOGLO1("<<<CVCXTestCommon::GetIapIdByNameL");

    return found;

    }

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

// CVCXTestCommon::GetIapIdByTypeL

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

//

EXPORT_C TBool CVCXTestCommon::GetIapIdByTypeL(TIptvTestIapType aType, TUint32& aIapId, TInt aOrderNumber)

    {

    VCXLOGLO1(">>>CVCXTestCommon::GetIapIdByTypeL");

    aIapId = 0;

    TBool found( EFalse );

    #ifdef __WINSCW__

        found = GetIapIdByNameL( _L("Ethernet with Daemon Dynamic IP"), aIapId );

        VCXLOGLO1("<<<CVCXTestCommon::GetIapIdByTypeL");

        return found;

    #endif

    // Get AP names and ids from the database

    CCommsDatabase* TheDb = CCommsDatabase::NewL( EDatabaseTypeIAP );

    CleanupStack::PushL( TheDb );

    TheDb->ShowHiddenRecords();

    CCommsDbTableView* view = TheDb->OpenTableLC( TPtrC(IAP) );

    TBuf<40> name;

    TUint32 id;

    TBuf<255> iapType;

    TInt matchCount(0);

    TInt res = view->GotoFirstRecord();

    while( res == KErrNone )

        {

        view->ReadTextL( TPtrC(COMMDB_NAME), name );

        view->ReadUintL( TPtrC(COMMDB_ID), id );

        view->ReadTextL( TPtrC(IAP_SERVICE_TYPE), iapType);

        VCXLOGLO3("CVCXTestCommon:: name: %S, id: %d", &name, id);

        VCXLOGLO2("CVCXTestCommon:: type: %S", &iapType);

        if( ( iapType == _L("LANService") && aType == EWlanIap && name != _L("Easy WLAN") ) ||

            ( iapType == _L("OutgoingGPRS") && aType == EGprsIap ) )

            {

            if( matchCount == aOrderNumber )

                {

                found = ETrue;

                aIapId = id;

                break;

                }

            matchCount++;

            }

        res = view->GotoNextRecord();

        }

    CleanupStack::PopAndDestroy( view ); // view

    CleanupStack::PopAndDestroy( TheDb ); // TheDb

    VCXLOGLO1("<<<CVCXTestCommon::GetIapIdByTypeL");

    return found;

    }

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

// CVCXTestCommon::GetIapNameById

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

//

EXPORT_C TBool CVCXTestCommon::GetIapNameById(TDes& aIapName, TUint32 aIapId)

    {

    TBool found = FALSE;

    // Get AP names and ids from the database

    CCommsDatabase* TheDb = CCommsDatabase::NewL( EDatabaseTypeIAP );

    CleanupStack::PushL( TheDb );

    TheDb->ShowHiddenRecords();

    CCommsDbTableView* view = TheDb->OpenTableLC( TPtrC(IAP) );

    TBuf<40> name;

    TUint32 id;

    TInt res = view->GotoFirstRecord();

    while( res == KErrNone )

        {

        view->ReadTextL( TPtrC(COMMDB_NAME), name );

        view->ReadUintL( TPtrC(COMMDB_ID), id );

        res = view->GotoNextRecord();

        //VCXLOGLO3("IAP name, id: %S, %d", &name, id);

        if(id == aIapId)

            {

            found = TRUE;

            aIapName.Zero();

            aIapName.Append(name);

            break;

            }

        }

    CleanupStack::PopAndDestroy( view ); // view

    CleanupStack::PopAndDestroy( TheDb ); // TheDb

    return found;

    }

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

// CVCXTestCommon::PrintIaps

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

//

EXPORT_C void CVCXTestCommon::PrintIaps()

    {

    VCXLOGLO1(">>>CVCXTestCommon::PrintIaps");

    // Get IAP names and ids from the database

    CCommsDatabase* TheDb( NULL );

    TRAPD( err, TheDb = CCommsDatabase::NewL( EDatabaseTypeIAP ) );

    if( err == KErrNone && TheDb )

        {

        CleanupStack::PushL( TheDb );

        TheDb->ShowHiddenRecords();

        CCommsDbTableView* view( NULL );

        TRAP( err, view = TheDb->OpenTableLC( TPtrC(IAP) ); CleanupStack::Pop( view ); );

        CleanupStack::PushL( view );

        if( err == KErrNone && view )

            {

            TBuf<40> name;

            TUint32 id;

            err = view->GotoFirstRecord();

            while( err == KErrNone )

                {

                TRAP( err, view->ReadTextL( TPtrC(COMMDB_NAME), name ) );

                if( err != KErrNone ) break;

                TRAP( err, view->ReadUintL( TPtrC(COMMDB_ID), id ) );

                if( err != KErrNone ) break;

                VCXLOGLO3("CVCXTestCommon:: IAP name, id: %S, %d", &name, id);

                err = view->GotoNextRecord();

                if( err != KErrNone ) break;

                }

            }

        CleanupStack::PopAndDestroy( view ); // view

        CleanupStack::PopAndDestroy( TheDb ); // TheDb

        }

    VCXLOGLO1("<<<CVCXTestCommon::PrintIaps");

    }

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

// CIptvTestVerifyData::CreateVerifyData

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

//

EXPORT_C TInt CVCXTestCommon::CreateVerifyData(TDesC& aVerifyId, TBool aAppend)

    {

    VCXLOGLO2(">>>CVCXTestCommon::CreateVerifyData: %S", &aVerifyId);

    TInt result = KErrNone;

    TRAPD(err, result = iIptvVerifyData->CreateVerifyDataL(aVerifyId, aAppend));

    if(err != KErrNone)

        {

        VCXLOGLO2("CIptvVerifyData::CreateVerifyDataL caused a leave. %d", err);

        result = err;

        }

    VCXLOGLO1("<<<CVCXTestCommon::CreateVerifyData");

    return result;

    }

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

// CIptvTestVerifyData::WriteVerifyData

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

//

EXPORT_C TInt CVCXTestCommon::WriteVerifyData(TDesC& aVerifyId, TDesC& aVerifyData)

    {

    //VCXLOGLO1(">>>CVCXTestCommon::WriteVerifyData");

    TInt result = KErrNone;

    TRAPD(err, result = iIptvVerifyData->WriteVerifyDataL(aVerifyId, aVerifyData));

    if(err != KErrNone)

        {

        VCXLOGLO2("CIptvVerifyData::WriteVerifyDataL caused a leave. %d", err);

        result = err;

        }

    //VCXLOGLO1("<<<CVCXTestCommon::WriteVerifyData");

    return result;

    }

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

// CIptvTestVerifyData::WriteVerifyData

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

//

EXPORT_C TInt CVCXTestCommon::WriteVerifyData(TDesC& aVerifyId, TRefByValue<const TDesC> aFmt, ... )

    {

    //VCXLOGLO1(">>>CVCXTestCommon::WriteVerifyData(formatted)");

    VA_LIST argptr; //pointer to argument list

    VA_START( argptr, aFmt );

    HBufC* str;

    str = HBufC::NewLC(1024*3);

    //TBuf<512*3> str;

    //TBuf<512> format(_L("TESTI: %d, %S"));

    str->Des().FormatList(aFmt, argptr);