/*

* 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 <sipdialogassocbase.h>

#include <sipdialog.h>

#include <sipclienttransaction.h>

#include <sipresponseelements.h>

#include <sipcseqheader.h>

#include "mcestateoffering.h"

#include "mcesipsession.h"

#include "mcesipextensions.h"

#include "mceactionset.h"

#include "mcefcactionset.h"

#include "mceclientserver.h"

#include "mcesip.h"

#include "mcesipsession.h"

#include "mcenatmacros.h"

#include "mcesdpsession.h"

#include "mcesrvlogs.h"

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

// CMceStateOffering::CMceStateOffering

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

//

CMceStateOffering::CMceStateOffering ()

    : CMceState( KMceStateOffering )

	{

	}

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

// CMceStateOffering::~CMceStateOffering

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

//

CMceStateOffering::~CMceStateOffering()

	{

	}

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

// CMceStateOffering::DoAcceptL

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

//

TBool CMceStateOffering::DoAcceptL( TMceStateTransitionEvent& aEvent )

	{

    User::LeaveIfError( 	                 

       aEvent.Code() == EMceUpdate ||

       aEvent.Code() == EMceResponse  ||

       aEvent.Code() == EMceProvisionalResponse ||

       aEvent.Code() == EMceRedirectionResponse ||

       aEvent.Code() == EMceErrorResponse ||

       aEvent.Code() == EMceMediaUpdated ||

       aEvent.Code() == EMceItcCancel ||    

       aEvent.Code() == EMceBye ||  

       aEvent.Code() == EMceItcEnable ||

       aEvent.Code() == EMceItcDisable || 

       IsExtensionRequestEvent( aEvent )

       ? KErrNone : KErrTotalLossOfPrecision );

	return ETrue;

	}

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

// CMceStateOffering::EntryL

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

//

void CMceStateOffering::EntryL( TMceStateTransitionEvent& aEvent )

	{

	if ( IsExtensionRequestEvent( aEvent ))

		{

		HandleExtensionRequestEventL( aEvent );	

		}

    else

    	{

	    switch( aEvent.Code() )

	        {

            case EMceUpdate:

                {

                EntryUpdateL( aEvent );

                break;

                }

	        case EMceProvisionalResponse:

	            {

	            EntryProvisionalResponseL( aEvent );

	            break;

	            }

	        //200 OK

	        case EMceResponse:

	            {

	            EntryResponseL( aEvent );

	            break;                

	            }

	        //error

	        case EMceRedirectionResponse:

	            {

	            EntryRedirectionResponseL( aEvent );

	            break;   

	            }

	        case EMceErrorResponse:

	            {

	            EntryErrorResponseL( aEvent );

	            break;                

	            }

	        //if client cancels, send CANCEL            

	        case EMceItcCancel:

	            {

	            EntryCancelL( aEvent );

	            break;

	            }

	        case EMceMediaUpdated:

	            {

                CMceSipSession& session = aEvent.Session();

                CSIPServerTransaction* update = &session.Request();

                if ( update && update->Type() == 

                    SIPStrings::StringF( SipStrConsts::EUpdate ) )

                    {

                    EntryMediaUpdatedL( aEvent );

                    }

                else

                    {

                    if ( aEvent.Session().SubState() == CMceSipSession::EUpdating )

                        {

                        EntryAnswerToUpdateDecodedL( aEvent );

                        }

                    else

                        {

                        EntryAnswerToOfferDecodedL( aEvent );

                        }

                    }

	            break;

	            }

	        case EMceItcEnable:

	        case EMceItcDisable:

	            {

	            aEvent.Session().Actions().ControlMediaL( aEvent.ParamIDs(), 

	                                             (TMceItcFunctions)aEvent.Code() );

	            break;

	            } 

	        case EMceBye:

	            {

	            EntryByeL( aEvent );

	            break;

	            }

	        default:

	            {

	            //NOP

	            break;

	            }       

	        }

    	}

	}

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

// CMceStateOffering::EntryUpdateL

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

//

void CMceStateOffering::EntryUpdateL( TMceStateTransitionEvent& aEvent )

    {

    CMceSipSession& session = aEvent.Session();

    if ( MceSip::HasContent( session.Request() ) )

        {

        // UPDATE carries SDP

        User::LeaveIfError( session.Actions().CreateSDP( session.Request() ) );

        session.Actions().DecodeL();

        TMceReturnStatus status = session.Actions().UpdateL();

        aEvent.ParamStatus() = status;

        if ( MCE_IS_ERROR( status ) )

            {

            // TBD: update failed, reject

            }

        else if ( status == KMceAsync )

            {

            // NOP

            }

        else // ready

            {

            aEvent.Code() = EMceMediaUpdated;

            EntryMediaUpdatedL( aEvent );

            }

        }

    else 

        {

        // TBD: handle UPDATE without content

        }

    }

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

// CMceStateOffering::EntryProvisionalResponseL

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

//

void CMceStateOffering::EntryMediaUpdatedL( TMceStateTransitionEvent& aEvent )

    {

    CMceSipSession& session = aEvent.Session();

    TMceReturnStatus status = session.Actions().ReserveL();

    aEvent.ParamStatus() = status;

    if ( MCE_IS_ERROR( status ))

        {

        // TBD: reservation failed

        }

    else

        if (status == KMceAsync)

            {

            // NOP

            }

        else // ready, send 2xx to update

            {

            CSIPServerTransaction* update= NULL;

            RStringF trx = session.Request().Type();

            if (trx == SIPStrings::StringF(SipStrConsts::EUpdate) )

                {

                update = &session.Request();

                }

            if (update)

                {

                session.Actions().EncodeL();

                session.FCActions().UpdateFCAnswerL( *session.Offer() );

                session.Actions().SendAnswerL( *update);

                }

            else

                {

                User::Leave(KErrTotalLossOfPrecision);

                }

            }

	}

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

// CMceStateOffering::EntryProvisionalResponseL

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

//

void CMceStateOffering::EntryProvisionalResponseL( 

    TMceStateTransitionEvent& aEvent )

    {

    TInt status = KErrNone;

    CMceSipSession& session = aEvent.Session();

    CSIPClientTransaction& response = session.Response();

    session.Extensions().UpdateL( response );

    session.Actions().CheckContactIsSecureL( response );

    session.ActiveBody().AnswerType() = KMceNegotiationAnswerTypeIntermediate;

    TBool IsFork = EFalse;

    if ( MceSip::ResponseCode( session.Response() ) == KMceSipSessionProgress && 

    	   session.ForkedDialogsCount() ) 

        {

        IsFork = ETrue;

  	    }

    if ( session.Actions().NeedToProcessL( aEvent ) || IsFork )

        {

        if ( MCE_NEED_TO_SEND( session, NULL ) || IsFork )

            {

            if ( MceSip::HasContent( response ) )

                {

                // create SDP answer

                //status = session.Actions().CreateSDP( response );

                NAT_WAIT_NO_EXEC( session, (status = session.Actions().CreateSDP( response )));

                // handle SDP content

                if ( !MCE_IS_ERROR( status ) )

                    {

                    // process session timer

                    session.Actions().ProcessSessionTimerClientL( response );

                    // update FC

                    session.FCActions().PeekFCDocumentL( *session.Offer() );

                    //decode answer, ignore warning code 

                    if ( session.ActiveBody().SecureSession())

                    	{

                    	session.ActiveBody().SecureSession()->iLSReadyToBind = EFalse;

                    	}

                    session.Actions().DecodeL();

                    // update media

                    status = session.Actions().UpdateL();

                    }

                }

            //if there was an error

            if ( MCE_IS_ERROR( status ) )

                {

                EntryCancelL( aEvent );

                //transition exit is performed here

                session.Actions().StateChanged( KMceStateCanceled );

                session.Actions().ClientStateChangedL( CMceSession::ECancelling, 

                                                       aEvent.ParamStatus() );

                }

            else if ( status == KMceAsync )

                {

                aEvent.Session().SetWaitingMediaCallback( ETrue );

                }

            else // KMceReady 

                {

                EntryAnswerToOfferDecodedL( aEvent );

                }

            }

        else

            {

            EntryAnswerToOfferDecodedL( aEvent );

            }

        }

    aEvent.ParamStatus() = status;

    }

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

// CMceStateOffering::EntryRedirectionResponseL

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

//

void CMceStateOffering::EntryRedirectionResponseL( 

    TMceStateTransitionEvent& aEvent )

    {

    MCESRV_DEBUG("CMceStateOffering::EntryRedirectionResponseL, Entry");

	CMceSipSession& session = aEvent.Session();

    session.ResetSdpCounts();

    switch ( MceSip::ResponseCode( session.Response() ) )

        {   

        case KMceSipMovedTemporarily:  

            {

            // any 3xx response for updating will be handled as

            // a error situation

            if ( session.SubState() != CMceSipSession::EUpdating )

                {

                // get remoteUri information from response 

                session.AddRemoteUriFromResponseL( 

                    *const_cast<CSIPResponseElements*>(session.Response().ResponseElements()) );

                // create a new inviteAssociationDialog

                session.CreateDialogFrom3XXResponseL();

                // send the invite again

                session.Actions().SendInviteL();    

                }            

            break;

            }

        // include KMceSipUseProxy, KMceSipAlternativeService,

        // KMceSipMultipleChoices, KMceSipMovedPermanently

        default: 

            {

            // error situation

            break;

            }

        }

    MCESRV_DEBUG("CMceStateOffering::EntryRedirectionResponseL, Exit");

    }

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

// CMceStateOffering::ExitRedirectionEventL

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

//

void CMceStateOffering::ExitRedirectionEventL( 

    TMceStateTransitionEvent& aEvent )

    {

    MCESRV_DEBUG("CMceStateOffering::RedirectionErrorResponseL, Entry");

    CMceSipSession& session = aEvent.Session();

    CMceSipSession::TSubState subState = session.SubState();

    TUint responseCode = MceSip::ResponseCode( session.Response() );

    if ( subState == CMceSipSession::EOffering )

        {

        if ( responseCode == KMceSipMovedTemporarily )  

            {

            session.Actions().ClientStateChangedL( 

                CMceSession::EOffering, *session.Body(), session.Response() );           

            }

        else

            {

            session.Actions().StopMedia();

            session.FCActions().ReleaseFC();

            session.Actions().StateChanged( KMceStateTerminated );

            session.Actions().ClientStateChangedL( 

                CMceSession::ETerminated, *session.Body(), session.Response() );       

            }

        }

    else if ( session.SubState() == CMceSipSession::EUpdating ) 

        {

        session.Actions().StopUpdatingMedia();

        session.Actions().UpdateFailed();

        session.Actions().StateChanged( CMceSession::EEstablished );

        session.Actions().ClientStateChangedL( 

            CMceSession::EEstablished, *session.Body(),

            session.Response(), KErrGeneral );                                    

        }

    else

        {

        // do nothing  

        }

    MCESRV_DEBUG("CMceStateOffering::RedirectionErrorResponseL, Exit");

    }

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

// CMceStateOffering::EntryResponseL

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

//

void CMceStateOffering::EntryResponseL( TMceStateTransitionEvent& aEvent )

    {

    TInt status = KErrNone;

	CMceSipSession& session = aEvent.Session();

    CMceSipSession::TSubState subState = session.SubState();

    //send ACK

    session.Actions().SendACKL( session.Response() );

	session.Actions().CheckContactIsSecureL( session.Response() );

    session.ActiveBody().AnswerType() = KMceNegotiationAnswerTypeFinal;

	// Handle the answer only if the media processing is not

	// already ongoing

	if ( !session.WaitingMediaCallback() )

	    {

	    if ( MceSip::HasContent( session.Response() ) )

	        {

	        //process session timer

            session.Actions().ProcessSessionTimerClientL( session.Response() );

            if ( subState != CMceSipSession::ERefreshing )

                {

                //create SDP answer

        	    NAT_WAIT_NO_EXEC( session, (status = session.Actions().CreateSDP( session.Response() ) ));

            	if ( !MCE_IS_ERROR( status ) )

            	    {

                    //update FC

                    session.FCActions().PeekFCDocumentL( *session.Offer() );

            	    //decode answer, ignore warning code 

                    if ( session.ActiveBody().SecureSession())

                    	{

                    	session.ActiveBody().SecureSession()->iLSReadyToBind = ETrue;

                    	}

                    status = session.Actions().Decode();

                    // update media and start waiting EMceMediaUpdated (if needed) 

				    if ( !MCE_IS_ERROR( status ) )

						{

		                status = session.Actions().UpdateL();

		                //if everything OK, starts floor control

		        		if ( !MCE_IS_ERROR( status ) )

		    		        {

		                    //check should wait EMceMediaUpdated

		                    aEvent.Code() = status == KMceReady ? 

		                                    EMceMediaUpdated : EMceResponse;

		                    if ( subState == CMceSipSession::EOffering )

		                        {

		                        // start floor control only for the initial INVITE

		                        session.FCActions().StartFCL();

		                        }

		    		        }

						}

            	    }

                }

            }

	    else // no content

    	    {

    	    if  ( !MCE_NEED_TO_RECEIVE( session ) )

    	        {

                status = session.Actions().UpdateL();

    	        // SDP answer was received before

    	        // go to established state

    	        session.Actions().StateChanged( KMceStateEstablished );

                //session.Actions().ClientStateChangedL( CMceSession::EEstablished,

                //                               session.Response() );

    	        session.Actions().ClientStateChangedL( CMceSession::EEstablished, 

                                                   *session.Body(),

                                                   session.Response(),

                                                   status );

    	        }

    	    else

    	        {

    	        // SDP answer is not received

    	        User::Leave( KErrNotReady );

    	        }

    	    }

	    aEvent.ParamStatus() = status;

        //if there was an error

        if ( MCE_IS_ERROR( status ) )

            {

        	//if first invite

            if ( subState == CMceSipSession::EOffering )

                {

                //send BYE and stop media

                session.Actions().SendBYEL();

                session.Actions().StopMedia();

                }

            //if updating

            else if ( subState == CMceSipSession::EUpdating )

                {

                //do rollback

                session.Actions().UpdateFailed();

                if ( session.Body() && &session.Body()->SdpSession() &&

                     session.Body()->SdpSession().iOOldSchoolCompleted )

                    {

                    session.Actions().ClientStateChangedL( 

                        CMceSession::EEstablished, *( session.Body() ), status );                         

                    }       

                }