/*
* Copyright (c) 2007 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 machine implementation.
*
*/

#include "nspstatemachine.h"
#include "nspstatebase.h"
#include "nspsessiondata.h"
#include "nspevents.h"
#include "nspstateinitializing.h"
#include "nspstateidle.h"
#include "nspstatelocalcand.h"
#include "nspstatenegotiating.h"
#include "nspstateresolving.h"
#include "nspstateactivating.h"
#include "nspstateconnected.h"
#include "nspstatedeactivating.h"
#include "nspdefs.h"

#define STATE_ID_L( statearray, state ) \
        User::LeaveIfError( statearray.Find( state ) )

#define LOGSTATE( aState ) \
    switch( aState )\
        {\
        case KStateIndexInitializing:{ NSPLOG_STR( "state:Initializing" ); break; }\
        case KStateIndexIdle:{ NSPLOG_STR( "state:Idle" ); break; }\
        case KStateIndexLocalCand:{ NSPLOG_STR( "state:LocalCand" ); break; }\
        case KStateIndexNegotiating:{ NSPLOG_STR( "state:Negotiating" ); break; }\
        case KStateIndexResolving:{ NSPLOG_STR( "state:Resolving" ); break; }\
        case KStateIndexActivating:{ NSPLOG_STR( "state:Activating" ); break; }\
        case KStateIndexConnected:{ NSPLOG_STR( "state:Connected" ); break; }\
        case KStateIndexDeActivating:{ NSPLOG_STR( "state:DeActivating" ); break; }\
        default:{ NSPLOG_STR( "state:Unknown" ); break; }\
        }

#define LOGOLDSTATE( aState ) \
    switch( aState )\
        {\
        case KStateIndexInitializing:{ NSPLOG_STR( "    old state:Initializing" ); break; }\
        case KStateIndexIdle:{ NSPLOG_STR( "    old state:Idle" ); break; }\
        case KStateIndexLocalCand:{ NSPLOG_STR( "    old state:LocalCand" ); break; }\
        case KStateIndexNegotiating:{ NSPLOG_STR( "    old state:Negotiating" ); break; }\
        case KStateIndexResolving:{ NSPLOG_STR( "    old state:Resolving" ); break; }\
        case KStateIndexActivating:{ NSPLOG_STR( "    old state:Activating" ); break; }\
        case KStateIndexConnected:{ NSPLOG_STR( "    old state:Connected" ); break; }\
        case KStateIndexDeActivating:{ NSPLOG_STR( "    old state:DeActivating" ); break; }\
        default:{ NSPLOG_STR( "    old state:Unknown" ); break; }\
        }

#define LOGSNEWTATE( aState ) \
    switch( aState )\
        {\
        case KStateIndexInitializing:{ NSPLOG_STR( "    new state:Initializing" ); break; }\
        case KStateIndexIdle:{ NSPLOG_STR( "    new state:Idle" ); break; }\
        case KStateIndexLocalCand:{ NSPLOG_STR( "    new state:LocalCand" ); break; }\
        case KStateIndexNegotiating:{ NSPLOG_STR( "    new state:Negotiating" ); break; }\
        case KStateIndexResolving:{ NSPLOG_STR( "    new state:Resolving" ); break; }\
        case KStateIndexActivating:{ NSPLOG_STR( "    new state:Activating" ); break; }\
        case KStateIndexConnected:{ NSPLOG_STR( "    new state:Connected" ); break; }\
        case KStateIndexDeActivating:{ NSPLOG_STR( "    new state:DeActivating" ); break; }\
        default:{ NSPLOG_STR( "    new state:Unknown" ); break; }\
        }


#define LOGEVENT( aEvent ) \
    switch( (TNSPStateMachineEvent::TRequest) aEvent.Request() )\
        {\
        case TNSPStateMachineEvent::ENat:{ NSPLOG_STR( "event:ENat" ); break; }\
        case TNSPStateMachineEvent::ECreateOffer:{ NSPLOG_STR( "event:ECreateOffer" ); break; }\
        case TNSPStateMachineEvent::EResolve:{ NSPLOG_STR( "event:EResolve" ); break; }\
        case TNSPStateMachineEvent::EDecodeAnswer:{ NSPLOG_STR( "event:EDecodeAnswer" ); break; }\
        case TNSPStateMachineEvent::EUpdate:{ NSPLOG_STR( "event:EUpdate" ); break; }\
        case TNSPStateMachineEvent::EReservationStatus:{ NSPLOG_STR( "event:EReservationStatus" ); break; }\
        case TNSPStateMachineEvent::ECloseSession:{ NSPLOG_STR( "event:ECloseSession" ); break; }\
        default:{ NSPLOG_STR( "event:Unknown" ); break; }\
        }

// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
// CNSPStateMachine::CNSPStateMachine
// ---------------------------------------------------------------------------
//
CNSPStateMachine::CNSPStateMachine()
    {
    }


// ---------------------------------------------------------------------------
// CNSPStateMachine::ConstructL
// ---------------------------------------------------------------------------
//
void CNSPStateMachine::ConstructL()
    {
    InitializeStateArrayL();
    iCurrentState = iStateArray[KStateIndexInitializing];
    }


// ---------------------------------------------------------------------------
// CNSPStateMachine::InitializeStateArrayL
// ---------------------------------------------------------------------------
//
void CNSPStateMachine::InitializeStateArrayL()
    {
    CNSPStateBase* state = NULL;
    
    state = CNSPStateInitializing::NewLC();
    User::LeaveIfError( iStateArray.Insert( state, KStateIndexInitializing ) );
    CleanupStack::Pop( state );
    
    state = CNSPStateIdle::NewLC();
    User::LeaveIfError( iStateArray.Insert( state, KStateIndexIdle ) );
    CleanupStack::Pop( state );
    
    state = CNSPStateLocalCand::NewLC();
    User::LeaveIfError( iStateArray.Insert( state, KStateIndexLocalCand ) );
    CleanupStack::Pop( state );
    
    state = CNSPStateNegotiating::NewLC();
    User::LeaveIfError( iStateArray.Insert( state, KStateIndexNegotiating ) );
    CleanupStack::Pop( state );
    
    state = CNSPStateResolving::NewLC();
    User::LeaveIfError( iStateArray.Insert( state, KStateIndexResolving ) );
    CleanupStack::Pop( state );
    
    state = CNSPStateActivating::NewLC();
    User::LeaveIfError( iStateArray.Insert( state, KStateIndexActivating ) );
    CleanupStack::Pop( state );
    
    state = CNSPStateConnected::NewLC();
    User::LeaveIfError( iStateArray.Insert( state, KStateIndexConnected ) );
    CleanupStack::Pop( state );

    state = CNSPStateDeActivating::NewLC();
    User::LeaveIfError( iStateArray.Insert( state, KStateIndexDeActivating ) );
    CleanupStack::Pop( state );
    }


// ---------------------------------------------------------------------------
// CNSPStateMachine::NewL
// ---------------------------------------------------------------------------
//
CNSPStateMachine* CNSPStateMachine::NewL()
    {
    CNSPStateMachine* self = CNSPStateMachine::NewLC();
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// CNSPStateMachine::NewLC
// ---------------------------------------------------------------------------
//
CNSPStateMachine* CNSPStateMachine::NewLC()
    {
    CNSPStateMachine* self = new ( ELeave ) CNSPStateMachine();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }


// ---------------------------------------------------------------------------
// CNSPStateMachine::~CNSPStateMachine
// ---------------------------------------------------------------------------
//
CNSPStateMachine::~CNSPStateMachine()
    {
    iStateArray.ResetAndDestroy();
    iStateArray.Close();
    }


// ---------------------------------------------------------------------------
// CNSPStateMachine::ProcessL
// ---------------------------------------------------------------------------
//
void CNSPStateMachine::ProcessL( TNSPStateMachineEvent& aEvent )
    {
    __ASSERT_ALWAYS( iCurrentState, User::Leave( KErrTotalLossOfPrecision ) );
    
    NSPLOG_STR( "CNSPStateMachine::ProcessL, Entry" )
    
    TBool accept = iCurrentState->AcceptL( aEvent );
    
    if ( accept )
        {
        TNSPStateIndex currState = STATE_ID_L( iStateArray, iCurrentState );
        aEvent.NextState() = currState;
        
        LOGSTATE( currState );
        LOGEVENT( aEvent );
        
        iCurrentState->ApplyL( aEvent );
        
        if ( currState != aEvent.NextState() )
            {
            NSPLOG_STR( "CNSPStateMachine::ProcessL, Changing session state." )
            LOGOLDSTATE( currState )
            
            IsAcceptableStateTransitionL( aEvent.NextState() );
            
            LOGSNEWTATE( aEvent.NextState() )
            
            iCurrentState->ExitL( aEvent );
            CNSPStateBase* newState = iStateArray[aEvent.NextState()];
            TRAPD( error, newState->StateEntryL( aEvent ) );
            
            if ( KErrNone != error )
                {
                NSPLOG_STR( "CNSPStateMachine::ProcessL, StateEntryL leave!" )
                NSPLOG_INT( "CNSPStateMachine::ProcessL, With leave code", error )
                NSPLOG_STR( "CNSPStateMachine::ProcessL, Reversing.." )
                iCurrentState->Reverse( aEvent );
                User::Leave( error );
                }
            else
                {
                iCurrentState = newState;
                }
            }
        }
    else
    	{
    	NSPLOG_STR( "CNSPStateMachine::ProcessL, Ignoring event." )
    	}
    
    NSPLOG_STR( "CNSPStateMachine::ProcessL, Exit" )
    }


// ---------------------------------------------------------------------------
// CNSPStateMachine::IsAcceptableStateTransitionL
// ---------------------------------------------------------------------------
//
void CNSPStateMachine::IsAcceptableStateTransitionL( 
        TNSPStateIndex aStateIndex ) const
    {
    User::LeaveIfError( IsAcceptableStateTransition( aStateIndex ) ?
            KErrNone : KErrArgument );
    }


// ---------------------------------------------------------------------------
// CNSPStateMachine::IsAcceptableStateTransition
// ---------------------------------------------------------------------------
//
TBool CNSPStateMachine::IsAcceptableStateTransition(
        TNSPStateIndex aStateIndex ) const
    {
    const TNSPStateIndex currstate = iStateArray.Find( iCurrentState );
    
    switch( currstate )
        {
        case KErrNotFound:
            {
            NSPLOG_STR(
            "CNSPStateMachine::IsAcceptableStateTransition(), Not found" )
            return EFalse;
            }
        
        case KStateIndexInitializing:
        	{
        	if ( KStateIndexIdle == aStateIndex )
        		{
        		return ETrue;
        		}
        	else
        		{
        		return EFalse;
        		}
        	}
        
        case KStateIndexIdle:
            {
            if ( KStateIndexLocalCand == aStateIndex )
                {
                return ETrue;
                }
            else
                {
                return EFalse;
                }
            }
        
        case KStateIndexLocalCand:
            {
            if ( KStateIndexNegotiating == aStateIndex ||
                 KStateIndexResolving == aStateIndex ||
                 KStateIndexActivating == aStateIndex )
                {
                return ETrue;
                }
            else
                {
                return EFalse;
                }
            }
        
        case KStateIndexNegotiating:
            {
            if ( KStateIndexResolving == aStateIndex ||
                 KStateIndexActivating == aStateIndex )
                {
                return ETrue;
                }
            else
                {
                return EFalse;
                }
            }
        
        case KStateIndexResolving:
            {
            if ( KStateIndexActivating == aStateIndex )
                {
                return ETrue;
                }
            else
                {
                return EFalse;
                }
            }
        
        case KStateIndexActivating:
            {
            if ( KStateIndexConnected == aStateIndex ||
                 KStateIndexDeActivating == aStateIndex )
                {
                return ETrue;
                }
            else
                {
                return EFalse;
                }
            }
        
        case KStateIndexConnected:
            {
            if ( KStateIndexLocalCand == aStateIndex ||
                 KStateIndexActivating == aStateIndex ||
                 KStateIndexResolving == aStateIndex ||
                 KStateIndexDeActivating == aStateIndex )
                {
                return ETrue;
                }
            else
                {
                return EFalse;
                }
            }
        
        case KStateIndexDeActivating:
            {
            return EFalse; // end state, no transitions allowed
            }
        
        default:
            {
            // never should come here,
            // since all state transitions are handled above
            NSPLOG_STR(
            "CNSPStateMachine::IsAcceptableStateTransition(), DEFAULT" )
            return EFalse;
            }
        }
    }


// end of file