/*

* 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 * TStateFileShare::processIncommingMessageL(CMSRPServerSubSession *aContext, 

                 CMSRPMessageHandler* incommingMsg)

    {

    MSRPLOG("TStateFileShare::processIncommingMessage Enter!");

    TStateBase *state = this;

    CMSRPMessageHandler *incommingMsgHandler;

    if(NULL != incommingMsg)

        {

        aContext->iInCommingMsgQ.Queue(*incommingMsg);

        }

    incommingMsgHandler = aContext->iInCommingMsgQ.DeQueue();         

    while (incommingMsgHandler && state == this)

        {

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

            {

            state = handlesResponseL(aContext,incommingMsgHandler);                    

            }

        else

            {

            state = handleRequestsL(aContext,incommingMsgHandler);

            }

        incommingMsgHandler = aContext->iInCommingMsgQ.DeQueue();

        }

    MSRPLOG("TStateFileShare::processIncommingMessage Exit!");

    return state;

    }

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

    // Shift this to Outgoing Queue.

    aContext->iCurrentMsgHandler = msgHandler;

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

    }

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

        {

        TBool error = 0;

        CleanupStack::PushL(incommingMsgHandler);

        TBool sendResult = outgoingMsgHandler->ConsumeResponseL(*incommingMsgHandler);

        if( sendResult )

            {

            error = aContext->sendResultToClientL(outgoingMsgHandler);

            }        

        if(outgoingMsgHandler->IsMessageComplete())

            {

            aContext->iOutMsgQ.explicitRemove(outgoingMsgHandler);    

            delete outgoingMsgHandler;

            }

        CleanupStack::Pop(incommingMsgHandler); 

        if( error )

            {

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

            }

        else

            {

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

            }            

        }

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

        TBool sendToClient = incommingMsgHandler->SendResponseL(aContext, 

                *aContext->iConnection, 0);        

        if(sendToClient)

            {

            aContext->sendMsgToClientL(incommingMsgHandler);

            }

        aContext->iPendingForDeletionQ.Queue(*incommingMsgHandler);

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

        }

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

        {

        MSRPLOG("Reports not supported!!");

        delete incommingMsgHandler;

        return this;

        }

    else // It is an unrecognized request eg. AUTH

        {

        MSRPLOG("Unrecognized request received");

        TBool sendToClient = incommingMsgHandler->SendResponseL(aContext, 

                *aContext->iConnection, CMSRPResponse::EUnknownRequestMethod);        

        aContext->iPendingForDeletionQ.Queue(*incommingMsgHandler);

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

        }

    } 

TStateBase* TStateBase::handleClientListnerCancelL(CMSRPServerSubSession * aContext, 

        TMSRPFSMEvent aEvent)

    {

    if(aEvent == EMSRPCancelReceivingEvent)

        {

        // Confirm completion of the Cancel Request.

        aContext->CompleteClient(KErrNone);

        // Complete the Listner if that is active.

        if(aContext->iIncommingMessageListner.Check())

            aContext->iIncommingMessageListner.Complete(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::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

        {   

        if( CMSRPServerSubSession::TInCommingMsgQueue == 

                           aContext->getQToProcess() )

            state  =  processIncommingMessageL( aContext );       

        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;

         case EMSRPListenEvent:        

             aContext->iConnDirection = EUpstream;

             state = handleListenRequestL( aContext );

             break;         

        case EMSRPListenMessagesEvent:

        case EMSRPListenSendResultEvent:

            // A MSRP Connection error code would be more appropriate here.

            aContext->CompleteClient(KErrCouldNotConnect); 

            state = this;

            break;

        case EMSRPCancelReceivingEvent:          

        case EMSRPCancelSendRespListeningEvent:

             state = handleClientListnerCancelL(aContext, aEvent);

                 break;

        case EConnectionStateChangedEvent:

             state = handleConnectionStateChangedL(aContext);

             break;

        default:

             // Any such error usually a client/server protocol voilation.

             // A bug to fix.

             MSRPLOG2("TStateIdle::EventL :: Err!! Invalid state to have received %d",aEvent);                     

             state =  HandleStateErrorL(aContext);

             break;

        }

    return state;     

    }

TStateBase* TStateIdle::handleLocalMSRPPathRequestL( CMSRPServerSubSession *aContext)

    {

    // The function is reponsible for contructing a  Local MSRP path and returning it to the 

    // client.

    // path:msrp://atlanta.example.com:7654/jshA7weztas;tcp

    // !! The current implementation should change to fully construct a MSRP path in the 

    // subsessoin and send back the result as path buffer. Right now this done in the client. !!

    MSRPLOG("TStateIdle::HandleLocalPathRequestL()");

    TInetAddr localAddr;

    aContext->ConnectionManager().ResolveLocalIPAddressL( localAddr );               

    localAddr.Output(aContext->iLocalHost);          

    aContext->iLocalPathMSRPDataPckg().iLocalHost.Copy( aContext->iLocalHost );

    aContext->iLocalPathMSRPDataPckg().iSessionID = *(aContext->iLocalSessionID);

    TInt reason = aContext->Write(0, aContext->iLocalPathMSRPDataPckg);     

    aContext->CompleteClient(KErrNone);

    return this; // No state change.

    }

TStateBase* TStateIdle::handleConnectRequestL(CMSRPServerSubSession *aContext)

    {

    if(!aContext->iConnectionListner.set(*(aContext->iClientMessage)))

        {

        MSRPLOG("TStateIdle::handleConnectRequestL() iConnectionListner is already setup");

        MSRPLOG("TStateIdle::handleConnectRequestL() Invalid state to setup for ConnectionListner");

        return HandleStateErrorL(aContext);

        }  

    aContext->iClientMessage = NULL; 

    aContext->iConnectionListner.ReadL( 0, aContext->iConnectMSRPdataPckg );     

    aContext->iRemoteHost = aContext->iConnectMSRPdataPckg().iRemoteHost;

    aContext->iRemotePort = aContext->iConnectMSRPdataPckg().iRemotePort;

    aContext->iRemoteSessionID = 

            HBufC8::NewL( aContext->iConnectMSRPdataPckg().iRemoteSessionID.Length());

    *(aContext->iRemoteSessionID) = 

             aContext->iConnectMSRPdataPckg().iRemoteSessionID;

    // Request for a Connection.

    MMSRPConnection &connection = 

             aContext->ConnectionManager().getConnectionL(

                                  aContext->iRemoteHost

                                 ,aContext->iRemotePort);

    aContext->iConnection = &connection;    

    TBool connReady = initializeConnectionL(aContext);

    if(!connReady)

        { 

        MSRPLOG("TStateIdle:: Transtion to State EConnecting" );

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

        }

    else

        {

        MSRPLOG("TStateIdle:: Transtion to State EConnecting" );

        aContext->informConnectionReadyToClient();

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

        }

    }

TStateBase* TStateIdle::handleListenRequestL(CMSRPServerSubSession *aContext)

    {  

    if(!aContext->iIncommingMessageListner.set(*(aContext->iClientMessage)))

        {

        MSRPLOG("TStateWaitForClient::EventL iIncomming listner is already setup");

        MSRPLOG("TStateWaitForClient::EventL Invalid state to setup a listner");

        return HandleStateErrorL(aContext);

        }    

    aContext->iClientMessage = NULL;    

    aContext->iIncommingMessageListner.ReadL( 0, aContext->iListenMSRPdataPckg );

    aContext->iRemoteHost = aContext->iListenMSRPdataPckg().iRemoteHost;

    aContext->iRemotePort = aContext->iListenMSRPdataPckg().iRemotePort; 

    aContext->iRemoteSessionID    = 

            HBufC8::NewL( aContext->iListenMSRPdataPckg().iRemoteSessionID.Length());

    *(aContext->iRemoteSessionID) = 

             aContext->iListenMSRPdataPckg().iRemoteSessionID;    

    // Request for a Connection.

    MMSRPConnection &connection   = 

             aContext->ConnectionManager().getConnectionL(

                                  aContext->iRemoteHost

                                 ,aContext->iRemotePort);

    aContext->iConnection = &connection;    

    TBool connReady = initializeConnectionL(aContext);

    if(!connReady)

        { 

        MSRPLOG("TStateIdle:: Transtion to State EConnecting" );

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

        }

    else

        {

        MSRPLOG("TStateIdle:: Transtion to State EConnecting" );

        aContext->informConnectionReadyToClient();

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

        }

    } 

TBool TStateIdle::initializeConnectionL(CMSRPServerSubSession *aContext)

    {

     // Connect or Listen on Connection.

     // Return status based on connection is ready for use or not.

    TBool retVal = FALSE;

    if(EDownstream == aContext->iConnDirection)

        {

        if(3 == aContext->iConnection->ConnectL(*aContext))

            retVal = TRUE;              

        }

    else

        {

        if(3 == aContext->iConnection->ListenL(*aContext))

            retVal = TRUE;

        }

    return retVal;    

    }