/*

* 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);                    

            }

        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);

    }

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::Pop(incommingMsgHandler); 

        }

    delete incommingMsgHandler;    

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

    return nextState;    

    }

TStateBase* TStateBase::handleRequestsL(CMSRPServerSubSession *aContext,

                 CMSRPMessageHandler *incommingMsgHandler)

    {

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

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

        {

        MSRPLOG("SEND request received");

            {

            aContext->sendMsgToClientL(incommingMsgHandler);

            }

        }

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

        {

        delete incommingMsgHandler;

        }

    else // It is an unrecognized request eg. AUTH

        {

        MSRPLOG("Unrecognized request received");

        aContext->iPendingForDeletionQ.Queue(*incommingMsgHandler);

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

        }

    } 

        TMSRPFSMEvent aEvent)

    {

    if(aEvent == EMSRPCancelReceivingEvent)

        {

        }    

    if(aEvent == EMSRPCancelSendRespListeningEvent)

        {

        // Confirm completion of the Cancel Request.

        // Complete the Listner if that is active.

        if(aContext->iResponseListner.Check())

        }

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

    }

TStateBase* TStateBase::handleConnectionStateChangedL(CMSRPServerSubSession *aContext)

    {

    TStateBase* state = NULL;    

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

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

    switch(iConnectionEvent)

        {

        case -1: // Error Scenario         

            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

        {   

        else

            state  =  processPendingMessageQL( aContext );

        }   

    return state;

    }

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;     

         case EMSRPConnectEvent:  

             aContext->iConnDirection = EDownstream; 

             state = handleConnectRequestL(aContext);

             break;