/*
* Copyright (c) 2009 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: Implementation of CSsmStartupPolicy class.
*
*/

#include <centralrepository.h>
#include <e32property.h>
#include <e32uid.h>
#include <featmgr.h>
#include <ssm/ssmdomaindefs.h>
#include <ssm/ssmcmd.hrh>
#include <ssm/ssmcommandlistresourcereader.h>
#include <ssm/ssmstate.h>
#include <ssm/ssmstateawaresession.h>
#include <ssm/ssmstatetransition.h>
#include <ssm/startupdomainpskeys.h>

#include "ssmsubstateext.hrh"
#include "ssmmapperutility.h"
#include "ssmmapperutilitystatic.h"
#include "ssmstartuppolicy.h"
#include "ssmpolicypluginsprivatecrkeys.h"
#include "trace.h"

/**
* Start-up state policy resource file path format :
* "\private\<SID of SSM>\startup\<Value of KSystemStartupModeKey>\"
*/
_LIT( KCommandListPath, "Z:\\private\\2000D75B\\startup\\%d\\" );

// ======== LOCAL FUNCTIONS ========

// ---------------------------------------------------------------------------
// GetStartupMode
// ---------------------------------------------------------------------------
//
static TInt GetStartupMode()
    {
    FUNC_LOG;

    TInt startupMode( EStartupModeNormal );
    TInt errorCode = RProperty::Get(
        SsmMapperUtility::PsUid( KPSUidStartup ), KPSGlobalStartupMode, startupMode );
    ERROR( errorCode, "Failed to read startup mode from P&S" );
    INFO_1( "Startup mode is %d", startupMode );
    return startupMode;
    }


// ---------------------------------------------------------------------------
// DecideStateByStartupMode
// ---------------------------------------------------------------------------
//
static TSsmStartupSubStateExt DecideStateByStartupMode()
    {
    FUNC_LOG;

    TInt startupMode( GetStartupMode() );
    TSsmStartupSubStateExt nextState( ESsmStateSecurityCheck );
    switch ( startupMode )
        {
        case EStartupModeTest:
            nextState = ESsmStateTest;
            break;
        case EStartupModeAlarm:
            nextState = ESsmStateAlarm;
            break;
        case EStartupModeCharging:
            nextState = ESsmStateCharging;
            break;
        default:
            break;
        }

    return nextState;
    }


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

// ---------------------------------------------------------------------------
// CSsmStartupPolicy::NewL
// ---------------------------------------------------------------------------
//
EXPORT_C MSsmStatePolicy* CSsmStartupPolicy::NewL()
    {
    CSsmStartupPolicy* self = new( ELeave ) CSsmStartupPolicy;
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// CSsmStartupPolicy::~CSsmStartupPolicy
// ---------------------------------------------------------------------------
//
CSsmStartupPolicy::~CSsmStartupPolicy()
    {
    FUNC_LOG;
    }


// ---------------------------------------------------------------------------
// CSsmStartupPolicy::GetNextState
// ---------------------------------------------------------------------------
//
// TomP - We've simplified this: we now only have 3 sub-states: PreUIServices StartingUIServices and StartingCriticalApps
// After that we'll drop into the Normal state which with it's 1 sub-state: NonCritcalApps
TBool CSsmStartupPolicy::GetNextState(
    TSsmState aCurrentTransition,
    TInt /*aReason*/,
    TInt aError,
    TInt aSeverity,
    TSsmState& aNextState )
    {
    FUNC_LOG;
    INFO_2( "Current state %04x.%04x",
        aCurrentTransition.MainState(), aCurrentTransition.SubState() );
    ERROR_1( aError, "State transition resulted in an error, severity %d", aSeverity );
	ASSERT_TRACE( aCurrentTransition.MainState() == ESsmStartup );

	TBool moreToCome = EFalse;
	if ( aError == KErrNone || aSeverity < ECmdHighSeverity )
		{
		switch( aCurrentTransition.SubState() )
			{
			case KSsmAnySubState:
			case ESsmStatePreUiServices:
				aNextState = TSsmState( ESsmStartup, ESsmStateStartingUiServices );
				moreToCome = ETrue;
				break;
			case ESsmStateStartingUiServices:
				aNextState = TSsmState( ESsmStartup, ESsmStateStartingCriticalApps );
				moreToCome = ETrue;
				break;
			case ESsmStateStartingCriticalApps:
				//TomP aNextState = TSsmState( ESsmStartup, ESsmStateSelfTestOK );
				moreToCome = EFalse;
				break;
/*TomP		
			case ESsmStateSelfTestOK:
				aNextState = TSsmState( ESsmStartup, DecideStateByStartupMode() );
				moreToCome = ETrue;
				break;
			case ESsmStateChargingToNormal:
			case ESsmStateAlarmToNormal:
				aNextState = TSsmState( ESsmStartup, ESsmStateSecurityCheck );
				moreToCome = ETrue;
				break;
			case ESsmStateSecurityCheck:
				aNextState = TSsmState( ESsmStartup, SelectStateAfterSecurityCheck() );
				moreToCome = ETrue;
				break;
			case ESsmStateChargingToAlarm:
				aNextState = TSsmState( ESsmStartup, ESsmStateAlarm );
				moreToCome = ETrue;
				break;
			case ESsmStateAlarmToCharging:
				aNextState = TSsmState( ESsmStartup, ESsmStateCharging );
				moreToCome = ETrue;
				break;
			case ESsmStateNonCritical:
			    ClearResetCounter(); // start-up is successful
				aNextState = TSsmState( ESsmNormal, KSsmAnySubState );
				moreToCome = ETrue;
				break;
			case ESsmStateAlarm:
			case ESsmStateCharging:
			case ESsmStateTest:
				moreToCome = EFalse;
				break;
			case ESsmStateEmergencyCallsOnly:
			    ClearResetCounter(); // start-up is successful
				moreToCome = EFalse;
				break;
*/
			default:
        		ASSERT_ALWAYS_TRACE;
				moreToCome = EFalse;
				break;
			}
		}
	else
		{
        if ( ResetLimitReached() ) // Updates the reset count
            {
            aNextState = TSsmState( ESsmFail, KSsmAnySubState );
	    	moreToCome = ETrue;
    	    }
    	else
    	    {
            aNextState = TSsmState( ESsmShutdown, ESsmErrorShutdown );
            moreToCome = ETrue;
    	    }
		}

	return moreToCome;
    }


// ---------------------------------------------------------------------------
// CSsmStartupPolicy::GetCommandListPathL
// ---------------------------------------------------------------------------
//
void CSsmStartupPolicy::GetCommandListPathL( TDes& aCmdListPath )
    {
    FUNC_LOG;

	aCmdListPath.Format( KCommandListPath, iHardwareReason );
	iUtil->GetCommandListPath( aCmdListPath );
    }


// ---------------------------------------------------------------------------
// CSsmStartupPolicy::IsAllowedTargetState
// ---------------------------------------------------------------------------
//
TBool CSsmStartupPolicy::IsAllowedTargetState(
    const TSsmStateTransition& aRequest ) const
    {
    FUNC_LOG;

    TSsmState currentState;
    TInt errorCode = GetCurrentState( currentState );
    ERROR( errorCode, "Failed to get current state" );

    if ( errorCode == KErrNone )
        {
        TUint16 reqMainState( aRequest.State().MainState() );
        TUint16 reqSubState( aRequest.State().SubState() );
        INFO_2( "Requested target state = %04x.%04x", reqMainState, reqSubState );
        TUint16 curMainState( currentState.MainState() );
        TUint16 curSubState( currentState.SubState() );
        INFO_2( "Current state = %04x.%04x", curMainState, curSubState );

		// TomP - We'll allow any state transition as long as there was no error
		return ETrue;
        if ( reqMainState == ESsmStartup )
            {
            if ( ( curSubState == ESsmStateCharging &&
                   ( reqSubState == ESsmStateChargingToAlarm ||
                     reqSubState == ESsmStateChargingToNormal ) ) ||
                 ( curSubState == ESsmStateAlarm &&
                   ( reqSubState == ESsmStateAlarmToCharging ||
                     reqSubState == ESsmStateAlarmToNormal ) ) )
                {
                return ETrue;
                }
            }
        else if ( reqMainState == ESsmNormal )
            {
            if ( ( curMainState == ESsmStartup &&
                   curSubState == ESsmStateNonCritical ) )
                {
                return ETrue;
                }
            }
        else if ( reqMainState == ESsmFail ||
                  reqMainState == ESsmShutdown )
            {
            return ETrue;
            }
        }

    return EFalse;
    }


// ---------------------------------------------------------------------------
// CSsmStartupPolicy::TargetSubState
// ---------------------------------------------------------------------------
//
TUint16 CSsmStartupPolicy::TargetSubState( const TUint16 aRequestedSubState )
    {
    FUNC_LOG;
    INFO_1( "Requested sub state %04x", aRequestedSubState );

	return ( aRequestedSubState == KSsmAnySubState ) ?
        ESsmStatePreUiServices : aRequestedSubState;
    }


// ---------------------------------------------------------------------------
// CSsmStartupPolicy::CSsmStartupPolicy
// ---------------------------------------------------------------------------
//
CSsmStartupPolicy::CSsmStartupPolicy()
    {
    FUNC_LOG;
    }


// ---------------------------------------------------------------------------
// CSsmStartupPolicy::ConstructL
// ---------------------------------------------------------------------------
//
void CSsmStartupPolicy::ConstructL()
    {
    FUNC_LOG;

	// Read the hardware reason
	User::LeaveIfError( RProperty::Get(
	    KUidSystemCategory, KSystemStartupModeKey, iHardwareReason ) );

    BaseConstructL();
    }


// ---------------------------------------------------------------------------
// CSsmStartupPolicy::IsSimlessOfflineSupported
// ---------------------------------------------------------------------------
//
TBool CSsmStartupPolicy::IsSimlessOfflineSupported()
    {
    FUNC_LOG;
/*	
    TBool ret( EFalse );

    ret = ( iUtil->FeatureStatus( TUid::Uid( KFeatureIdOfflineMode ) ) ||
            iUtil->FeatureStatus( TUid::Uid( KFeatureIdFlightMode ) ) ) &&
            iUtil->FeatureStatus( TUid::Uid( KFeatureIdFfSimlessOfflineSupport ) );

    INFO_1( "Simless offline supported = %d", ret );
*/	
	//TomP - SIMless Offline is always supported
    return ETrue;
    }


// ---------------------------------------------------------------------------
// CSsmStartupPolicy::SelectStateAfterSecurityCheck
// ---------------------------------------------------------------------------
//
TUint16 CSsmStartupPolicy::SelectStateAfterSecurityCheck()
    {
    FUNC_LOG;
/*
    TInt value( ESimStatusUninitialized );
    TInt errorCode = RProperty::Get( iUtil->PsUid( KPSUidStartup ), KPSSimStatus, value );
    ERROR( errorCode, "Failed to read KPSUidStartup::KPSSimStatus P&S key" );
    INFO_1( "Current SIM status = %d", value );
    TUint16 retVal( ESsmStateEmergencyCallsOnly );
    if ( errorCode == KErrNone )
        {
        if ( value == ESimUsable || value == ESimNotSupported )
            {
            retVal = ESsmStateNonCritical;
            }
        else if ( value == ESimNotPresent && IsSimlessOfflineSupported() )
            {
            retVal = ESsmStateNonCritical;
            }
        }

    INFO_1( "State selected after security check = %04x", retVal );
*/	
	// TomP - Always jump straight into Non Critical State next
    return ESsmStateNonCritical;
    }


// ---------------------------------------------------------------------------
// CSsmStartupPolicy::ClearResetCounter
// ---------------------------------------------------------------------------
//
void CSsmStartupPolicy::ClearResetCounter()
    {
    FUNC_LOG;

    TRAPD_ERR( errorCode, ClearResetCounterL() );
    ERROR( errorCode, "Failed to clear reset counter" );
    }


// ---------------------------------------------------------------------------
// ClearResetCounterL
// ---------------------------------------------------------------------------
//
void CSsmStartupPolicy::ClearResetCounterL()
    {
    FUNC_LOG;

    CRepository* repository = CRepository::NewLC( iUtil->CrUid( KCRUidSsmStartupPolicy ) );
    User::LeaveIfError( repository->Set( KSsmStartupErrorResetCounter, 0 ) );
    CleanupStack::PopAndDestroy( repository );
    }