/**************************************************************************
*
* Copyright (c) 2024-2024 Diality Inc. - All Rights Reserved.
*
* THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN
* WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER.
*
* @file    SafetyShutdown.c
*
* @author  (last)      Vinayakam Mani
* @date    (last)      09-Aug-2024
*
* @author  (original)  Vinayakam Mani
* @date    (original)  09-Aug-2024
*
***************************************************************************/

#include "mibspi.h"

#include "InternalADC.h"
#include "Messaging.h"
#include "SafetyShutdown.h"
#include "Timers.h"
#include "PAL.h"

/**
 *  @addtogroup SafetyShutdown
 *  @{
 */

// ********** private definitions **********

#define SAFETY_SHUTDOWN_POST_TIMEOUT_MS     500                                     ///< Safety shutdown POST test timeout (in ms).
#define SAFETY_SHUTDOWN_RECOVERY_TIME_MS    500                                     ///< After safety shutdown POST test, wait this long (in ms) to recover before moving on.

#define MAX_24V_LEVEL_ON_SAFETY_SHUTDOWN     5.0F                                   ///< Maximum voltage on 24V line when safety shutdown asserted.
#define MAX_ISOLATED_24V_LEVEL_ON_SS_EXPIRED 22.6F                                  ///< Maximum voltage on isolated 24V line when watchdog is expired. 10% of 24V.
#define MIN_24V_LEVEL_ON_SAFETY_RECOVER      22.6F                                  ///< Minimum voltage on 24V line when safety shutdown is recovered.

/// Enumeration of safety shutdown self-test states.
typedef enum Safety_Shutdown_Self_Test_States
{
    SAFETY_SHUTDOWN_SELF_TEST_STATE_START = 0,                                      ///< Safety shutdown self-test start state
    SAFETY_SHUTDOWN_SELF_TEST_STATE_IN_PROGRESS,                                    ///< Safety shutdown self-test in progress state
    SAFETY_SHUTDOWN_SELF_TEST_STATE_RECOVER,                                        ///< Safety shutdown self-test recovery state
    SAFETY_SHUTDOWN_SELF_TEST_STATE_COMPLETE,                                       ///< Safety shutdown self-test completed state
    NUM_OF_SAFETY_SHUTDOWN_SELF_TEST_STATES                                         ///< Number of safety shutdown self-test states
} SAFETY_SHUTDOWN_SELF_TEST_STATE_T;

// ********** private data **********

static BOOL safetyShutdownActivated;                                                ///< Status of safety shutdown signal.
static BOOL safetyShutdownOverrideResetState;                                       ///< Natural status of safety shutdown signal.  Used to restore state on override reset.
static SAFETY_SHUTDOWN_SELF_TEST_STATE_T safetyShutdownSelfTestState;               ///< Current safety shutdown self-test state.
static SELF_TEST_STATUS_T safetyShutdownSelfTestStatus;                             ///< Safety shutdown self-test preliminary status.
static U32 safetyShutdownSelfTestTimerCount;                                        ///< Safety shutdown self-test state timer counter.

/*********************************************************************//**
 * @brief
 * The initSafetyShutdown function initializes the safety shutdown unit.
 * The safety shutdown unit is to cut down the 24v DC supply to majority of actuators
 * when system detects critical faulty conditions.
 * @details \b Inputs: none
 * @details \b Outputs: safetyShutdownActivated, safetyShutdownOverrideResetState,
 * safetyShutdownSelfTestState, safetyShutdownSelfTestStatus,
 * safetyShutdownSelfTestTimerCount
 * @return none
 *************************************************************************/
void initSafetyShutdown( void )
{
    safetyShutdownActivated          = FALSE;
    safetyShutdownOverrideResetState = FALSE;
    safetyShutdownSelfTestState      = SAFETY_SHUTDOWN_SELF_TEST_STATE_START;
    safetyShutdownSelfTestStatus     = SELF_TEST_STATUS_IN_PROGRESS;
    safetyShutdownSelfTestTimerCount = 0;
    clear_saftety_shutdown();
}

/*********************************************************************//**
 * @brief
 * The activateSafetyShutdown function activates the safety shutdown signal.
 * @details \b Inputs: none
 * @details \b Outputs: Safety shutdown signal output set to active state.
 * @return none
 *************************************************************************/
void activateSafetyShutdown( void )
{
    set_safety_shutdown();
    safetyShutdownActivated = TRUE;
}

/*********************************************************************//**
 * @brief
 * The isSafetyShutdownActivated function returns whether the safety shutdown
 * signal has been activated.
 * @details \b Inputs: none
 * @details \b Outputs: none
 * @return safetyShutdownActivated
 *************************************************************************/
BOOL isSafetyShutdownActivated( void )
{
    return safetyShutdownActivated;
}

/*********************************************************************//**
 * @brief
 * The execSafetyShutdownTest function executes the safety shutdown test.
 * This function should be called periodically until a pass or fail
 * result is returned. This function primarily checks when safety shutdown
 * activated/ deactivated, the corresponding voltage is seen or not.
 * @details \b Inputs: safetyShutdownSelfTestState
 * @details \b Outputs: safetyShutdownSelfTestState
 * @details \b Alarms: ALARM_ID_DD_SAFETY_SHUTDOWN_POST_TEST_FAILED,
 * SW_FAULT_ID_SAFETY_SHUTDOWN_INVALID_SELF_TEST_STATE
 * @return in progress, passed, or failed
 *************************************************************************/
SELF_TEST_STATUS_T execSafetyShutdownTest( void )
{
    SELF_TEST_STATUS_T result = SELF_TEST_STATUS_IN_PROGRESS;

    switch ( safetyShutdownSelfTestState )
    {
        case SAFETY_SHUTDOWN_SELF_TEST_STATE_START:
            safetyShutdownSelfTestState = SAFETY_SHUTDOWN_SELF_TEST_STATE_IN_PROGRESS;
            safetyShutdownSelfTestTimerCount = getMSTimerCount();
            activateSafetyShutdown();
            break;

        case SAFETY_SHUTDOWN_SELF_TEST_STATE_IN_PROGRESS:
            if ( TRUE == didTimeout( safetyShutdownSelfTestTimerCount, SAFETY_SHUTDOWN_POST_TIMEOUT_MS ) )
            {
//                F32 v24         = getIntADCVoltageConverted( INT_ADC_SECONDARY_HEATER_24_VOLTS );
//                F32 isolatedV24 = getRawIsolatedPowerSupplyVoltage();
//
//                // Verify 24V is down when w.d. expired
//                if ( ( v24 > MAX_24V_LEVEL_ON_SAFETY_SHUTDOWN ) || ( isolatedV24 > MAX_ISOLATED_24V_LEVEL_ON_SS_EXPIRED ) )
//                {
//                    //SET_ALARM_WITH_2_F32_DATA( ALARM_ID_DD_SAFETY_SHUTDOWN_POST_TEST_FAILED, 1.0, v24 );
//                    safetyShutdownSelfTestStatus = SELF_TEST_STATUS_FAILED;
//                }
//                safetyShutdownSelfTestTimerCount = getMSTimerCount();
//                clear_saftety_shutdown();
//                safetyShutdownActivated = FALSE;
//                safetyShutdownSelfTestState = SAFETY_SHUTDOWN_SELF_TEST_STATE_RECOVER;
            }
            break;

        case SAFETY_SHUTDOWN_SELF_TEST_STATE_RECOVER:
            if ( TRUE == didTimeout( safetyShutdownSelfTestTimerCount, SAFETY_SHUTDOWN_RECOVERY_TIME_MS ) )
            {
//                F32 v24         = getIntADCVoltageConverted( INT_ADC_SECONDARY_HEATER_24_VOLTS );
//                F32 isolatedV24 = getRawIsolatedPowerSupplyVoltage();
//
//                // Verify 24V is down when w.d. recovered
//                if ( ( v24 < MIN_24V_LEVEL_ON_SAFETY_RECOVER ) || ( isolatedV24 < MAX_ISOLATED_24V_LEVEL_ON_SS_EXPIRED ) )
//                {
//                    // TODO - If issue persisted talk with systems why 24V does not recover fully.
//                    //SET_ALARM_WITH_2_F32_DATA( ALARM_ID_DD_SAFETY_SHUTDOWN_POST_TEST_FAILED, 2.0, v24 );
//                    safetyShutdownSelfTestStatus = SELF_TEST_STATUS_FAILED;
//                }
//                else
//                {
//                    safetyShutdownSelfTestStatus = SELF_TEST_STATUS_PASSED;
//                }
//                safetyShutdownSelfTestState = SAFETY_SHUTDOWN_SELF_TEST_STATE_COMPLETE;
//                result = safetyShutdownSelfTestStatus;
            }
            break;

        case SAFETY_SHUTDOWN_SELF_TEST_STATE_COMPLETE:
            // If we get called in this state, assume we are doing self-test again
            result = SELF_TEST_STATUS_IN_PROGRESS;
            safetyShutdownSelfTestState = SAFETY_SHUTDOWN_SELF_TEST_STATE_START;
            break;

        default:
            result = SELF_TEST_STATUS_FAILED;
            SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_SAFETY_SHUTDOWN_INVALID_SELF_TEST_STATE, safetyShutdownSelfTestState )
            break;
    }

    return result;
}

/*********************************************************************//**
 * @brief
 * The resetSafetyShutdownPOSTState function resets the safety shutdown POST state.
 * @details \b Inputs: none
 * @details \b Outputs: safetyShutdownSelfTestState
 * @return none
 *************************************************************************/
void resetSafetyShutdownPOSTState( void )
{
    safetyShutdownSelfTestState = SAFETY_SHUTDOWN_SELF_TEST_STATE_START;
}

/*********************************************************************//**
 * @brief
 * The testSetSafetyShutdownOverride function overrides the HD safety shutdown.
 * @details \b Inputs: none
 * @details \b Outputs: HD safety shutdown overridden
 * @param value TRUE to activate safety shutdown, FALSE to de-activate it
 * @return TRUE if override successful, FALSE if not
 *************************************************************************/
BOOL testSetSafetyShutdownOverride( U32 value )
{
    BOOL result = FALSE;

    if ( TRUE == isTestingActivated() )
    {
        // remember natural state before override so we can reset
        safetyShutdownOverrideResetState = safetyShutdownActivated;
        // override safety shutdown signal
        if ( value > 0 )
        {
            activateSafetyShutdown();
        }
        else
        {
            safetyShutdownActivated = FALSE;
            clear_saftety_shutdown();
        }
        result = TRUE;
    }

    return result;
}

/*********************************************************************//**
 * @brief
 * The testResetSafetyShutdownOverride function resets the override of the
 * HD safety shutdown.
 * @details \b Inputs: none
 * @details \b Outputs: shutdown override reset
 * @return TRUE if override reset successful, FALSE if not
 *************************************************************************/
BOOL testResetSafetyShutdownOverride( void )
{
    BOOL result = FALSE;

    if ( TRUE == isTestingActivated() )
    {
        if ( TRUE == safetyShutdownOverrideResetState )
        {
            activateSafetyShutdown();
        }
        else
        {
            safetyShutdownActivated = FALSE;
            clear_saftety_shutdown();
        }
        result = TRUE;
    }

    return result;
}

/**@}*/