/*
* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "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 "mcecsreceiverbase.h"
#include "mcecsreceivequeue.h"
#include "mcecsserveritc.h"
#include "mcesrvlogs.h"

// -----------------------------------------------------------------------------
// CMceCsReceiverBase::ConstructL
// -----------------------------------------------------------------------------
//
void CMceCsReceiverBase::ConstructL ()
	{
    iReceiveQueue = new (ELeave) CMceCsReceiveQueue;
	}

// -----------------------------------------------------------------------------
// CMceCsReceiverBase::CMceCsReceiverBase
// -----------------------------------------------------------------------------
//
CMceCsReceiverBase::CMceCsReceiverBase (CMceCsServerITC& aItc)
:iITC (aItc), iClientReadyToReceive (EFalse)
	{
	}

// -----------------------------------------------------------------------------
// CMceCsReceiverBase::~CMceCsReceiverBase
// -----------------------------------------------------------------------------
//
CMceCsReceiverBase::~CMceCsReceiverBase()
	{
    delete iReceiveQueue;
	}

// -----------------------------------------------------------------------------
// CMceCsReceiverBase::ClientReadyToReceiveL
// -----------------------------------------------------------------------------
//
void CMceCsReceiverBase::ClientReadyToReceiveL (const RMessage2& aMessage)
	{
    MCESRV_DEBUG("CMceCsReceiverBase::ClientReadyToReceiveL, Entry");
    
    __ASSERT_ALWAYS (!iClientReadyToReceive, User::Leave (KErrAlreadyExists));
    
    MCESRV_DEBUG("storing ids");
    
	iIds = iITC.ReadMCEIdsL (aMessage);

    if (iReceiveQueue->IsEmpty())
		{
        iClientReadyToReceive = ETrue;
        iReceiveRMessage = aMessage;
		}
    else
		{
    	MCESRV_DEBUG("queue not empty") 	
        const TMceCSReceiveItem& item = iReceiveQueue->First();
		TMceMessageBufSizes bufSizes = item.BufSizes();
        iITC.WriteL (aMessage,item.Ids());
        iITC.WriteL (aMessage,bufSizes);
        if (bufSizes.iContentBufSize < 0 && bufSizes.iContextBufSize < 0)
        	{
    		MCESRV_DEBUG("removing stored data");
			iReceiveQueue->RemoveFirst ();    
        	}
        iITC.Complete (aMessage, item.Error());
        iClientReadyToReceive = EFalse;
    	MCESRV_DEBUG("event written");
		}
    MCESRV_DEBUG("CMceCsReceiverBase::ClientReadyToReceiveL, Exit");
	}

// -----------------------------------------------------------------------------
// CMceCsReceiverBase::CancelClientReceiveL
// -----------------------------------------------------------------------------
//
void CMceCsReceiverBase::CancelClientReceiveL ()
	{
    __ASSERT_ALWAYS (iClientReadyToReceive, User::Leave (KErrNotFound));

    iClientReadyToReceive = EFalse;
    iITC.Complete (iReceiveRMessage, KErrCancel);
	}

// -----------------------------------------------------------------------------
// CMceCsReceiverBase::SendToClientL
// -----------------------------------------------------------------------------
//       
void CMceCsReceiverBase::SendToClientL( TMceIds& aId, TInt aError)
	{
    MCESRV_DEBUG("CMceCsReceiverBase::SendToClientL( ids ), Entry");
    MCESRV_DEBUG_DVALUE("error", aError );
	
    MCESRV_DEBUG_IDS("IDS", aId );
	
	TMceCSReceiveItem item(aId, NULL, NULL, aError);
	HandleNewReceiveItemL( item );

    MCESRV_DEBUG("CMceCsReceiverBase::SendToClientL( ids ), Exit");
	
	}

// -----------------------------------------------------------------------------
// CMceCsReceiverBase::SendToClientL
// -----------------------------------------------------------------------------
//       
void CMceCsReceiverBase::SendToClientL( TMceIds& aId, HBufC8* aContext )
	{
    MCESRV_DEBUG("CMceCsReceiverBase::SendToClientL( ids, context), Entry");
	
    __ASSERT_ALWAYS (aContext, User::Leave (KErrArgument));

	TMceCSReceiveItem item(aId, aContext, NULL, KErrNone);
	HandleNewReceiveItemL( item );

    MCESRV_DEBUG("CMceCsReceiverBase::SendToClientL( ids, context), Exit");
	
	}

// -----------------------------------------------------------------------------
// CMceCsReceiverBase::SendToClientL
// -----------------------------------------------------------------------------
//       
void CMceCsReceiverBase::SendToClientL( TMceIds& aId, HBufC8* aContext, HBufC8* aContent )
	{
    MCESRV_DEBUG("CMceCsReceiverBase::SendToClientL( ids, context, content ), Entry");
	
    __ASSERT_ALWAYS (aContext, User::Leave (KErrArgument));
    __ASSERT_ALWAYS (aContent, User::Leave (KErrArgument));

	TMceCSReceiveItem item(aId, aContext, aContent, KErrNone);
	HandleNewReceiveItemL( item );
	
    MCESRV_DEBUG("CMceCsReceiverBase::SendToClientL( ids, context, content ), Exit");
	
	}

// -----------------------------------------------------------------------------
// CMceCsReceiverBase::Ids
// -----------------------------------------------------------------------------
//       
TMceIds CMceCsReceiverBase::Ids() const
	{
	return iIds;
	}
	
// -----------------------------------------------------------------------------
// CMceCsReceiverBase::ITC
// -----------------------------------------------------------------------------
//       
CMceCsServerITC& CMceCsReceiverBase::ITC()
    {
    return iITC;
    }
	

// -----------------------------------------------------------------------------
// CMceCsReceiverBase::HandleNewReceiveItemL
// -----------------------------------------------------------------------------
//       
void CMceCsReceiverBase::HandleNewReceiveItemL (TMceCSReceiveItem& aItem)
    {
    MCESRV_DEBUG("CMceCsReceiverBase::HandleNewReceiveItemL, Entry");
    
    if ( iClientReadyToReceive )
        {
    	MCESRV_DEBUG("client ready, sending") 	
		TMceMessageBufSizes bufSizes = aItem.BufSizes();
        iITC.WriteL( iReceiveRMessage, aItem.Ids() );
        iITC.WriteL( iReceiveRMessage, bufSizes );
        if ( bufSizes.iContentBufSize >= 0 || bufSizes.iContextBufSize >= 0 )
        	{
    		MCESRV_DEBUG("stored for receive");
        	User::LeaveIfError( iReceiveQueue->AddLast( aItem ) );        	
        	}
        iITC.Complete ( iReceiveRMessage, aItem.Error() );
        iClientReadyToReceive = EFalse;
        }
    else
        {
    	MCESRV_DEBUG("client not ready, storing");
        User::LeaveIfError( iReceiveQueue->AddLast( aItem ) );
        }     
    MCESRV_DEBUG("CMceCsReceiverBase::HandleNewReceiveItemL, Exit");
    }

// -----------------------------------------------------------------------------
// CMceCsReceiverBase::ReceiveL
// -----------------------------------------------------------------------------
//
void CMceCsReceiverBase::ReceiveL (const RMessage2& aMessage)
	{
    MCESRV_DEBUG("CMceCsReceiverBase::ReceiveL, Entry");

    __ASSERT_ALWAYS(!iReceiveQueue->IsEmpty(), User::Leave(KErrNotReady));

    TMceCSReceiveItem& item = iReceiveQueue->First();
	TMceIds ids = iITC.ReadMCEIdsL( aMessage );
    (void)ids;
    if ( item.Content() )
        {
    	MCESRV_DEBUG_DVALUE("writing context. size", 
    	    item.Context() ? item.Context()->Length() : 0 );
    	    
    	iITC.WriteL( aMessage, *(item.Context()), EMceItcArgContext );
    	
    	MCESRV_DEBUG_DVALUE("writing content. size", 
    	    item.Context() ? item.Content()->Length() : 0 );
    	    
    	iITC.WriteL( aMessage, *(item.Content()), EMceItcArgMessageContent );
        }   
	else
		{
    	MCESRV_DEBUG_DVALUE("writing context. size", 
    	    item.Context() ? item.Context()->Length() : 0 );
    	iITC.WriteL( aMessage, *(item.Context()), EMceItcArgContext );
		}
						
    MCESRV_DEBUG("removing stored data");
	iReceiveQueue->RemoveFirst ();
	
    MCESRV_DEBUG("CMceCsReceiverBase::ReceiveL, Exit");
    
	}