/*

* 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:    ?Description*

*/

// INCLUDE FILES

#include <s32mem.h>

#include "IptvDebug.h"

#include <bautils.h>

#include "CIptvMediaContent.h"

#include "TIptvRssSearchQuery.h"

#include "CIptvEpgDatabase.h"

#include "IptvLiveEpgConstants.h"

#include "CIptvMyVideosGlobalFileId.h"

#include "IptvClientServerCommon.h"

#include "CIptvEpgMsgHandler.h"

#include "CIptvServer.h"

#include "CIptvEpgManagerImpl.h"

#include "CIptvEpgVodClientImpl.h"

#include "CIptvEpgSession.h"

#include "CIptvVodContentCategoryBriefDetails.h"

#include "CIptvVodContentContentBriefDetails.h"

#include "CIptvVodContentContentFullDetails.h"

#include "CIptvEpgVodMsqQueue.h"

// CONSTANTS

const TInt KIptvFour = 4;

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

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

// CIptvEpgMsgHandler::CIptvEpgMsgHandler

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

// might leave.

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

//

CIptvEpgMsgHandler::CIptvEpgMsgHandler(CIptvServer& aServer) : 

    iVodMsgQueue (NULL ),

    iEpgSession ( NULL ), 

    iServer( aServer ), 

    iCategory( NULL ), 

    iServiceId( 0 ),

	iEpgDatabase( NULL )

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvEpgMsgHandler::CIptvEpgMsgHandler");

    }

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

// CIptvEpgMsgHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CIptvEpgMsgHandler::ConstructL()

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvEpgMsgHandler::ConstructL");

    iVodMsgQueue = CIptvEpgVodMsqQueue::NewL();

    }

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

// CIptvEpgMsgHandler::NewL

// Two-phased constructor.

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

//

CIptvEpgMsgHandler* CIptvEpgMsgHandler::NewL(CIptvServer& aServer)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvEpgMsgHandler::NewL");

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CIptvEpgMsgHandler::~CIptvEpgMsgHandler()

// Destructor.

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

//   

CIptvEpgMsgHandler::~CIptvEpgMsgHandler()

    {        

    IPTVLOGSTRING_LOW_LEVEL("CIptvEpgMsgHandler::~CIptvEpgMsgHandler");

    iCategoryBriefDetailsArray.ResetAndDestroy();

    iContentBriefDetailsArray.ResetAndDestroy();

    iMediaContentArray.ResetAndDestroy();        

    delete iContentFullDetails;

    delete iCategory;

    delete iVodMsgQueue;             

    delete iEpgSession;

    delete iEpgDatabase;

    }

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

// CIptvEpgMsgHandler::HandleEpgMsg

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

//

void CIptvEpgMsgHandler::HandleEpgMsgL(const RMessage2& aMessage)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvEpgMsgHandler::HandleEpgMsgL");

    switch ( aMessage.Function() )

        {

        case EIptvEngineVodContentUpdateEcg:

            {

            TInt err( KErrNotReady );

            if ( iEpgSession )

                {

                err = iEpgSession->UpdateEcg( ETrue );

                }

            aMessage.Complete( err );                

            }

            break;

        case EIptvEngineVodContentCheckGroup:

            {

            TInt err( KErrNotReady );

            if ( iEpgSession )

                {

                err = iEpgSession->UpdateEcg( EFalse );

                }

            aMessage.Complete( err );                

            }

            break;

        case EIptvEngineVodContentCancel:

            {

            delete iEpgSession;

            iEpgSession = NULL;

            iVodMsgQueue->CancelRequest();

            aMessage.Complete(KErrNone);

            }

            break;

        case EIptvEngineVodContentCancelUpdate:

            {

            if ( iEpgSession )

                {

                iEpgSession->VodPluginCancelled();

                }

            iVodMsgQueue->CancelMsgQueue();

            aMessage.Complete(KErrNone);

            }

            break;

        case EIptvEngineVodContentRssSearch:

        	{

        	TInt err( KErrNotReady );

        	if( iEpgSession )

        		{

	            TPckgBuf<TIptvRssSearchQuery> pckg;

	            TRAP( err, aMessage.ReadL( 0, pckg ) );

	            if( err == KErrNone )

	            	{

	        		err = iEpgSession->Search( pckg() );

	            	}

        		}

    		aMessage.Complete( err );

        	}

        	break;

        case EIptvEngineVodContentRssSearchCancel:

        	{

        	TInt err( KErrNotReady );

        	if( iEpgSession )

        		{

        		err = iEpgSession->CancelSearch();

        		}

        	aMessage.Complete( err );

        	}

        	break;

        case EIptvEngineLiveTvUpdateEPGReq:

			{

			TInt err( KErrNotReady );

			if ( iEpgSession )

        		{

        		err = iEpgSession->UpdateEcg( ETrue );

        		}

        	aMessage.Complete( err );

			}

        	break;

		case EIptvEngineLiveTvUpdateChannelReq:

            {

            TRAPD( err, HandleUpdateChannelOrderReqL( aMessage ) );

			aMessage.Complete( err );	

			break;

            }

        case EIptvEngineVodContentObserver:

            iVodMsgQueue->SetRequest(aMessage);

            break;

        case EIptvEngineVodContentServiceId: // fall through

        case EIptvEngineLiveTvContentServiceId:

            HandleServiceIdL(aMessage);            

            break;

        case EIptvEngineVodContentGetCAListSizeReq:

            HandleGetCAListSizeReqL(aMessage);

            break;

        case EIptvEngineVodContentGetCAListDataReq:

            HandleGetCAListDataReqL(aMessage);

            break;                

        case EIptvEngineVodContentSetLastPosition:

            SetLastPositionL(aMessage);

            break;

        case EIptvEngineVodContentSetMpxId:

            HandleSetMpxIdL(aMessage);

            break;  

        case EIptvEngineVodContentGetEcgCategoryListSizeReq:            

            HandleGetEcgCategoryListSizeReqL(aMessage);

            break;

        case EIptvEngineVodContentGetEcgCategoryListDataReq:

            HandleGetEcgCategoryListDataReqL(aMessage);

            break;

        case EIptvEngineVodContentGetCategoryDetailsSizeReq:

            HandleGetCategoryDetailsSizeReqL(aMessage);

            break;

        case EIptvEngineVodContentGetCategoryDetailsDataReq:

            HandleGetCategoryDetailsDataReqL(aMessage);

            break;

        case EIptvEngineVodContentGetParentCategoryReq:

            HandleGetParentCategoryReqL(aMessage);

            break;

        case EIptvEngineVodContentGetEcgListSizeReq:             

            HandleGetEcgListSizeReqL(aMessage);

            break;

        case EIptvEngineVodContentGetEcgListDataReq:

            HandleGetEcgListDataReqL(aMessage);

            break;

        case EIptvEngineVodContentGetEcgAllListSizeReq:

            HandleGetEcgAllListSizeReqL(aMessage);

            break;

        case EIptvEngineVodContentGetEcgAllListDataReq:

            HandleGetEcgAllListDataReqL(aMessage);

            break;

        case EIptvEngineVodContentGetContentDetailsSizeReq:            

            HandleGetContentDetailsSizeReqL(aMessage);

            break;

        case EIptvEngineVodContentGetContentDetailsDataReq:

            HandleGetContentDetailsDataReqL(aMessage);

            break;

        case EIptvEngineVodGetUpdateTime:

            HandleGetUpdateTimeL(aMessage);

            break;

        case EIptvEngineLiveTvSetIap: // fall through            

        case EIptvEngineVodContentSetIap:

            HandleSetIapL(aMessage);

            break;

        case EIptvEngineVodContentResetGlobalId:

            HandleResetGlobalIdL( aMessage );

            break;

        case EIptvEngineVodContentCheckUpdate:

            HandleContentCheckUpdateL( aMessage );

            break;

        default:

            break;

        }

    }

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

// CIptvEpgMsgHandler::HandleUpdateChannelOrderReqL

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

//

void CIptvEpgMsgHandler::HandleUpdateChannelOrderReqL( const RMessage2& aMessage ) 

	{

	IPTVLOGSTRING_LOW_LEVEL("CIptvEpgMsgHandler::HandleUpdateChannelOrderReqL");

	// aMessage contains service provider id, channel id 

	// and order number

	TUint32 serviceId( 0 );

	TInt64 channelId( 0 );

	TUint32 order( 0 );

	TBuf8<KIptvChannelOrderReqSize> data;        

    aMessage.ReadL( 0, data, 0 );   

    RDesReadStream stream;

	CleanupClosePushL( stream );

    stream.Open( data );       

    serviceId = stream.ReadUint32L();

	stream >> channelId;

	order = stream.ReadUint32L();

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

    if ( !iEpgDatabase ) 

		{

		// remove non-working code below?

		RFs fs;

		CleanupClosePushL( fs );

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

	    TBuf<KIptvMaxPath> path;

	    CIptvUtil::GetPathL( fs, EIptvPathEcg, path );

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

	    path.Append( KLiveTvEPGDatabaseName );

		iEpgDatabase = CIptvEpgDatabase::NewL( path );

		}

	iEpgDatabase->UpdateChannelOrderL( serviceId, channelId, order );	

	}

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

// CIptvEpgMsgHandler::SendMessageToClientL

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

//

void CIptvEpgMsgHandler::SendMessageToClientL(TInt aMsg, TInt aInfo)

    {

    IPTVLOGSTRING2_LOW_LEVEL("CIptvEpgMsgHandler::SendMessageToClientL %d", aMsg);

    // Service id = 0 because we dont have to bring this information

    // over IPC. Service ID is already on the client side.    

    iVodMsgQueue->SendMessageToClientL(aMsg, aInfo);

    }

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

// CIptvEpgMsgHandler::HandleGetEcgCategoryListSizeReqL()

// 

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

//   

void CIptvEpgMsgHandler::HandleGetEcgCategoryListSizeReqL(const RMessage2& aMessage)

    {    

    IPTVLOGSTRING_LOW_LEVEL("CIptvEpgMsgHandler::HandleGetEcgCategoryListSizeReqL");

    TBuf8<KIptvSizeRequestSize> data;        

    aMessage.ReadL(0, data, 0);       

    RDesReadStream stream;

    stream.Open(data);  

    CleanupClosePushL( stream );     

    TIptvCategoryId parentCategoryId = stream.ReadUint32L();     

    CleanupStack::PopAndDestroy( &stream );

    // Get Epg stuff from DB

    TInt error = KErrNotReady;

    if (iEpgSession)

        {    

        error = iEpgSession->GetVodClientImplL()->GetEcgCategoryListL(parentCategoryId, iCategoryBriefDetailsArray);

        if (error != KErrNone)

            {

            IPTVLOGSTRING2_LOW_LEVEL("CIptvEpgMsgHandler::HandleGetEcgCategoryListSizeReqL error %d", error);            

            }       

        }

    else

        {                        

        IPTVLOGSTRING_LOW_LEVEL("CIptvEpgMsgHandler::HandleGetEcgCategoryListSizeReqL Epg session is NULL");        

        }

    TInt count = iCategoryBriefDetailsArray.Count();

    IPTVLOGSTRING2_LOW_LEVEL("Item count = %d", count);

    // count in the beginning

    TUint32 dataSize = KIptvFour;

    for (TInt i = 0; i < count; i++)

        {                        

        dataSize += iCategoryBriefDetailsArray[i]->CountExternalizeSize();

        }

    IPTVLOGSTRING2_LOW_LEVEL("CIptvEpgMsgHandler::Category brief details array data size = %d", dataSize);

    iDataSize = dataSize;

    // Send data size to client

    data.FillZ();

    RDesWriteStream writeStream;

    writeStream.Open(data);

    CleanupClosePushL( writeStream );

    writeStream.WriteUint32L(dataSize);

    CleanupStack::PopAndDestroy( &writeStream );

	aMessage.WriteL(0, data, 0);

    aMessage.Complete(error);    

    }

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

// CIptvEpgMsgHandler::HandleGetEcgCategoryListDataReqL()

// 

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

//    

void CIptvEpgMsgHandler::HandleGetEcgCategoryListDataReqL(const RMessage2& aMessage)

    {   

    IPTVLOGSTRING_LOW_LEVEL("CIptvEpgMsgHandler::HandleGetEcgCategoryListDataReqL");

    HBufC8* data = HBufC8::NewL(iDataSize);

    CleanupStack::PushL(data);

    TPtr8 dataPtr(data->Des());

    RDesWriteStream stream;

    stream.Open(dataPtr);

    CleanupClosePushL( stream );

    TUint32 count = iCategoryBriefDetailsArray.Count();

    stream.WriteUint32L(count);

    for (TInt i = 0; i < count; i++)

        {

        iCategoryBriefDetailsArray[i]->ExternalizeL(stream);        

        }

    CleanupStack::PopAndDestroy( &stream );

    aMessage.WriteL(0, dataPtr, 0);

    CleanupStack::PopAndDestroy(data);

    iCategoryBriefDetailsArray.ResetAndDestroy();

    aMessage.Complete(KErrNone);    

    }

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

// CIptvEpgMsgHandler::HandleGetCategoryDetailsSizeReqL()

// 

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

//    

void CIptvEpgMsgHandler::HandleGetCategoryDetailsSizeReqL(const RMessage2& aMessage)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvEpgMsgHandler::HandleGetCategoryDetailsSizeReqL");

    TBuf8<KIptvSizeRequestSize> data;        

    aMessage.ReadL(0, data, 0);       

    RDesReadStream stream;

    stream.Open(data); 

    CleanupClosePushL( stream );      

    TIptvCategoryId categoryId = stream.ReadUint32L();     

    CleanupStack::PopAndDestroy( &stream );

    // Get Epg stuff from DB        

    delete iCategory;

    iCategory = NULL;        

    iCategory = CIptvVodContentCategoryBriefDetails::NewL();

    TInt error = KErrNotReady;

    if (iEpgSession)

        {

        error = iEpgSession->GetVodClientImplL()->GetCategoryDetailsL(categoryId, *iCategory);

        if (error != KErrNone)

            {                

            IPTVLOGSTRING2_LOW_LEVEL("CIptvEpgMsgHandler::HandleGetCategoryDetailsSizeReqL error %d", error);            

            }

        }

    else

        {

        IPTVLOGSTRING_LOW_LEVEL("CIptvEpgMsgHandler::HandleGetCategoryDetailsSizeReqL Epg session is NULL");        

        }       

    TUint32 dataSize = 0;

    if (iCategory)

        {

        dataSize = iCategory->CountExternalizeSize();

        IPTVLOGSTRING2_LOW_LEVEL("CIptvEpgMsgHandler::Category full details data size = %d", dataSize);

        iDataSize = dataSize;

        }

    // Send data size to client

    data.FillZ();

    RDesWriteStream writeStream;

    writeStream.Open(data);

    CleanupClosePushL( writeStream );

    writeStream.WriteUint32L(dataSize);

    CleanupStack::PopAndDestroy( &writeStream );

	aMessage.WriteL(0, data, 0);    

    aMessage.Complete(error);                       

    }

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

// CIptvEpgMsgHandler::HandleGetCategoryDetailsDataReqL()

// 

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

//    

void CIptvEpgMsgHandler::HandleGetCategoryDetailsDataReqL(const RMessage2& aMessage)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvEpgMsgHandler::HandleGetCategoryDetailsDataReqL");

    HBufC8* data = HBufC8::NewL(iDataSize);

    CleanupStack::PushL(data);

    TPtr8 dataPtr(data->Des());

    RDesWriteStream stream;

    stream.Open(dataPtr);

    CleanupClosePushL( stream );

    iCategory->ExternalizeL(stream);

    CleanupStack::PopAndDestroy( &stream );   

    aMessage.WriteL(0, dataPtr, 0);

    CleanupStack::PopAndDestroy(data);

    delete iCategory;

    iCategory = NULL;      

    aMessage.Complete(KErrNone);    

    }

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

// CIptvEpgMsgHandler::HandleGetParentCategoryReqL()

// 

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

//    

void CIptvEpgMsgHandler::HandleGetParentCategoryReqL(const RMessage2& aMessage)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvEpgMsgHandler::HandleGetParentCategoryReqL");

    TBuf8<KIptvSizeRequestSize> data;        

    aMessage.ReadL(0, data, 0);

    RDesReadStream stream;

    stream.Open(data);       

    CleanupClosePushL( stream );

    TIptvCategoryId categoryId = stream.ReadUint32L();     

    CleanupStack::PopAndDestroy( &stream );

    IPTVLOGSTRING2_LOW_LEVEL("HandleGetParentCategoryReqL category = %d", categoryId);        

    // Get Epg stuff from DB    

    TIptvCategoryId parent = 0;

    TInt error = KErrNotReady;

    if (iEpgSession)

        {

        error = iEpgSession->GetVodClientImplL()->GetParentCategoryL(categoryId, parent);

        if (error != KErrNone)

            {                

            IPTVLOGSTRING2_LOW_LEVEL("CIptvEpgMsgHandler::HandleGetParentCategoryReqL error %d", error);            

            }

        }

    // Send parent category to client

    data.FillZ();

    RDesWriteStream writeStream;

    writeStream.Open(data);

    CleanupClosePushL( writeStream );

    writeStream.WriteUint32L(parent);

    CleanupStack::PopAndDestroy( &writeStream );