/*
* 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:    Class for event context. Contains methods for
*                creating the state array and controlling current state.
*
*/




#include "mcecomevent.h"
#include "mceeventcontext.h"
#include "mceeventstatebase.h"
#include "mceeventsubscribemoestablishedstate.h"
#include "mceeventsubscribemtestablishedstate.h"
#include "mceeventsubscribeterminatingstate.h"
#include "mceeventsubscribeterminatedstate.h"
#include "mceeventrefermoestablishedstate.h"
#include "mceeventrefermtestablishedstate.h"
#include "mceeventreferterminatingstate.h"
#include "mceeventreferterminatedstate.h"
#include "mceeventsubscribemoidlestate.h"
#include "mceeventsubscribemoestablishingstate.h"
#include "mceeventrefermoidlestate.h"
#include "mceeventrefermoestablishingstate.h"
#include "mceeventsubscribemtidlestate.h"
#include "mceeventsubscribemtestablishingstate.h"
#include "mceeventrefermtidlestate.h"
#include "mceeventrefermtestablishingstate.h"

// -----------------------------------------------------------------------------
// CMCEMoEventSubscribeContext::NewL
// -----------------------------------------------------------------------------
//
CMceEventContext* CMceEventContext::NewL( CMceComEvent& aEvent )
	{
	CMceEventContext* self = new( ELeave ) CMceEventContext;
    CleanupStack::PushL( self );
    self->ConstructL( aEvent );
    CleanupStack::Pop(self);
    return self;
	}

// -----------------------------------------------------------------------------
// CMceEventContext::CMceEventContext
// -----------------------------------------------------------------------------
//
CMceEventContext::CMceEventContext()
    {
    }

// -----------------------------------------------------------------------------
// CMceEventContext::ConstructL
// -----------------------------------------------------------------------------
//
void CMceEventContext::ConstructL( CMceComEvent& aEvent )
	{
	InitializeStateArrayL(aEvent);
    SetCurrentStateL( aEvent, KMceIdleEventStateIndex );
	}
	
// -----------------------------------------------------------------------------
// CMceEventContext::~CMceEventContext
// -----------------------------------------------------------------------------
//
CMceEventContext::~CMceEventContext()
	{
	if ( iStates )
	    {
	    iStates->ResetAndDestroy();
        iStates->Close();
        delete iStates;
        iStates = NULL;    
	    }
    }
	
// -----------------------------------------------------------------------------
// CMceEventContext::SetCurrentState
// -----------------------------------------------------------------------------
//
void CMceEventContext::SetCurrentStateL( CMceComEvent& aEvent, 
            				          	 TMceEventStateIndex aNewEventState )
	{
	TInt leave = KErrNone;
	if (aNewEventState > KMceSrvEventStateArraySize-1)
		{
		leave = KMceEventStateError;	
		}
	   // Check, if the transition is valid
	if(aEvent.SIPEvent().EventStateType()==EMoSubscribe ||
	aEvent.SIPEvent().EventStateType()==EMoRefer)
		{
		if ( !IsMoStateTransitionAccepted( aNewEventState ) )
        	{
        	leave = KMceEventStateError;
        	}
    	else
        	{
        	iCurrentState = ( *iStates )[ aNewEventState ];
        	}
		}
    else //MT
    	{
    	if ( !IsMtStateTransitionAccepted( aNewEventState ) )
        	{
        	leave = KMceEventStateError;
        	}
    	else
        	{
        	iCurrentState = ( *iStates )[ aNewEventState ];
        	}	
    	}
    User::LeaveIfError( leave );
    }
	
// -----------------------------------------------------------------------------
// CMceEventContext::CurrentState()
// -----------------------------------------------------------------------------
//
TMceEventStateIndex CMceEventContext::CurrentState()
	{
	return iStates->Find( iCurrentState );
	}

// -----------------------------------------------------------------------------
// CMceEventContext::ProcessSubscribeEventL
// -----------------------------------------------------------------------------
//
void CMceEventContext::ProcessEventL( CMceComEvent& aEvent )
	{
	iCurrentState->ProcessStateL( aEvent );
	}

// -----------------------------------------------------------------------------
// CMceEventContext::ProcessRequestReceivedEventL
// -----------------------------------------------------------------------------
//
void CMceEventContext::ProcessRequestReceivedEventL( CMceComEvent& aEvent )
	{
	iCurrentState->ProcessReqRecvStateL( aEvent );
	}

// -----------------------------------------------------------------------------
// CMceEventContext::ProcessIncomingResponseEventL
// -----------------------------------------------------------------------------
//
void CMceEventContext::ProcessIncomingResponseEventL( CMceComEvent& aEvent )
	{
	iCurrentState->ProcessRespRecvStateL( aEvent );
	}

// -----------------------------------------------------------------------------
// CMceEventContext::InitializeStateArrayL
// -----------------------------------------------------------------------------
//
void CMceEventContext::InitializeStateArrayL( CMceComEvent& aEvent )
	{
	    // Create state array
    iStates = new ( ELeave ) RPointerArray< CMceEventStateBase >(
                                       KMceSrvEventStateArraySize );

    // States common for MO and MT are created here.
    // Established event state
    if (aEvent.SIPEvent().EventStateType()==EMoSubscribe)
    	{
    	InitialSubscribeCommonStatesL();
    	//moSubscirbe State
    	    // MO Idle state
    	CMceEventSubscribeMoIdleState* idleEvent = 
    	    new( ELeave ) CMceEventSubscribeMoIdleState();
		CleanupStack::PushL( idleEvent );
		User::LeaveIfError( iStates->Insert(
									idleEvent, KMceIdleEventStateIndex ) );   
		CleanupStack::Pop( idleEvent );

		// MO Establishing state
		  
		CMceEventSubscribeMoEstablishingState* establishingEvent = 
		    new( ELeave ) CMceEventSubscribeMoEstablishingState();
		CleanupStack::PushL( establishingEvent );
		User::LeaveIfError( iStates->Insert(
	        establishingEvent, KMceEstablishingEventStateIndex ) );   
		CleanupStack::Pop( establishingEvent );
		
		CMceEventSubscribeMoEstablishedState* established = 
		    new( ELeave ) CMceEventSubscribeMoEstablishedState();
    	CleanupStack::PushL( established );
		User::LeaveIfError( iStates->Insert( 
	    	established, KMceEstablishedEventStateIndex ) );
		CleanupStack::Pop( established );
		}
	else if(aEvent.SIPEvent().EventStateType()==EMtSubscribe)
		{
		InitialSubscribeCommonStatesL();
		//mtSubscribe State
		    // MT Idle state
	   	CMceEventSubscribeMtIdleState* idleEvent = 
	   	    new( ELeave ) CMceEventSubscribeMtIdleState();
	    CleanupStack::PushL( idleEvent );
	    User::LeaveIfError( iStates->Insert(
	        idleEvent, KMceIdleEventStateIndex ) );   
	    CleanupStack::Pop( idleEvent );
	    
	    // Mt establishing state
	    CMceEventSubscribeMtEstablishingState* establishing = 
	        new ( ELeave ) CMceEventSubscribeMtEstablishingState();
	    CleanupStack::PushL( establishing );
	    User::LeaveIfError( iStates->Insert( 
	        establishing, KMceEstablishingEventStateIndex ) );
	    CleanupStack::Pop( establishing );
	    
	    //Mt established
	    CMceEventSubscribeMtEstablishedState* established = 
	        new( ELeave ) CMceEventSubscribeMtEstablishedState();
		CleanupStack::PushL( established );
		User::LeaveIfError( iStates->Insert( 
		    established, KMceEstablishedEventStateIndex ) );
		CleanupStack::Pop( established );
		}
	else if(aEvent.SIPEvent().EventStateType()==EMoRefer)
		{
		InitialReferCommonStatesL();
		//moReferState	
		// MO Idle state
	    CMceEventReferMoIdleState* idleEvent = 
	        new( ELeave )CMceEventReferMoIdleState();
	    CleanupStack::PushL( idleEvent );
	    User::LeaveIfError( iStates->Insert(
	    								idleEvent, KMceIdleEventStateIndex ) );
	    CleanupStack::Pop( idleEvent );
	    
	    // MO Establishing state
	    CMceEventReferMoEstablishingState* establishingEvent = 
	        new( ELeave )CMceEventReferMoEstablishingState;
	    CleanupStack::PushL( establishingEvent );
	    User::LeaveIfError( iStates->Insert(
	        establishingEvent, KMceEstablishingEventStateIndex ) );   
	    CleanupStack::Pop( establishingEvent );
	    //Mo Established
	    CMceEventReferMoEstablishedState* established = 
    	    new( ELeave ) CMceEventReferMoEstablishedState();
		CleanupStack::PushL( established );
		User::LeaveIfError( iStates->Insert( 
	    	established, KMceEstablishedEventStateIndex ) );
		CleanupStack::Pop( established );
        }
	else
		{
		InitialReferCommonStatesL();
		//mtReferState	
		// MT Idle state
	   	CMceEventReferMtIdleState* idleEvent = 
	   	    new( ELeave ) CMceEventReferMtIdleState();
	    CleanupStack::PushL( idleEvent );
	    User::LeaveIfError( iStates->Insert(
	        idleEvent, KMceIdleEventStateIndex ) );   
	    CleanupStack::Pop( idleEvent );
	    
	    // Server establishing state
	    CMceEventReferMtEstablishingState* establishing = 
	        new( ELeave ) CMceEventReferMtEstablishingState();
	    CleanupStack::PushL( establishing );
	    User::LeaveIfError( iStates->Insert( 
	        establishing, KMceEstablishingEventStateIndex ) );
	    CleanupStack::Pop( establishing );
	   	//Mt established
	   	CMceEventReferMtEstablishedState* established = 
    	    new( ELeave )CMceEventReferMtEstablishedState();
		CleanupStack::PushL( established );
		User::LeaveIfError( iStates->Insert( 
	    	established, KMceEstablishedEventStateIndex ) );
		CleanupStack::Pop( established );	
		}
 
  	}
// -----------------------------------------------------------------------------
// CMceEventContext::InitialSubscribeCommonStates
// -----------------------------------------------------------------------------
//
void CMceEventContext::InitialSubscribeCommonStatesL()
	{
	// Terminating event state
	CMceEventSubscribeTerminatingState* terminating = 
	    new( ELeave )CMceEventSubscribeTerminatingState();
	CleanupStack::PushL( terminating );
    User::LeaveIfError( iStates->Insert( 
	    terminating, KMceTerminatingEventStateIndex ) );
	CleanupStack::Pop( terminating ); 

	// Terminated event state
	CMceEventSubscribeTerminatedState* terminated = 
	    new( ELeave ) CMceEventSubscribeTerminatedState();
    CleanupStack::PushL( terminated );
    User::LeaveIfError( iStates->Insert( 
	    terminated, KMceTerminatedEventStateIndex ) );
	CleanupStack::Pop( terminated );
	}

// -----------------------------------------------------------------------------
// CMceEventContext::InitialReferCommonStates
// -----------------------------------------------------------------------------
//
void CMceEventContext::InitialReferCommonStatesL()
	{
	// Terminating event state
	CMceEventReferTerminatingState* terminating = 
	    new( ELeave ) CMceEventReferTerminatingState();
	CleanupStack::PushL( terminating );
	User::LeaveIfError( iStates->Insert( 
	    terminating, KMceTerminatingEventStateIndex ) );
	CleanupStack::Pop( terminating ); 

	// Terminated event state
	CMceEventReferTerminatedState* terminated = 
	    new( ELeave ) CMceEventReferTerminatedState();
	CleanupStack::PushL( terminated );
	User::LeaveIfError( iStates->Insert( 
	    terminated, KMceTerminatedEventStateIndex ) );
	CleanupStack::Pop( terminated );		
	}
	
// -----------------------------------------------------------------------------
// CMCEMoEventSubscribeContext::IsMoStateTransitionAccepted
// -----------------------------------------------------------------------------
//     
TBool CMceEventContext::IsMoStateTransitionAccepted( 
                                            TMceEventStateIndex aNewState )
	{
    // Call the parent function.
    return IsStateTransitionAccepted( aNewState );
	}
	
// -----------------------------------------------------------------------------
// CMceSrvMoEventContext::IsMtStateTransitionAccepted
// -----------------------------------------------------------------------------
//     
TBool CMceEventContext::IsMtStateTransitionAccepted( 
                                            TMceEventStateIndex aNewState )
	{
	TMceEventStateIndex currentState = CurrentState();
	TBool ret = IsStateTransitionAccepted( aNewState );
	if ( !ret )
	    {
	    switch ( currentState )
            {
            case KMceIdleEventStateIndex:
                {
                // From MT event idle state, transition to client establishing 
                // state is allowed.
                if (KMceEstablishedEventStateIndex == aNewState ||
            	    KMceTerminatedEventStateIndex == aNewState ) 
                    {
                    ret = ETrue;
                    }
                break;
                }
            
            default:
                {
                ret = EFalse;
                break;
                }
    	    }
	    }
	return ret;
	}


// -----------------------------------------------------------------------------
// CMceEventContext::IsStateTransitionAccepted
// -----------------------------------------------------------------------------
//
TMceEventStateIndex CMceEventContext::IsStateTransitionAccepted(
										    TMceEventStateIndex aNewState )
	{
	TMceEventStateIndex current = CurrentState();
    switch( current )
        {
        case KErrNotFound:
            {
            // Only idle state can be the first one.
            if ( KMceIdleEventStateIndex == aNewState )
                {
                return ETrue;
                }
            else
                {
                return EFalse;
                }
            }
            
        case KMceIdleEventStateIndex:
            {
            if ( KMceEstablishingEventStateIndex == aNewState )
                {
                return ETrue;
                }
            else
                {
                return EFalse;
                }
            }
        
        case KMceEstablishingEventStateIndex:
            {
            if ( KMceEstablishedEventStateIndex == aNewState ||
                 KMceTerminatedEventStateIndex == aNewState )
                {
                return ETrue;
                }
            else
                {
                return EFalse;
                }
            }
        
        case KMceEstablishedEventStateIndex:
            { 
            if ( KMceEstablishingEventStateIndex == aNewState ||
            	 KMceEstablishedEventStateIndex == aNewState || 
            	 KMceTerminatingEventStateIndex == aNewState ||
            	 KMceTerminatedEventStateIndex == aNewState )
                {
                return ETrue;
                }
            else
                {
                return EFalse;
                }
            }
               
        case KMceTerminatingEventStateIndex:
            {
            // From terminating state, transition to terminated is accepted.
            if ( KMceTerminatedEventStateIndex == aNewState )
                {
                return ETrue;
                }
            else
                {
                return EFalse;
                }
            } 
        
        default:
            {
            // From terminated state no transition is allowed.
            // All the states are handled either here or in separate methods
            // for MO or MT events. 
            return EFalse;
            }
   
        }

	}