/*

* Copyright (c) 2009-2010 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:

* MSRP Implementation

*

*/

#include "TStates.h"

#include "TStateFactory.h"

#include "CMSRPServerSubSession.h"

#include "CMSRPMessageHandler.h"

#include "CMSRPResponse.h"

#include "MMSRPConnection.h"

TStateBase* TStateBase::HandleStateErrorL(CMSRPServerSubSession *aContext)

    {

    // Error handling for invalid events received in a given state.

    if(NULL != aContext->iClientMessage)

        {

        // Complete the client with a error.

        // Set this to iClientReceivedEventData to NULL.

        aContext->CompleteClient(KErrNone);                 

        }

    if(NULL != aContext->iReceivedMsg)

        {

        // !! Handle

        }

    return aContext->StateFactory().getStateL(EIdle);

    }  

TStateBase* TStateBase::processIncommingMessageL(CMSRPServerSubSession *aContext, 

                 CMSRPMessageHandler* incommingMsg)

    {

    MSRPLOG("TStateBase::processIncommingMessage Entered!");

    CMSRPMessageHandler *incommingMsgHandler;

    if(NULL == incommingMsg)

        {

        incommingMsgHandler = aContext->iInCommingMsgQ.DeQueue();

        }

    else

        {

        incommingMsgHandler = incommingMsg;

        }

    if(incommingMsgHandler)

        {        

        if(MMSRPIncomingMessage::EMSRPResponse == incommingMsgHandler->MessageType())

            {

            return handlesResponseL(aContext,incommingMsgHandler);                    

            }

        if( MMSRPIncomingMessage::EMSRPReport == incommingMsgHandler->MessageType( ) )

            {

            return handleRequestsL( aContext,incommingMsgHandler );

            }

        else

            {

            return handleRequestsL(aContext,incommingMsgHandler);

            }        

        }

    else

        return NULL; 

    } 

TStateBase* TStateBase::processPendingMessageQL(CMSRPServerSubSession *aContext)

    {

    MSRPLOG("TStateBase::processPendingMessagesL Entered!");

    CMSRPMessageHandler *msgHandler;

    msgHandler = aContext->iPendingSendMsgQ.DeQueue();

    msgHandler->SendMessageL(*aContext->iConnection);

    aContext->iOutMsgQ.Queue( *msgHandler );

    return aContext->StateFactory().getStateL( EActive );

    }

TStateBase* TStateBase::processCompletedMessageL( CMSRPServerSubSession *aContext )

    {

    MSRPLOG("TStateBase::processCompletedMessageL Entered!");

    CMSRPMessageHandler* msgHandler = aContext->iPendingDataSendCompleteQ.DeQueue();

    if ( msgHandler->IsTransmissionTerminated() )

        {

        MSRPLOG("TStateBase::processCompletedMessageL transmission terminated");

        if( aContext->iResponseListner.Check() )

            {

            MSRPLOG("TStateBase::processCompletedMessageL complete with KErrCancel");    

            aContext->iResponseListner.Complete( KErrCancel );

            }

        }

    else

        {

        aContext->sendResultToClientL( msgHandler );      

        }

    delete msgHandler;

    return aContext->StateFactory().getStateL( EWaitForClient );

    }

TStateBase* TStateBase::processCompletedIncomingMessageL( CMSRPServerSubSession *aContext )

    {

    MSRPLOG("TStateBase::processCompletedIncomingMessageL Entered!");

    CMSRPMessageHandler* msgHandler = aContext->iPendingDataIncCompleteQ.DeQueue();

    if ( msgHandler->IsTransmissionTerminated() )

        {

        MSRPLOG("TStateBase::processCompletedIncomingMessageL transmission terminated");

        if( aContext->iIncommingMessageListner.Check() )

            {

            MSRPLOG("TStateBase::processCompletedIncomingMessageL complete with KErrCancel");    

            aContext->iIncommingMessageListner.Complete( KErrCancel );

            }

        }

    else

        {

        aContext->sendMsgToClientL( msgHandler );      

        delete msgHandler;

        }

    return aContext->StateFactory().getStateL( EWaitForClient );

    }

TStateBase* TStateBase::processReceiveReportL( CMSRPServerSubSession *aContext )

    {

    MSRPLOG("TStateBase::processReceiveReportL Entered!");

    CMSRPMessageHandler* msgHandler = aContext->iPendingReceiveProgressQ.DeQueue();

    aContext->ReceiveProgressToClientL( msgHandler );

    return aContext->StateFactory().getStateL( EWaitForClient );

    }

TStateBase* TStateBase::processSendReportL( CMSRPServerSubSession *aContext )

    {

    MSRPLOG("TStateBase::processSendReportL Entered!");

    CMSRPMessageHandler* msgHandler = aContext->iPendingSendProgressQ.DeQueue();

    aContext->SendProgressToClientL( msgHandler );

    return aContext->StateFactory().getStateL( EWaitForClient );

    }

TStateBase* TStateBase::handlesResponseL(CMSRPServerSubSession *aContext,

                 CMSRPMessageHandler *incommingMsgHandler)

    {

    TStateBase *nextState; 

    MSRPLOG("TStateBase::handlesResponseL Entered!");

    // Search the outgoing Queue to find the owner of the owner of this response.

    CMSRPMessageHandler *outgoingMsgHandler = 

                    aContext->iOutMsgQ.getMatch(incommingMsgHandler);

    if(NULL == outgoingMsgHandler)

        {

        // No outgoingMsgHandler to match the received response. Stray response.

        MSRPLOG("TStateBase::handlesResponseL() Received Stray Response!!");

        MSRPLOG("TStateBase::handlesResponseL() No Outgoing message handler found");

        nextState = this;

        }

    else

        {

        CleanupStack::PushL( incommingMsgHandler );

        TUint responseCode = outgoingMsgHandler->ConsumeResponseL( *incommingMsgHandler );

        if( outgoingMsgHandler->IsMessageComplete() ||

            responseCode != EAllOk ||

            ( outgoingMsgHandler->IsFailureHeaderPartial() &&

              responseCode != EAllOk ) )

            {

            aContext->iConnection->CancelSendingL( outgoingMsgHandler );

            aContext->sendResultToClientL( outgoingMsgHandler );

            aContext->iOutMsgQ.explicitRemove( outgoingMsgHandler );    

            delete outgoingMsgHandler;

            }

        else

            {

            aContext->iConnection->ContinueSendingL( *outgoingMsgHandler );

            }

        CleanupStack::Pop(incommingMsgHandler); 

        nextState = aContext->StateFactory().getStateL(EWaitForClient);     

        }

    delete incommingMsgHandler;    

    MSRPLOG("TStateBase::handlesResponseL Exit!");

    return nextState;    

    }

TStateBase* TStateBase::handleRequestsL(CMSRPServerSubSession *aContext,

                 CMSRPMessageHandler *incommingMsgHandler)

    {

    MSRPLOG("-> TStateBase::handleRequestsL");

    MMSRPIncomingMessage::TMSRPMessageType msgType = incommingMsgHandler->MessageType();

    if(MMSRPIncomingMessage::EMSRPMessage == msgType) // SEND request

        {

        MSRPLOG("SEND request received");

        incommingMsgHandler->SendResponseL(aContext, *aContext->iConnection, EAllOk );        

        incommingMsgHandler->SendReportL(aContext, *aContext->iConnection, EAllOk );        

        if( incommingMsgHandler->IsMessageComplete() )

            {

            MSRPLOG("-> TStateBase::handleRequestsL complete");

            aContext->sendMsgToClientL(incommingMsgHandler);

            delete incommingMsgHandler;

            //aContext->iPendingForDeletionQ.Queue(*incommingMsgHandler);

            return aContext->StateFactory().getStateL(EWaitForClient);

            }

        return aContext->StateFactory().getStateL( EActive );

        }

    else if(MMSRPIncomingMessage::EMSRPReport == msgType) // Drop Reports

        {

        aContext->sendMsgToClientL( incommingMsgHandler );

        delete incommingMsgHandler;

        //aContext->iPendingForDeletionQ.Queue(*incommingMsgHandler);

        return aContext->StateFactory().getStateL( EWaitForClient );

        }

    else // It is an unrecognized request eg. AUTH

        {

        MSRPLOG("Unrecognized request received");

        incommingMsgHandler->SendResponseL(aContext, *aContext->iConnection, EUnknownRequestMethod );        

        aContext->iPendingForDeletionQ.Queue(*incommingMsgHandler);

        return aContext->StateFactory().getStateL(EWaitForClient);

        }

    } 

TStateBase* TStateBase::handleClientListnerCancelL( CMSRPServerSubSession* aContext, 

        TMSRPFSMEvent aEvent)

    {

    MSRPLOG("-> TStateBase::handleClientListnerCancelL");

    if(aEvent == EMSRPCancelReceivingEvent)

        {

        // let's find the correct listener first

        TBuf8< KMaxLengthOfTransactionIdString > messageId;

        aContext->iClientMessage->ReadL( 0, messageId );

        // going through all incoming instances

        CMSRPMessageHandler* owner = aContext->iCurrentlyReceivingMsgQ.FindElement( messageId );

        if ( owner )

            {

            MSRPLOG2("TStateBase::handleClientListnerCancelL terminating %d", owner );

            owner->TerminateReceiving( aContext, *aContext->iConnection );

            }

        else

            {

            if( aContext->iIncommingMessageListner.Check() )

                {

                aContext->iIncommingMessageListner.Complete( KErrNone );

                }

            }

        // Confirm completion of the Cancel Request.

        aContext->CompleteClient( KErrNone );

        }    

    if(aEvent == EMSRPCancelSendRespListeningEvent)

        {

        // Confirm completion of the Cancel Request.

        aContext->CompleteClient( KErrNone );

        // Complete the Listner if that is active.

        if(aContext->iResponseListner.Check())

            aContext->iResponseListner.Complete( KErrNone );        

        }

    return aContext->StateFactory().getStateL(EWaitForClient);    

    }

TStateBase* TStateBase::HandleClientCancelSendingL( CMSRPServerSubSession* aContext )

    {

    MSRPLOG("-> TStateBase::HandleClientCancelSendingL");

    // let's find the correct listener first

    TBuf8< KMaxLengthOfTransactionIdString > messageId;

    aContext->iClientMessage->ReadL( 0, messageId );

    // going through all incoming instances

    CMSRPMessageHandler* owner = aContext->iOutMsgQ.FindElement( messageId );

    if ( owner )

        {

        MSRPLOG2("TStateBase::HandleClientCancelSendingL terminating %d", owner );

        owner->TerminateSending( );

        }

    // Confirm completion of the Cancel Request.

    aContext->CompleteClient( KErrNone );

    return this;

    }

TStateBase* TStateBase::handleConnectionStateChangedL(CMSRPServerSubSession *aContext)

    {

    TStateBase* state = NULL;    

    TInt iConnectionEvent = aContext->iConnection->getConnectionState();

    MSRPLOG2("handleConnectionStateChanged::Connection Event %d \n",iConnectionEvent ); 

    switch(iConnectionEvent)

        {

            state = handleConnectionErrorsL(aContext);

            break;

        case 1:

        case 2:

            MSRPLOG("handleConnectionStateChanged::Connection in Progress \n");

            state = this;

            break;

        case 3: 

            // Connected.

            MSRPLOG("handleConnectionStateChanged: Connected now." );    

            aContext->informConnectionReadyToClient();

            state = aContext->StateFactory().getStateL(EWaitForClient);            

            break;

        case 4:

        case 5:

            MSRPLOG("handleConnectionStateChanged: TimeOut now." ); 

            if(EDownstream == aContext->iConnDirection)

                aContext->iConnectionListner.Complete(-33); // TODO : Change to query the exact erorr code from the connection.

            else

                aContext->iIncommingMessageListner.Complete(-33); // TODO : Change to query the exact erorr code from the connection.    

            state = aContext->StateFactory().getStateL(EWaitForClient);            

            break;

        case 0:      

            // Not Connected.

            MSRPLOG("handleConnectionStateChanged: TimeOut now." );

            state = this;  

            break;

        }

    return state;    

    }

TStateBase* TStateBase::handleConnectionErrorsL(CMSRPServerSubSession *aContext)

    {

    TStateBase* state;

    if(TRUE == aContext->iConnectionListner.Check())

        {

        // Have a connection listner to inform connection errors.

        // This scenario happens where there is a connection error during "Connect"

        aContext->iConnectionListner.Complete(KErrCouldNotConnect);  // TODO : Change to query the exact erorr code from the connection.

        aContext->iConnection->ReleaseConnection(*aContext);

        aContext->iConnection = NULL;

        state = aContext->StateFactory().getStateL(EWaitForClient);        

        }

     else

        {

        // If do not have a connection listner.

        // This is a case where a established connection(connect/listen) 

        // is now reporting a Error.

        // ConnectionErrors in the current scheme of things will be reported via

        // iIncommingMessageListner.

        if(!aContext->iIncommingMessageListner.Check())

            {

            // Case where the subsession is waiting for the Client subsessions 

            // to provide it with listner to reports issues on.

            // Just move to the EIdle state. EIdle is the not connected state.

            // The connection error here will be reported from the TIdle state.

            state = aContext->StateFactory().getStateL(EIdle);

            }

        else

            {

            aContext->iIncommingMessageListner.Complete(KErrDisconnected);

            aContext->iConnection->ReleaseConnection(*aContext);

            aContext->iConnection = NULL;

            state = aContext->StateFactory().getStateL(EIdle);

            }

        }

    return state;

    }

TStateBase* TStateBase::handleQueuesL(CMSRPServerSubSession *aContext)

    {

    TStateBase * state;

    if( aContext->QueuesEmpty() )

        {

        state = aContext->StateFactory().getStateL( EActive );

        }

    else

        {   

        CMSRPServerSubSession::TQueueType type = aContext->getQToProcess();

        if ( type == CMSRPServerSubSession::TReceiveProgressQueue )

            {

            state  =  processReceiveReportL( aContext );       

            }

        else if ( type == CMSRPServerSubSession::TSendProgressQueue )

            {

            state  =  processSendReportL( aContext );       

            }

        else if ( type == CMSRPServerSubSession::TCompletedSendQueue )

            {

            state  =  processCompletedMessageL( aContext );       

            }

        else if ( type == CMSRPServerSubSession::TCompletedIncQueue )

            {

            state  =  processCompletedIncomingMessageL( aContext );       

            }

        else if( type == CMSRPServerSubSession::TInCommingMsgQueue )

            {

            state  =  processIncommingMessageL( aContext );

            }

        else

            {

            state  =  processPendingMessageQL( aContext );

            }

        }   

    return state;

    }

TStateBase* TStateBase::handleInCommingMessagesL(CMSRPServerSubSession *aContext)

     {

     CMSRPMessageHandler* incommingMsg = aContext->iReceivedMsg;

     aContext->iReceivedMsg = NULL;

     return processIncommingMessageL(aContext, incommingMsg);             

     }

TStateBase* TStateBase::MessageSendCompleteL(CMSRPServerSubSession *aContext)

    {

    // Handle send message complete event.

    if( NULL == aContext->iCurrentMsgHandler)

        {

        MSRPLOG( "TStateBase::MessageSendCompleteL :: iCurrentMsgHandler is NULL \n" );                                     

        return this;

        }

    if ( aContext->iCurrentMsgHandler->IsTransmissionTerminated() )

        {

        MSRPLOG("TStateBase::processCompletedMessageL transmission terminated");

        if( aContext->iResponseListner.Check() )

            {

            MSRPLOG("TStateBase::processCompletedMessageL complete with KErrCancel");    

            aContext->iResponseListner.Complete( KErrCancel );

            }

        return aContext->StateFactory().getStateL( EWaitForClient );

        }

    if( aContext->iCurrentMsgHandler->IsMessageComplete() )

        {

        // Messages with Failure Report set to "No" will never get a response.        

        aContext->sendResultToClientL( aContext->iCurrentMsgHandler );      

        CMSRPMessageHandler* temp = aContext->iOutMsgQ.getMatch( aContext->iCurrentMsgHandler );

        if ( temp )

            {

            aContext->iOutMsgQ.explicitRemove( aContext->iCurrentMsgHandler );

            }

        delete aContext->iCurrentMsgHandler;

        aContext->iCurrentMsgHandler = NULL;

        return aContext->StateFactory().getStateL( EWaitForClient );

        }

    else

        {

        aContext->iCurrentMsgHandler = NULL;

        // Handle any pending events in Queue.

        return handleQueuesL(aContext);     

        }

    }

TStates TStateIdle::identity()

    {

    return EIdle;

    }

TStateBase* TStateIdle::EventL(TMSRPFSMEvent aEvent, CMSRPServerSubSession *aContext)

    {

    // TStateIdle is a state where the subsession is waiting to get connected.     

    // It is the first state which is entered post sub-session creation.

    // Also it is the state that is entered in case there is of a connection error.

    // It may be possible that the client could not be informed about the 

    // connection error. Thus any client listner setup events will inform the client about 

    // the current disconnected state.

    // Any existing queues of received messages, received client send requests would be 

    // retained as it is. Any events for send messages received from the client 

    // would be queued up.

    // An event from the connection layer is considered invalid as the connection is 

    // assumed to be dead. Such events will result in a error report being published.

     MSRPLOG2("Entered TStateIdle Event %d",aEvent);

     TStateBase* state;

     switch(aEvent)

         {

         case ELocalMSRPPathEvent:

             state =  handleLocalMSRPPathRequestL(aContext);

             break;