/*
* 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:    State for established MT refer.
*
*/




// INCLUDE FILES
#include <sipnotifydialogassoc.h>
#include <sipsubscriptionstateheader.h>
#include <sipdialog.h>
#include "mceeventrefermtestablishedstate.h"
#include "mcesipeventhelper.h"
#include "mcesip.h"
#include "mceeventslogs.h"

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

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

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

// -----------------------------------------------------------------------------
// CMceEventReferMtEstablishedState::ProcessReferStateL
// Ápply concrete state.
// Be noticed that it will be also update, unRefer
// -----------------------------------------------------------------------------
//
void CMceEventReferMtEstablishedState::HandleL( CMceComEvent& aEvent )
    {
    MCEEVENTS_DEBUG("CMceEventReferMtEstablishedState::HandleL, Entry");
    //For Mt
    User::LeaveIfError( aEvent.SIPEvent().Dialog() ?
        KErrNone : KMceEventStateError );
        
    User::LeaveIfError( aEvent.SIPEvent().Dialog()->Type() 
        == SIPStrings::StringF( SipStrConsts::ENotify ) ?
        KErrNone : KMceEventStateError );
    
    // set subscription state and parameters
	TMceEventStateIndex nextState = KErrNotFound;
	CSIPSubscriptionStateHeader& subStateHeader = 
				( static_cast< CSIPNotifyDialogAssoc* >
				( aEvent.SIPEvent().Dialog() ) )->SubscriptionState();
		
    switch ( aEvent.PreviousAction() )
        {
        case EMceItcNotify:
            {
            MCESIPEventHelper::SetSubsStateHeaderValueAndParamsL( 
            									aEvent, 
            								   	SipStrConsts::ENotify,
            								   	subStateHeader,	
            									KStateActive, 
            									aEvent.RefreshInterval(),
            									EFalse );
           
             
            nextState = KMceEstablishingEventStateIndex;
            break;
            }
        case EMceItcTerminateEvent:
            {
             
            MCESIPEventHelper::SetSubsStateHeaderValueAndParamsL( 
            									aEvent, 
            								   SipStrConsts::ENotify,
            								   subStateHeader,	
            								   KStateTerminated,
            								   NULL );
         
            
           
            nextState = KMceTerminatingEventStateIndex;
            break;
            }
        default:
            {
            User::Leave( KMceEventStateError );
            break;
            }
        }
    
    // message elements
    CSIPMessageElements* message = 
	    MCESIPEventHelper::CreateMessageElementsLC( aEvent,
	                                                SipStrConsts::ENotify );
	
	// send Notify
	
    CSIPClientTransaction* transaction = 
		( static_cast< CSIPNotifyDialogAssoc* >
		( aEvent.SIPEvent().Dialog() ) )->SendNotifyL( message );		
		
    CleanupStack::Pop( message );
	CleanupStack::PushL( transaction );
	
	aEvent.SIPEvent().SetPendingTransactionL( transaction );
	CleanupStack::Pop( transaction );
	
	aEvent.EventContext().SetCurrentStateL( aEvent, nextState );
	MCEEVENTS_DEBUG("CMceEventReferMtEstablishedState::HandleL, Exit");
    }

// -----------------------------------------------------------------------------
// CMceEventReferMtEstablishedState::HandleReceiveRequestL
// Ápply concrete state.
// Be noticed that it will be also Refer/Bye or Refer/Invite(update)
// -----------------------------------------------------------------------------
//
void CMceEventReferMtEstablishedState::HandleReceiveRequestL( 
														CMceComEvent& aEvent )
	{
	MCEEVENTS_DEBUG("CMceEventReferMtEstablishedState::HandleReceiveRequestL, Entry");
	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 );
	
	//Received Subscribe from Mo there is no action in the previous action
	User::LeaveIfError( aEvent.PreviousAction() == KErrNotFound ?
	    KErrNone : KMceEventStateError );
	
    User::LeaveIfError( CSIPDialog::EConfirmed ==
        aEvent.SIPEvent().Dialog()->Dialog().State() ?
        KErrNone : KMceEventStateError );
    
    User::LeaveIfError( serverTran.RequestElements() ? KErrNone : KErrCorrupt) ;
					
	const CSIPMessageElements& subscribeMsg = 
	    serverTran.RequestElements()->MessageElements();
			
	TBool terminated = EFalse;
    CSIPResponseElements* response = 
        MCESIPEventHelper::SubscribeRequestReceivedLC( aEvent, subscribeMsg );
    
    if ( response->StatusCode() == KMceSipOK )
		{

		MCESIPEventHelper::HandleExpireHeaderL(
        								subscribeMsg,
        								terminated ); 
   
        aEvent.SIPEvent().Request().SendResponseL( response );
        
        CleanupStack::Pop( response );
        //then send Notify

		CSIPNotifyDialogAssoc* dialogAssoc = 
    			static_cast <CSIPNotifyDialogAssoc* >
    			(aEvent.SIPEvent().Dialog()); 

		CSIPMessageElements* notifyMsg = 
	        MCESIPEventHelper::CreateReferNotifyMessageElementsLC( aEvent );
		
		CSIPSubscriptionStateHeader& subscrState = 
		    dialogAssoc->SubscriptionState();
		
		TInt nextState = KErrNotFound;		
        if ( terminated )
            {
			subscrState.SetSubStateValueL( KStateTerminated );
			RStringF expires = SIPStrings::StringF( SipStrConsts::EExpires );
            subscrState.DeleteParam( expires );
            nextState = KMceTerminatingEventStateIndex;
            }
        else
            {
            //when subscription state is active
            subscrState.SetSubStateValueL( KStateActive );
			subscrState.SetExpiresParameterL(aEvent.RefreshInterval());
            nextState = KMceEstablishedEventStateIndex;
			}
        
        CSIPClientTransaction* tx = dialogAssoc->SendNotifyL( notifyMsg );
		CleanupStack::Pop( notifyMsg );
	    CleanupStack::PushL( tx );
		aEvent.SIPEvent().SetPendingTransactionL( tx );
		CleanupStack::Pop( tx );	
		
        aEvent.EventContext().SetCurrentStateL( aEvent, nextState );
        }
	else
	  	{
	  	// bad request
	    aEvent.SIPEvent().Request().SendResponseL( response );
	    CleanupStack::Pop( response );
	    }

	MCEEVENTS_DEBUG("CMceEventReferMtEstablishedState::HandleReceiveRequestL, Exit");
	}
	
// -----------------------------------------------------------------------------
// CMceEventReferMtEstablishedState::HandleResponseReceivedL
// Ápply concrete state.
// Be noticed that it will be also update, unRefer
// -----------------------------------------------------------------------------
//	
void CMceEventReferMtEstablishedState::HandleResponseReceivedL( 
												CMceComEvent& aEvent )
    {
    MCEEVENTS_DEBUG("CMceEventReferMtEstablishedState::HandleResponseReceivedL, Entry");
    CSIPClientTransaction& clientTran = aEvent.SIPEvent().Response();
    CSIPClientTransaction* clientTranCheck = &clientTran;;
	User::LeaveIfError( clientTranCheck ? KErrNone : KMceEventStateError );
		 
    User::LeaveIfError( 
        clientTran.ResponseElements() ? KErrNone : KErrCorrupt );
	
	// Response for first Notify comes here.
    aEvent.SetPreviousAction( KErrNotFound ); 
    TUint statusCode = clientTran.ResponseElements()->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("CMceEventReferMtEstablishedState::HandleResponseReceivedL, Exit");        
    }
    
//  End of File