/*
* 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:    MT refer is received and waiting for action from client.
*
*/




// INCLUDE FILES
#include <sipsubscriptionstateheader.h>
#include <sipnotifydialogassoc.h>
#include <sipresponseelements.h>
#include "mceeventrefermtestablishingstate.h"
#include "mcesipeventhelper.h"
#include "mcesip.h"
#include "mceeventslogs.h"

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CMceEventReferMtEstablishingState::CMceEventReferMtEstablishingState
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CMceEventReferMtEstablishingState::CMceEventReferMtEstablishingState()
    {
    }

// -----------------------------------------------------------------------------
// CMceEventReferMtEstablishingState::~CMceEventReferMtEstablishingState
// Destructor
// -----------------------------------------------------------------------------
//
CMceEventReferMtEstablishingState::~CMceEventReferMtEstablishingState()
    {
    }

// -----------------------------------------------------------------------------
// CMceEventReferMtEstablishingState::ProcessReferStateL
// Ápply concrete state.
// Be noticed that it will be also update, unRefer
// -----------------------------------------------------------------------------
//
void CMceEventReferMtEstablishingState::HandleL( 
												CMceComEvent& aEvent )
    {
    MCEEVENTS_DEBUG("CMceEventReferMtEstablishingState::HandleL, Entry");
    //Check after the receiving Refer, client want to accept/Reject the event
    User::LeaveIfError( aEvent.SIPEvent().Dialog() ?
        KErrNone : KMceEventStateError );
        
    User::LeaveIfError( aEvent.SIPEvent().Dialog()->Type() 
        == SIPStrings::StringF( SipStrConsts::ENotify ) ?
       KErrNone : KMceEventStateError );
        
    CSIPServerTransaction& serverTran = aEvent.SIPEvent().Request();    
    CSIPServerTransaction* serverTranCheck = &serverTran;    
    User::LeaveIfError( serverTranCheck ? KErrNone : KMceEventStateError );
    
    const CSIPRequestElements* request = serverTran.RequestElements();
    User::LeaveIfError( request ? KErrNone : KErrCorrupt );
     
    CSIPResponseElements* response =NULL;	

    switch ( aEvent.PreviousAction() )
        {
        case EMceItcAcceptEvent:
            {
            //return 202
            RStringF phrase = 
        	    SIPStrings::Pool().OpenFStringL( KMceSipPhraseAccepted );
        	CleanupClosePushL( phrase );
            response = MCESIPEventHelper::CreateResponseL( 
                                                    aEvent,
                                                    KMceSipAccepted,
                                                    phrase );
    	    CleanupStack::PopAndDestroy(); // phrase	
    	    break;
            }
        case EMceItcRejectEvent:
            {
            //RejectEvent
            response = MCESIPEventHelper::CreateResponseL( aEvent,
                                                           KMceSipDecline );
            aEvent.EventContext().SetCurrentStateL( 
                                            aEvent, 
                                            KMceTerminatedEventStateIndex );
        	break;
            }
        case EMceItcRespondEvent:
            {
            //Respond event 
        	RStringF phrase = 
        	    SIPStrings::Pool().OpenFStringL( aEvent.ReasonPhrase() );
        	CleanupClosePushL( phrase );
        	response = MCESIPEventHelper::CreateResponseL( 
                                                    aEvent,
                                                    aEvent.StatusCode(),
                                                    phrase,
                                                    ETrue /* aAddClientData */);
            CleanupStack::PopAndDestroy(); // phrase                                                    
        	break;
            }
        default:
            {
            User::Leave( KMceEventStateError );
            break;
            }
        }
    
    CleanupStack::PushL( response );
    
    serverTran.SendResponseL( response );
   	CleanupStack::Pop( response );
	
	//then send Notify
	TUint statusCode = response->StatusCode();
   	
	if ( statusCode == KMceSipAccepted || statusCode == aEvent.StatusCode() )
		{
		if(response->StatusCode() >= KMceSipOK)
			{
	        if ( statusCode < KMceSipMultipleChoices 
	          && aEvent.ReferType() == CMceRefer::ENoSuppression )
				{
				CSIPSubscriptionStateHeader& subStateHeader = 
				( static_cast< CSIPNotifyDialogAssoc* >
				( aEvent.SIPEvent().Dialog() ) )->SubscriptionState();
				
	        	subStateHeader.SetSubStateValueL( KStateActive );
	        	subStateHeader.SetExpiresParameterL( aEvent.RefreshInterval() );
	        	CSIPMessageElements* msgElem = 
	        	    MCESIPEventHelper::CreateReferNotifyMessageElementsLC( aEvent );
	        	                    
				CSIPClientTransaction* transaction = 
					( static_cast< CSIPNotifyDialogAssoc* >
					( aEvent.SIPEvent().Dialog() ) )->SendNotifyL( msgElem );
					
				CleanupStack::Pop( msgElem );
				CleanupStack::PushL( transaction );
				aEvent.SIPEvent().SetPendingTransactionL( transaction );
				CleanupStack::Pop( transaction );
				aEvent.EventContext().SetCurrentStateL( 
		                                    aEvent, 
		                                    KMceEstablishedEventStateIndex );
				}
			else
				{
				// Terminated, if received error response or the 
				// REFER is supppressed.
				aEvent.EventContext().SetCurrentStateL( 
		                                    aEvent, 
		                                    KMceTerminatedEventStateIndex );
				}
			}
		}
	MCEEVENTS_DEBUG("CMceEventReferMtEstablishingState::HandleL, Exit");		
    }

// -----------------------------------------------------------------------------
// CMceEventReferMtEstablishingState::HandleReceiveRequestL
// Ápply concrete state.
// Be noticed that it will be also update, unRefer
// -----------------------------------------------------------------------------
//
void CMceEventReferMtEstablishingState::HandleReceiveRequestL( 
												CMceComEvent& /*aEvent*/ )
	{
	}
	
// -----------------------------------------------------------------------------
// CMceEventReferMtEstablishingState::HandleResponseReceivedL
// Ápply concrete state.
// Be noticed that it will be also update, unRefer
// -----------------------------------------------------------------------------
//	
void CMceEventReferMtEstablishingState::HandleResponseReceivedL(
													CMceComEvent& aEvent )
	{
	MCEEVENTS_DEBUG("CMceEventReferMtEstablishingState::HandleResponseReceivedL, Entry");
    User::LeaveIfError( aEvent.PreviousAction() == EMceItcNotify ?
        KErrNone : KMceEventStateError );
    
    User::LeaveIfError( &aEvent.SIPEvent().Response() ?
        KErrNone : KMceEventStateError );
        
    User::LeaveIfError( aEvent.SIPEvent().Response().Type()==
	    SIPStrings::StringF(SipStrConsts::ENotify) ?
	    KErrNone : KMceEventStateError );
	
    aEvent.SetPreviousAction( KErrNotFound ); 
    
    const CSIPResponseElements* response = 
        aEvent.SIPEvent().Response().ResponseElements();
    User::LeaveIfError( response ? KErrNone : KErrCorrupt );

    TUint statusCode = response->StatusCode();
    if ( statusCode >= KMceSipOK )
		{
		CMceRefer::TState nextClientState = CMceRefer::EPending;
		TMceEventStateIndex nextState = KErrNotFound;
        if ( statusCode < KMceSipMultipleChoices )
            {
            nextClientState = CMceRefer::EAccepted;
            nextState = KMceEstablishedEventStateIndex;
            }
        else 
            {
            nextClientState = CMceRefer::ETerminated;
            nextState = KMceTerminatedEventStateIndex;
            }
        aEvent.SIPEvent().ClientStateChangedL( nextClientState, ETrue );
        aEvent.EventContext().SetCurrentStateL( aEvent, nextState );
        }
	MCEEVENTS_DEBUG("CMceEventReferMtEstablishingState::HandleResponseReceivedL, Exit");        
    }

//  End of File