/*

* Copyright (c) 2006 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:    Actual intelligence of scheduler server*

*/

// INCLUDE FILES

#include <s32mem.h>

#include <e32def.h>

#include <e32const.h>

#include "CCseSchedulerServerEngine.h"      // Common methods for server

#include <ipvideo/CseSchedulerClientServerCommon.h> // Common defines for client and server

#include <ipvideo/CCseScheduledProgram.h>           // Represent one schedule in database

#include "CseDebug.h"                       // Debug macros

#include "CCseScheduleDB.h"                 // Schedule database

#include "CCseSchedulerTimer.h"             // Schedule timer for determining schedule times

#include <ipvideo/CCseSchedulerPluginIF.h>          // Scheduler plugin interface

#include "CCseSchedulerUniPluginController.h"

#include "CCseSchedulerMultiPluginController.h"

#include "CCseSchedulerServer.h"

// EXTERNAL DATA STRUCTURES

// None.

// EXTERNAL FUNCTION PROTOTYPES  

// None.

// CONSTANTS

// None

// MACROS

// None.

// LOCAL CONSTANTS AND MACROS

// None.

// MODULE DATA STRUCTURES

// None.

// LOCAL FUNCTION PROTOTYPES

// None.

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

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

// CloseEngine

// CB method used if ConstructL leaves. Just calls Close to initiate proper

// shutdown sequence

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

//

void CloseEngine( TAny* aPtr )

    {

    static_cast<CCseSchedulerServerEngine*>( aPtr )->Close();

    }

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

// CCseSchedulerServerEngine::CCseSchedulerServerEngine

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

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

//

CCseSchedulerServerEngine::CCseSchedulerServerEngine( CCseSchedulerServer& aServer ) :

    iServer( aServer )

    {

    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::CCseSchedulerServerEngine");

    CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::CCseSchedulerServerEngine");

    }

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

// CCseSchedulerServerEngine::NewL

// Two-phased constructor.

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

//

CCseSchedulerServerEngine* CCseSchedulerServerEngine::NewL( CCseSchedulerServer& aServer ) 

    {

    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::NewL");

    CCseSchedulerServerEngine* self = new( ELeave ) CCseSchedulerServerEngine( aServer );    

    CleanupStack::PushL( TCleanupItem( CloseEngine, self ) );

    self->ConstructL();

    CleanupStack::Pop( ); // CleanupItem

    CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::NewL");

    return self;

    }

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

// CCseSchedulerServerEngine::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCseSchedulerServerEngine::ConstructL()

    {

    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::ConstructL");       

    iDb = CCseScheduleDB::NewL();

    iCompletitionBreaker = CIdle::NewL( CActive::EPriorityLow );

	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::ConstructL");

    }

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

// CCseSchedulerServerEngine::~CCseSchedulerServerEngine

// Destructor.

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

//

CCseSchedulerServerEngine::~CCseSchedulerServerEngine()

    {

    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::~CCseSchedulerServerEngine");

    delete iDb;

	iPluginControllerArray.ResetAndDestroy();

	iPluginControllerArray.Close();

    delete iCompletitionBreaker;

    CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::~CCseSchedulerServerEngine");

    }

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

// CCseSchedulerServerEngine::GeneralServiceL

//

// Schedule operations

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

//

void CCseSchedulerServerEngine::GeneralServiceL( const RMessage2& aMessage )

	{

	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::GeneralService");

	switch( aMessage.Function() )

		{

		case ECseAddSchedule:

			{

			AddScheduleL( aMessage );

			break; 		

			}

		case ECseRemoveSchedule:

			{

			RemoveScheduleL( aMessage );

			break;

			}

		case ECseGetSchedules:

			{

			GetSchedulesL( aMessage );	

			break;

			}

		case ECseGetSchedule:

			{

			GetScheduleL( aMessage );

			break;

			}

		case ECseGetScheduleLength:

			{

			GetScheduleLengthL( aMessage );

			break;

			}

		case ECseGetSchedulesByAppUid:

			{

			GetSchedulesByAppUidL( aMessage );

			break;

			}

		case ECseGetScheduleArrayLengthByAppUid:

			{

			GetScheduleArrayLengthByAppUidL( aMessage );

			break;

			}

		case ECseGetOverlappingSchedulesLength:

			{

			GetOverlappingSchedulesLengthL( aMessage );

			break;

			}

		case ECseGetOverlappingSchedules:

			{

			GetOverlappingSchedulesL( aMessage );

			break;

			}			

		case ECseGetScheduleArrayLengthByPluginUid:

			{

			GetScheduleArrayLengthByPluginUidL( aMessage );

			break;

			}

		case ECseGetSchedulesByPluginUid:

			{

			GetSchedulesByPluginUidL( aMessage );

			break;

			}

		case ECseGetScheduleArrayLengthByType:

			{

			GetScheduleArrayLengthByTypeL( aMessage );

			break;

			}

		case ECseGetSchedulesByType:

			{

			GetSchedulesByTypeL( aMessage );

			break;

			}

		case ECseGetScheduleArrayLengthByTimeframe:		     

			{

			GetScheduleArrayLengthByTimeframeL( aMessage );

			break;

			}

		case ECseGetSchedulesByTimeframe:

			{

			GetSchedulesByTimeframeL( aMessage );

			break;

			}

		default:

			{

			aMessage.Complete( KErrNotSupported ); 

		    break; 

			}

		}

	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::GeneralService");

	}

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

// CCseSchedulerServerEngine::PanicClient

//

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

//

void CCseSchedulerServerEngine::PanicClient( TCseSchedulerServPanic aPanic,

											 const RMessage2& aMessage ) const

    {    

    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::PanicClient");

    // Panic the client on server side

    _LIT( KTxtClientFault, "CseSchedulerServer" );

    aMessage.Panic( KTxtClientFault, aPanic );

    CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::PanicClient");

    }

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

// CCseSchedulerServerEngine::AddScheduleL

//

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

//

void CCseSchedulerServerEngine::AddScheduleL( const RMessage2& aMessage )

	{

	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::AddScheduleL");

	TInt ret( KErrNone );

	TBuf8<4> id;

	// Initialize buffers...

	CCseScheduledProgram* schedule = CCseScheduledProgram::NewL();

	CleanupStack::PushL( schedule );

	HBufC8* msg = HBufC8::NewL( aMessage.GetDesLengthL( 0 ) );

	CleanupStack::PushL( msg );

	TPtr8 ptr( msg->Des() );

	// Read schedule as a stream format to buffer

	aMessage.ReadL( 0, ptr, 0 );

	RDesReadStream readStream;

	CleanupClosePushL( readStream );

	readStream.Open( ptr );

	// Change stream formatted schedule to "CseScheduledProgram"-format

	schedule->InternalizeL( readStream );

	CleanupStack::PopAndDestroy( &readStream );

	// Add it to DB	

	iDb->AddScheduleL( *schedule );

	// Make the completition value

	id.FillZ();

	RDesWriteStream writeStream;

	CleanupClosePushL( writeStream );

	writeStream.Open( id );

	writeStream.WriteUint32L( schedule->DbIdentifier() );

	writeStream.CommitL();

	CleanupStack::PopAndDestroy( &writeStream );

	aMessage.WriteL( 1, id, 0 );

    RescheduleByPluginL( schedule->PluginUid() );

	CleanupStack::PopAndDestroy( msg );

	CleanupStack::PopAndDestroy( schedule );

    aMessage.Complete( ret );    

    CSELOGSTRING2_HIGH_LEVEL("<<<CCseSchedulerServerEngine::AddScheduleL, ret=%d", ret);

	}

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

// CCseSchedulerServerEngine::RemoveScheduleL

//

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

//

void CCseSchedulerServerEngine::RemoveScheduleL( const RMessage2& aMessage )

	{

	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::RemoveScheduleL");

	TUint32 dbIdentifier( 0 );

	TBuf8<4> idBuff;

	TInt32 pluginUid( 0 );

	idBuff.FillZ();

	// Read db identifier from aMessager

	User::LeaveIfError( aMessage.Read( 0, idBuff ) );

	RDesReadStream readStream;

	CleanupClosePushL( readStream );

	readStream.Open( idBuff );

	dbIdentifier = readStream.ReadUint32L();

	CleanupStack::PopAndDestroy( &readStream );

	// Remove schedule

	// First check the plugin UID of removed schedule

	CCseScheduledProgram* prog = CCseScheduledProgram::NewL();

	CleanupStack::PushL( prog );

	iDb->GetScheduleByDbIdentifierL( dbIdentifier, prog );

	pluginUid = prog->PluginUid( );

	// Now remove it from DB

	iDb->RemoveScheduleL( dbIdentifier );	

	RescheduleByPluginL( pluginUid );

	// Use completition callback to remove those controllers that aren't needed anymore

	if( !iCompletitionBreaker->IsActive() )

        {            

        iCompletitionBreaker->Start(TCallBack( CompletitionCallback, this ));

        }

    else

        {

        CSELOGSTRING_HIGH_LEVEL(

            "CCseSchedulerServerEngine::ScheduleCompletedSuccesfully - Breaker already active");

        }	

	CleanupStack::PopAndDestroy( prog );

	aMessage.Complete( KErrNone );	

	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::RemoveScheduleL");

	}

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

// CCseSchedulerServerEngine::GetScheduleL

//

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

//

void CCseSchedulerServerEngine::GetScheduleL( const RMessage2& aMessage )

	{

	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::GetScheduleL");

	TUint32 dbIdentifier( 0 );

	TBuf8<4> idBuff;

	idBuff.FillZ();

	// Read db identifier from aMessage

	TInt err( aMessage.Read( 0, idBuff ) );

	if ( err == KErrNone )

		{

		// Create new db identifier to be passed to client

		CCseScheduledProgram* prog = CCseScheduledProgram::NewL();

		CleanupStack::PushL( prog );

		RDesReadStream readStream;

		CleanupClosePushL( readStream );

		readStream.Open( idBuff );

		dbIdentifier = readStream.ReadUint32L();

		CleanupStack::PopAndDestroy( &readStream );

		// Get schedule

		iDb->GetScheduleByDbIdentifierL( dbIdentifier, prog );

		TInt length( prog->ExternalizeLength() );

		// Externalize schedule to stream format

		HBufC8* retBuff = HBufC8::NewL( length );

		CleanupStack::PushL( retBuff );

		TPtr8 retPtr( retBuff->Des() );

		RDesWriteStream writeStream;

		CleanupClosePushL( writeStream );

		writeStream.Open( retPtr );

		prog->ExternalizeL( writeStream );

		writeStream.CommitL();

		CleanupStack::PopAndDestroy( &writeStream );

		User::LeaveIfError( aMessage.Write( 1, retPtr ) );

		CleanupStack::PopAndDestroy( retBuff );

		CleanupStack::PopAndDestroy( prog );

		}

	aMessage.Complete( err );

	CSELOGSTRING2_HIGH_LEVEL("<<<CCseSchedulerServerEngine::RemoveScheduleL, err=%d", err);

	}

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

// CCseSchedulerServerEngine::GetScheduleLengthL

//

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

//

void CCseSchedulerServerEngine::GetScheduleLengthL( const RMessage2& aMessage )

	{

	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::GetScheduleLengthL");

	TUint32 dbIdentifier( 0 );

	TBuf8<4> idBuff;

	TBuf8<4> lenBuff;

	TInt length( 0 );

	CCseScheduledProgram* schedule = CCseScheduledProgram::NewL();

	CleanupStack::PushL( schedule );

	idBuff.FillZ();

	// Read db identifier from aMessage

	User::LeaveIfError( aMessage.Read( 0, idBuff ) );

	RDesReadStream readStream;

	CleanupClosePushL( readStream );

	readStream.Open( idBuff );

	dbIdentifier = readStream.ReadUint32L();

	CleanupStack::PopAndDestroy( &readStream );

	// Get schedule

	iDb->GetScheduleByDbIdentifierL( dbIdentifier, schedule );

	// Get schedule length

	length = schedule->ExternalizeLength();

	lenBuff.FillZ();

	// Write length in stream so we can pass it to client

	RDesWriteStream writeStream;

	CleanupClosePushL( writeStream );

	writeStream.Open( lenBuff );

    writeStream.WriteInt32L( length );

	writeStream.CommitL();

    CleanupStack::PopAndDestroy( &writeStream );

    User::LeaveIfError( aMessage.Write( 1, lenBuff ) );

    CleanupStack::PopAndDestroy( schedule );

	aMessage.Complete( KErrNone );

	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::GetScheduleLengthL");

	}

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

// CCseSchedulerServerEngine::GetScheduleLengthL

//

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

//

void CCseSchedulerServerEngine::GetScheduleArrayLengthByAppUidL( 

											const RMessage2& aMessage )

	{

	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::GetScheduleArrayLengthByAppUidL");

	TInt32 appUid( 0 );

	TBuf8<4> idBuff;

	TBuf8<4> lenBuff;

	TInt length( 0 );

	idBuff.FillZ();

	// Read application uid from aMessage

	User::LeaveIfError( aMessage.Read( 0, idBuff ) );

	RDesReadStream readStream;

	CleanupClosePushL( readStream );

	readStream.Open( idBuff );

	appUid = readStream.ReadInt32L();

	CleanupStack::PopAndDestroy( &readStream );

    // Get schedules from database

	RPointerArray<CCseScheduledProgram> progArray;

	CleanupResetAndDestroyPushL( progArray );

	iDb->GetApplicationSchedulesL( appUid, progArray );

	// Calculate total length

	// Number of items in array

	length = length + 4; // Size of TInt32

	// Data from array

	for ( TInt i = 0 ; i < progArray.Count(); i++ )

		{

		length = length + progArray[i]->ExternalizeLength();

		}

	CleanupStack::PopAndDestroy( &progArray ); // closes progArray

	lenBuff.FillZ();

	// Change length value to stream so that we can send it back to client.

	RDesWriteStream writeStream;

	CleanupClosePushL( writeStream );

	writeStream.Open( lenBuff );

    writeStream.WriteInt32L( length );

    CleanupStack::PopAndDestroy( &writeStream );

    User::LeaveIfError( aMessage.Write( 1, lenBuff ) );

  	aMessage.Complete( KErrNone );	

	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::GetScheduleArrayLengthByAppUidL");

	}

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

// CCseSchedulerServerEngine::GetSchedulesByAppUidL

//

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

//

void CCseSchedulerServerEngine::GetSchedulesByAppUidL( const RMessage2& aMessage )

	{

	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::GetSchedulesByAppUidL");

	TInt32 appUid( 0 );

	TBuf8<4> idBuff;

	idBuff.FillZ();

	TInt32 numberOfElems( 0 );

	TInt length( 0 );

	// Read application UID from aMessage

	TInt err( aMessage.Read( 0, idBuff ) );

	if ( err == KErrNone )

		{

		RPointerArray<CCseScheduledProgram> progArray;