/*

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

#include <f32file.h>

#include "VCXTestLog.h"

#include "CIptvUtil.h"

#include <s32mem.h>

#include "CIptvTestUtilities.h"

#include <ipvideo/CCseSchedulerAPI.h>

#include <ipvideo/CCseScheduledProgram.h>

//#include <CseSchedulerPluginIF.hrh>

#include "iptvvodscheduleddownloaddefinitions.h"

#include "IptvEngineUids.h"

#include "CIptvTestTimer.h"

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES

//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS

const TInt KTestPanic = -69;

const TInt KTmpBufLen = 256;

const TInt32 KInvalidPluginUid = -1;

// MACROS

//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS

//const ?type ?constant_var = ?constant;

//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES

//enum ?declaration

//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES

//?type ?function_name( ?arg_type, ?arg_type );

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

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

void PrintTime(TTime time)

    {

    TDateTime date(time.DateTime());

    _LIT( KTimeFormat, "Time = %d.%d.%d %d:%d" );

    TBuf<80>    buffer;

    buffer.Format( KTimeFormat, date.Day() + 1, date.Month() + 1, date.Year(), date.Hour(), date.Minute() );

	VCXLOGLO2( "%S", &buffer );

    }

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

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

// CVCXScheduledReminderTest::Delete

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

// Called from destructor.

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

//

void CVCXScheduledReminderTest::Delete()

    {

    VCXLOGLO1(">>>CVCXScheduledReminderTest::Delete");

    if(iSchedulerClient)

        {

        delete iSchedulerClient;

        iSchedulerClient = NULL;

        }

	if(iTestUtil!=NULL)

		{

		delete iTestUtil;

		iTestUtil=NULL;

		}

	if(iShutdownTimer!=NULL)

		{

		iShutdownTimer->CancelTimer();

		delete iShutdownTimer;

		iShutdownTimer = NULL;

		}

	iScheduleArray.ResetAndDestroy();

	iScheduleArray.Close();

	VCXLOGLO1("<<<CVCXScheduledReminderTest::Delete");

    }

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

// CVCXScheduledReminderTest::RunMethodL

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

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

//

TInt CVCXScheduledReminderTest::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", CVCXScheduledReminderTest::CreateL ),

        ENTRY( "RefreshService", CVCXScheduledReminderTest::RefreshServiceL ),

        ENTRY( "SetIap", CVCXScheduledReminderTest::SetIapL ),

        ENTRY( "ScheduleDownload", CVCXScheduledReminderTest::ScheduleDownloadL ),

        ENTRY( "AddSchedule", CVCXScheduledReminderTest::AddScheduleL ),

        ENTRY( "RemoveSchedule", CVCXScheduledReminderTest::RemoveScheduleL ),

        ENTRY( "RemoveAllSchedules", CVCXScheduledReminderTest::RemoveAllSchedulesL ),

        ENTRY( "RemoveAllFromArray", CVCXScheduledReminderTest::RemoveAllFromArrayL ),

        ENTRY( "GetSchedulesByAppUid", CVCXScheduledReminderTest::GetSchedulesByAppUidL ),

        ENTRY( "GetOverlappingSchedules", CVCXScheduledReminderTest::GetOverlappingSchedulesL ),

        ENTRY( "GetSchedulesByPluginUid", CVCXScheduledReminderTest::GetSchedulesByPluginUidL ),

        ENTRY( "GetSchedulesByType", CVCXScheduledReminderTest::GetSchedulesByTypeL ),

        ENTRY( "GetSchedulesByTime", CVCXScheduledReminderTest::GetSchedulesByTimeL ),

        ENTRY( "CheckCount", CVCXScheduledReminderTest::CheckCountL ),

        ENTRY( "EmptyArray", CVCXScheduledReminderTest::EmptyArray ),

        ENTRY( "AdjustClock", CVCXScheduledReminderTest::AdjustClockL ),

        ENTRY( "SetTimeout", CVCXScheduledReminderTest::SetTimeoutL ),

        };

    const TInt count = sizeof( KFunctions ) /

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

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

// CIptvVodDlApiTest::SetTimeoutL

// Set the timeout timer for the testcase. Timeout is given as 1/1000 seconds.

// Timeout's max value is 2147482 ms = 37 minutes.

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

//

TInt CVCXScheduledReminderTest::SetTimeoutL( CStifItemParser& aItem )

	{

	VCXLOGLO1(">>>CVCXScheduledReminderTest::SetTimeoutL");

	iShutdownTimer = CIptvTestTimer::NewL(*this, 0);

	TInt timeout(0);

	if(iShutdownTimer != NULL)

		{

		if(KErrNone!=aItem.GetNextInt(timeout))

			{

			VCXLOGLO1("Timeout value  missing");

			VCXLOGLO1("<<<CVCXScheduledReminderTest::SetTimeoutL");

			delete iShutdownTimer;

			iShutdownTimer = NULL;

			return KErrArgument;

			}

		}

	else

		{

		VCXLOGLO1("Couldn't create the timer");

		VCXLOGLO1("<<<CVCXScheduledReminderTest::SetTimeoutL");

		return KErrGeneral;

		}

	TTimeIntervalMicroSeconds32 interval((timeout * 1000));

	iShutdownTimer->After(interval);

	VCXLOGLO1("<<<CVCXScheduledReminderTest::SetTimeoutL");

	return KErrNone;

	}

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

// CVCXScheduledReminderTest::TimerComplete

//

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

//

void CVCXScheduledReminderTest::TimerComplete( TInt /* aTimerId */, TInt /* aError */ )

	{

	VCXLOGLO1(">>>CVCXScheduledReminderTest::TimerComplete");

	VCXLOGLO1("XXXXXXXX TESTCASE TIMEOUT XXXXXXXXX");

	Signal( KErrTimedOut );

	//User::Leave( KErrTimedOut );

	VCXLOGLO1("<<<CVCXScheduledReminderTest::TimerComplete");

	}

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

// CVCXScheduledReminderTest::CreateL

//

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

//

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

    {

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

    // Print to UI

    _LIT( KVCXScheduledReminderTest, "VCXScheduledReminderTest" );

    _LIT( KCreate, "In Create" );

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

    // Print to log file

    iLog->Log( KCreate );

    iSchedulerClient = CCseSchedulerApi::NewL();

	iTestUtil = CIptvTestUtilities::NewL();

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

    return KErrNone;

    }

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

// CVCXScheduledReminderTest::RefreshServiceL

//

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

//

TInt CVCXScheduledReminderTest::RefreshServiceL( CStifItemParser& aItem )

    {

    VCXLOGLO1(">>>CVCXScheduledReminderTest::RefreshServiceL");

    // Print to UI

    _LIT( KVCXScheduledReminderTest, "VCXScheduledReminderTest" );

    _LIT( KRefreshService, "In RefreshService" );

    TestModuleIf().Printf( 0, KVCXScheduledReminderTest, KRefreshService );

    // Print to log file

    iLog->Log( KRefreshService );

    TUint serviceId = GetServiceL(aItem);

	aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

	TTime refreshDate(0);

	TPtrC dateString;

	if(aItem.GetNextString(dateString) != KErrNone) {

		VCXLOGLO1("CVCXScheduledReminderTest::RefreshServiceL -- No date given as parameter, using Universal Time.");

		refreshDate.UniversalTime();

	}

	else {

		VCXLOGLO2("CVCXScheduledReminderTest::RefreshServiceL -- Using date string %S", &dateString);

		TInt err;

		err = refreshDate.Set( dateString );

		if( err != KErrNone ) {

			VCXLOGLO2("CVCXScheduledReminderTest::RefreshServiceL -- refreshDate.Set() returned error code %d", err);

			return KErrArgument;

		}

	}

    VCXLOGLO2("CSchedulingTest::RefreshService: sid = %d", serviceId);

	TInt ret = iTestUtil->RefreshService(serviceId, refreshDate);

    VCXLOGLO2("CSchedulingTest::RefreshService returned %d", ret);

    VCXLOGLO1("<<<CVCXScheduledReminderTest::RefreshServiceL");

    return KErrNone;

    }

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

// CVCXScheduledReminderTest::SetIapL ( service (name or id), iap (name or id) )

//

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

//

TInt CVCXScheduledReminderTest::SetIapL( CStifItemParser& aItem )

    {

    VCXLOGLO1(">>>CVCXScheduledReminderTest::SetIapL");

    // Print to UI

    _LIT( KVCXScheduledReminderTest, "VCXScheduledReminderTest" );

    _LIT( KSetIap, "In SetIap" );

    TestModuleIf().Printf( 0, KVCXScheduledReminderTest, KSetIap );

    // Print to log file

    iLog->Log( KSetIap );

    TUint sid = GetServiceL(aItem);

    TUint iap = GetIapL(aItem);

    VCXLOGLO3("CSchedulingTest::SetIap: sid = %d, iap = %d",sid, iap);

    TInt  ret = iTestUtil->SetUsedIap(sid, iap);

    VCXLOGLO2("CSchedulingTest:  SetUsedIap returned %d", ret);

    VCXLOGLO1("<<<CVCXScheduledReminderTest::SetIapL");

    return ret;

    }

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

// CVCXScheduledReminderTest::ScheduleDownloadL(start, end, service )

//

// start and end times are given as seconds relative to this moment.

// If values are negative, times are in the past.

// Service can be name or id

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

//

TInt CVCXScheduledReminderTest::ScheduleDownloadL( CStifItemParser& aItem )

    {

    VCXLOGLO1(">>>CVCXScheduledReminderTest::ScheduleDownloadL");

    // Print to UI

    _LIT( KVCXScheduledReminderTest, "VCXScheduledReminderTest" );

    _LIT( KScheduleDownload, "In ScheduleDownload" );

    TestModuleIf().Printf( 0, KVCXScheduledReminderTest, KScheduleDownload );

    // Print to log file

    iLog->Log( KScheduleDownload );

    CCseScheduledProgram* program = CCseScheduledProgram::NewL();

    TInt start(0);

    TInt end(0);

    aItem.GetNextInt(start);

    aItem.GetNextInt(end);

    TTime now;

    now.UniversalTime();

    TTime startTime = now + TTimeIntervalSeconds(start);

    TTime endTime   = now + TTimeIntervalSeconds(end);

    program->SetStartTime(TTime(startTime));

    program->SetEndTime(TTime(endTime));

    VCXLOGLO1("Now / Universal time:");

    PrintTime(now);

    TTime local;

    local.HomeTime();

    VCXLOGLO1("Now / Local time:");

    PrintTime(local);

    VCXLOGLO1("Scheduled starttime:");

    PrintTime(startTime);

    VCXLOGLO1("Scheduled endtime:");

    PrintTime(endTime);

    TUint id = GetServiceL(aItem);

    HBufC8* dataBuf = HBufC8::NewLC(sizeof(TIptvServiceId));

    TPtr8 dataPtr(dataBuf->Des());

    RDesWriteStream writeStream;

    CleanupClosePushL(writeStream);

    writeStream.Open(dataPtr);

    writeStream.WriteUint32L(id);

    CleanupStack::PopAndDestroy(&writeStream);

    program->SetApplicationDataL(dataPtr);

    CleanupStack::PopAndDestroy(dataBuf);

    TPtrC name(_L("<empty>"));

    //aItem.GetNextString(name);

    TBuf8<KTmpBufLen> nameBuf;

    nameBuf.Copy(name);

    program->SetName(nameBuf);

    TInt dbId(id);

    //aItem.GetNextInt(dbId);

    program->SetDbIdentifier(dbId);

    TInt appUid( IPTV_SERVER_UID );

    //aItem.GetNextInt(appUid);

    program->SetAppUid(appUid);

    TInt pluginUid( KIptvScheduledDownloadPluginImplementationUid );

    //aItem.GetNextInt(pluginUid);

    program->SetPluginUid(pluginUid);

    TInt type( CCseScheduledProgram::ECseScheduleDownload );

    //aItem.GetNextInt(type);

    program->SetScheduleType(type);

    //TUint32 pluginType = CCseScheduledProgram::ECseUniPlugin;

    //program->SetPluginType(pluginType);

    iSchedulerClient->AddSchedule(*program);

    VCXLOGLO1("<<<CVCXScheduledReminderTest::ScheduleDownloadL");

    return KErrNone;

    }

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

// CVCXScheduledReminderTest::AddScheduleL( CStifItemParser& aItem )

//

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

//

TInt CVCXScheduledReminderTest::AddScheduleL( CStifItemParser& aItem )

	{

    VCXLOGLO1(">>>VCXScheduledReminderTest::AddScheduleL");

    // Print to UI

    _LIT( KModule, "VCXScheduledReminderTest" );

    _LIT( KWhere, "In ScheduleDownload" );

    TestModuleIf().Printf( 0, KModule, KWhere );

	// Construct the program

    CCseScheduledProgram* program = CCseScheduledProgram::NewL();

    CleanupStack::PushL( program );

    TPtrC name(_L("<empty>"));

    TBuf8<KTmpBufLen> nameBuf;

    nameBuf.Copy(name);

    program->SetName(nameBuf);

    VCXLOGLO2("VCXScheduledReminderTest: ServiceName: %S", &nameBuf);

    // Set type

    TInt schedType( 0 );

    if( aItem.GetNextInt( schedType ) != KErrNone )

    	{

    	VCXLOGLO1("Unable to read NextInt");

    	VCXLOGLO1("<<<VCXScheduledReminderTest::AddScheduleL");

    	CleanupStack::PopAndDestroy();	//CCseScheduledProgram

    	return KErrArgument;

    	}

    program->SetScheduleType( schedType );

	VCXLOGLO2("VCXScheduledReminderTest: ScheduleType: %d", schedType);

   	// Set start & end

    TInt start(0);

    TInt end(0);

    if( aItem.GetNextInt(start) != KErrNone )

    	{

    	VCXLOGLO1("Unable to read NextInt to start");

    	VCXLOGLO1("<<<VCXScheduledReminderTest::AddScheduleL");

    	CleanupStack::PopAndDestroy();	//CCseScheduledProgram

    	return KErrArgument;

    	}

	if( aItem.GetNextInt(end) != KErrNone )

		{

    	VCXLOGLO1("Unable to read NextInt to end");

    	VCXLOGLO1("<<<VCXScheduledReminderTest::AddScheduleL");

    	CleanupStack::PopAndDestroy();	//CCseScheduledProgram

    	return KErrArgument;

		}

    TTime now;

    now.UniversalTime();

    TTime startTime = now + TTimeIntervalSeconds(start);

    TTime endTime   = now + TTimeIntervalSeconds(end);

    VCXLOGLO2("VCXScheduledReminderTest: Start: %d", start);

    VCXLOGLO2("VCXScheduledReminderTest: End: %d", end);

    program->SetStartTime(TTime(startTime));

    program->SetEndTime(TTime(endTime));

	// Print times

    VCXLOGLO1("Now / Universal time:");

    PrintTime(now);

    TTime local;

    local.HomeTime();

    VCXLOGLO1("Now / Local time:");

    PrintTime(local);

    VCXLOGLO1("Scheduled starttime:");

    PrintTime(TTime(startTime));

    VCXLOGLO1("Scheduled endtime:");

    PrintTime(TTime(endTime));

    // Set plugin UID to use

    TInt pluginId( 0 );

    if ( aItem.GetNextInt( pluginId ) != KErrNone )

    	{

    	VCXLOGLO1("Unable to read NextInt");

    	VCXLOGLO1("<<<VCXScheduledReminderTest::AddScheduleL");

    	CleanupStack::PopAndDestroy();	//CCseScheduledProgram

    	return KErrArgument;

    	}

    program->SetPluginUid( GetPluginUidByNumber(pluginId) );

	// Set plugin type

    TInt pluginType( 0 );

    if ( aItem.GetNextInt( pluginType ) != KErrNone )

    	{

    	VCXLOGLO1("Unable to read NextInt");

    	VCXLOGLO1("<<<VCXScheduledReminderTest::AddScheduleL");

    	CleanupStack::PopAndDestroy();	//CCseScheduledProgram

    	return KErrArgument;

    	}

    if( pluginType == 0 )

    	{

   	    program->SetPluginType( CCseScheduledProgram::ECseUniPlugin );

	   	}

	else

		{

		program->SetPluginType( CCseScheduledProgram::ECseMultiPlugin );

		}

    // Set app uid

    // This is used as a default, does it matter?

    program->SetAppUid( IPTV_SERVER_UID );

    // Set application data

    TUint id = GetServiceL(aItem);

    VCXLOGLO2("VCXScheduledReminderTest: Using Service id: %d", id);

    HBufC8* dataBuf = HBufC8::NewLC(sizeof(TIptvServiceId));

    TPtr8 dataPtr(dataBuf->Des());

    RDesWriteStream writeStream;

    CleanupClosePushL(writeStream);

    writeStream.Open(dataPtr);

    writeStream.WriteUint32L(id);

    CleanupStack::PopAndDestroy(&writeStream);

    program->SetApplicationDataL(dataPtr);