/**************************************************************************
*
* Copyright (c) 2020-2023 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    AlarmMgmt.c
*
* @author  (last)      Sean Nash
* @date    (last)      09-Aug-2023
*
* @author  (original)  Sean
* @date    (original)  04-Feb-2020
*
***************************************************************************/

#define __ALARM_MGMT_C__

#include "AlarmMgmt.h"
#include "CPLD.h"
#include "OperationModes.h"
#include "PersistentAlarm.h"
#include "Reservoirs.h"
#include "SafetyShutdown.h"
#include "SystemComm.h"
#include "SystemCommMessages.h"
#include "TaskGeneral.h"
#include "Timers.h"

/**
 *  @addtogroup AlarmManagement
 *  @{
 */

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

/// Interval (ms/task time) at which the alarm information is published on the CAN bus.
#define ALARM_INFO_PUB_INTERVAL                 ( MS_PER_SECOND / TASK_GENERAL_INTERVAL )
#define DATA_PUBLISH_COUNTER_START_COUNT        12                                                      ///< Data publish counter start count.
#define ALARM_DG_FAULT_LED_ON_INTERVAL          ( MS_PER_SECOND / 4 / TASK_GENERAL_INTERVAL )           ///< LED Flash ON time interval time
#define ALARM_DG_FAULT_LED_OFF_INTERVAL         ( ALARM_DG_FAULT_LED_ON_INTERVAL * 2 )                  ///< LED Flash OFF time interval time

// *** This declaration will cause a compiler error if ALARM_TABLE does not have same # of alarms as the Alarm_List enumeration.
U08 alarmTableSizeAssertion[ ( ( sizeof( ALARM_TABLE ) / sizeof( ALARM_T ) ) == NUM_OF_ALARM_IDS ? 1 : -1 ) ];

// *** This declaration will cause a compiler error if ALARM_RANK_TABLE does not have same # of alarms as the Alarm_List enumeration.
U08 alarmRankTableSizeAssertion[ ( ( sizeof( ALARM_RANK_TABLE ) / sizeof( ALARM_RANK_T ) ) == NUM_OF_ALARM_IDS ? 1 : -1 ) ];

U32 alarmLEDTimer;                                                      ///< Alarm LED timer

const ALARM_DATA_T BLANK_ALARM_DATA = { ALARM_DATA_TYPE_NONE, 0 };      ///< A blank alarm data record for alarms that do not include alarm data when triggered.

#define SUPERVISOR_ALARM_KEY        0xD2C3B4A5                          ///< 32-bit key required for clear all alarms request.

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

static BOOL alarmIsActive[ NUM_OF_ALARM_IDS ];                          ///< Array of current state of each alarm
static BOOL alarmConditionIsActive[ NUM_OF_ALARM_IDS ];                 ///< Array of flag indicates if an alarm condition is active
static U32 alarmInfoPublicationTimerCounter;                            ///< Used to schedule alarm information publication to CAN bus.
static BOOL isAFaultAlarmActive;                                        ///< Boolean flag to indicate whether a DG fault alarm is active.
/// Interval (in task intervals) at which to publish alarm information to CAN bus.
static OVERRIDE_U32_T alarmInfoPublishInterval = { ALARM_INFO_PUB_INTERVAL, ALARM_INFO_PUB_INTERVAL, ALARM_INFO_PUB_INTERVAL, 0 };

// ********** private function prototypes **********

static void activateAlarm( ALARM_ID_T alarm );
static void publishAlarmInfo( void );
static void alarmUserNotify( void );
static BOOL isTransitionToFaultRequired( void );

/*********************************************************************//**
 * @brief
 * The initAlarmMgmt function initializes the AlarmMgmt module.
 * @details Inputs: none
 * @details Outputs: alarmInfoPublicationTimerCounter, alarmLEDTimer,
 * isAFaultAlarmActive, alarmIsActive, alarmConditionIsActive
 * @return none
 *************************************************************************/
void initAlarmMgmt( void )
{
    ALARM_ID_T alrm;

    alarmInfoPublicationTimerCounter = DATA_PUBLISH_COUNTER_START_COUNT;
    alarmLEDTimer                    = 0;
    isAFaultAlarmActive              = FALSE;

    // initialize alarm states and start time stamps
    for ( alrm = ALARM_ID_NO_ALARM; alrm < NUM_OF_ALARM_IDS; alrm++ )
    {
        alarmIsActive[ alrm ]          = FALSE;
        alarmConditionIsActive[ alrm ] = FALSE;
    }
}

/*********************************************************************//**
 * @brief
 * The execAlarmMgmt function executes the alarm management module.
 * @details Inputs: none
 * @details Outputs: none
 * @return none
 *************************************************************************/
void execAlarmMgmt( void )
{
    // Alarm audio and LED/lamp management for DG
    alarmUserNotify();

    // Publish alarm information at interval
    publishAlarmInfo();
}

/*********************************************************************//**
 * @brief
 * The activateAlarm function activates a given alarm.
 * @details Inputs: none
 * @details Outputs: alarmIsActive[], isAFaultAlarmActive
 * @param alarm ID of alarm to activate
 * @return none
 *************************************************************************/
static void activateAlarm( ALARM_ID_T alarm )
{
    // verify given alarm
    if ( ( alarm > ALARM_ID_NO_ALARM ) && ( alarm < NUM_OF_ALARM_IDS ) )
    {
        // no need to do anything if alarm is already active
        if ( FALSE == alarmIsActive[ alarm ] )
        {
            // activate alarm
            alarmIsActive[ alarm ]          = TRUE;
            alarmConditionIsActive[ alarm ] = TRUE;

            if ( TRUE == ALARM_TABLE[ alarm ].alarmIsDGFault )
            {
                // There is a DG fault alarm.
                isAFaultAlarmActive = TRUE;

                if ( TRUE == isTransitionToFaultRequired() )
                {
                    // If alarm is a DG fault and the alarm manager can transition to fault immediately, go to fault mode
                    requestNewOperationMode( DG_MODE_FAUL );
                }
            }
            // If alarm has clear condition immediately property, clear condition now
            if ( TRUE == ALARM_TABLE[ alarm ].alarmConditionClearImmed )
            {
                clearAlarmCondition( alarm );
            }
        }
    }
    else
    {
        SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_TO_ACTIVATE, alarm )
    }
}

/*********************************************************************//**
 * @brief
 * The activateAlarmNoData function activates a given alarm. An alarm message
 * is broadcast to the rest of the system.
 * @details Inputs: none
 * @details Outputs: alarm triggered message sent, alarm activated
 * @param alarm ID of alarm to activate
 * @return none
 *************************************************************************/
void activateAlarmNoData( ALARM_ID_T alarm )
{
    activateAlarm2Data( alarm, BLANK_ALARM_DATA, BLANK_ALARM_DATA, FALSE );
}

/*********************************************************************//**
 * @brief
 * The activateAlarm1Data function activates a given alarm. An alarm message
 * is broadcast to the rest of the system.  This function will include given
 * data in the broadcast message for logging.
 * @details Inputs: none
 * @details Outputs: alarm triggered message sent, alarm activated
 * @param alarm ID of alarm to activate
 * @param alarmData supporting data to include in alarm message
 * @return none
 *************************************************************************/
void activateAlarm1Data( ALARM_ID_T alarm, ALARM_DATA_T alarmData )
{
    activateAlarm2Data( alarm, alarmData, BLANK_ALARM_DATA, FALSE );
}

/*********************************************************************//**
 * @brief
 * The activateAlarm2Data function activates a given alarm. An alarm message
 * is broadcast to the rest of the system.  This function will include
 * two given data in the broadcast message for logging.
 * @details Inputs: none
 * @details Outputs: alarm triggered message sent, alarm activated
 * @param alarm ID of alarm to activate
 * @param alarmData1 supporting data to include in alarm message
 * @param alarmData2 supporting data to include in alarm message
 * @param outside flag indicates whether alarm is originating from outside HD f/w
 * @return none
 *************************************************************************/
void activateAlarm2Data( ALARM_ID_T alarm, ALARM_DATA_T alarmData1, ALARM_DATA_T alarmData2, BOOL outside )
{
    HD_MODE_SUB_MODE_T hdModes;

    getHDOperationMode( &hdModes );

    // prevent alarm trigger if property blocks in current mode/state
    if ( ( ( ALARM_TABLE[ alarm ].alarmBlockRinseback != TRUE ) || ( hdModes.hdMode != MODE_TREA ) || ( hdModes.hdSubMode != TREATMENT_RINSEBACK_STATE ) ) &&
         ( ( ALARM_TABLE[ alarm ].alarmBlockEndTx != TRUE ) || ( hdModes.hdMode != MODE_POST ) ) )
    {
        // broadcast alarm and data if alarm not already active
        if ( ( FALSE == alarmIsActive[ alarm ] ) && ( TRUE == isHDCommunicating() ) )
        {
            broadcastAlarmTriggered( alarm, alarmData1, alarmData2 );
        }
        activateAlarm( alarm );
    }
}

/*********************************************************************//**
 * @brief
 * The clearAlarm function clears a given alarm if it is recoverable.
 * An alarm message is broadcast to the rest of the system.
 * @details Inputs: none
 * @details Outputs: AlarmStatusTable[]
 * @param alarm ID of alarm to clear
 * @return none
 *************************************************************************/
void clearAlarm( ALARM_ID_T alarm )
{
    // verify given alarm
    if ( ( alarm > ALARM_ID_NO_ALARM ) && ( alarm < NUM_OF_ALARM_IDS ) )
    {
        // clear alarm and broadcast alarm clear if not already cleared (and not a DG fault which should not be cleared)
        if ( ( TRUE == alarmIsActive[ alarm ] ) && ( ALARM_TABLE[ alarm ].alarmIsDGFault != TRUE ) )
        {
            if ( TRUE == isHDCommunicating() )
            {
                broadcastAlarmCleared( alarm );
            }
            alarmIsActive[ alarm ] = FALSE;
            clearAlarmCondition( alarm );
        }
    }
    else
    {
        SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_TO_CLEAR, alarm )
    }
}

/*********************************************************************//**
 * @brief
 * The clearAlarmCondition function clears a given alarm's condition detected
 * flag. Also an alarm message is broadcast to the rest of the system.
 * @details Inputs: none
 * @details Outputs: alarmConditionIsActive[]
 * @param alarm ID of alarm to clear condition for
 * @return none
 *************************************************************************/
void clearAlarmCondition( ALARM_ID_T alarm )
{
    // verify given alarm
    if ( ( alarm > ALARM_ID_NO_ALARM ) && ( alarm < NUM_OF_ALARM_IDS ) )
    {
        // clear alarm and broadcast alarm clear if not already cleared
        if ( TRUE == alarmConditionIsActive[ alarm ] )
        {
            if ( TRUE == isHDCommunicating() )
            {
                broadcastAlarmConditionCleared( alarm );
            }
            alarmConditionIsActive[ alarm ] = FALSE;
        }
    }
    else
    {
        SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_ID, alarm )
    }
}

/*********************************************************************//**
 * @brief
 * The isAlarmActive function determines whether a given alarm is currently active.
 * @details Inputs: alarmIsActive[]
 * @details Outputs: none
 * @param alarm ID of alarm to check
 * @return TRUE if given alarm is active, FALSE if not
 *************************************************************************/
BOOL isAlarmActive( ALARM_ID_T alarm )
{
    return alarmIsActive[ alarm ];
}

/*********************************************************************//**
 * @brief
 * The isDGFaultAlarmActive function determines whether a fault alarm is currently
 * active.
 * @details Inputs: alarmStatus
 * @details Outputs: none
 * @return TRUE if any alarm is active, FALSE if not
 *************************************************************************/
BOOL isDGFaultAlarmActive( void )
{
    return isAFaultAlarmActive;
}

/*********************************************************************//**
 * @brief
 * The isAlarmConditionActive function determines whether the condition of
 * a given alarm is currently active.
 * @details Inputs: alarmConditionIsActive[]
 * @details Outputs: none
 * @param alarm ID of alarm to check
 * @return TRUE if given alarm condition is active, FALSE if not
 *************************************************************************/
BOOL isAlarmConditionActive( ALARM_ID_T alarm )
{
    return alarmConditionIsActive[ alarm ];
}

/*********************************************************************//**
 * @brief
 * The publishAlarmInfo function publishes alarm information at the set
 * interval.
 * @details Inputs:
 * @details Outputs: alarm information are published to CAN bus.
 * @return none
 *************************************************************************/
static void publishAlarmInfo( void )
{
    // Publish voltages monitor data on interval
    if ( ++alarmInfoPublicationTimerCounter >= getU32OverrideValue( &alarmInfoPublishInterval ) )
    {
        SAFETY_SHUTDOWN_ACTIVATION_DATA_T data;

        data.safetyShutdownStatus = (U32)isSafetyShutdownActivated();

        broadcastData( MSG_ID_DG_ALARM_INFO_DATA, COMM_BUFFER_OUT_CAN_DG_ALARM, (U08*)&data, sizeof( SAFETY_SHUTDOWN_ACTIVATION_DATA_T ) );
        broadcastCPLDStatus();
        alarmInfoPublicationTimerCounter = 0;
    }
}

/*********************************************************************//**
 * @brief
* The handleResendActiveAlarmsRequest function processes the request to re-send
* all active alarms.
* @details Inputs: alarmIsActive[]
* @details Outputs: re-send active alarms to UI
* @return none
*************************************************************************/
void handleResendActiveAlarmsRequest( void )
{
    U32 index;

    for ( index = 0; index < NUM_OF_ALARM_IDS; index++ )
    {
        if ( TRUE == isAlarmActive( (ALARM_ID_T)index ) )
        {
            broadcastAlarmTriggered( index, BLANK_ALARM_DATA, BLANK_ALARM_DATA );
        }
    }
}

/*********************************************************************//**
 * @brief
* The isAnyCleaningModeInletWaterConditionActive function returns the status
* of any of the inlet water conditions is active or not in a cleaning mode
* @details Inputs: none
* @details Outputs: none
* @return TRUE if any of the inlet water conditions is active otherwise, FALSE
*************************************************************************/
BOOL isAnyCleaningModeInletWaterConditionActive( void )
{
    BOOL status = FALSE;

    status |= isAlarmActive( ALARM_ID_DG_CLEANING_MODE_INLET_WATER_TEMP_TOO_HIGH );
    status |= isAlarmActive( ALARM_ID_DG_CLEANING_MODE_INLET_WATER_TEMP_TOO_LOW );
    status |= isAlarmActive( ALARM_ID_DG_CLEANING_MODE_INLET_WATER_COND_TOO_HIGH );
    status |= isAlarmActive( ALARM_ID_DG_CLEANING_MODE_INLET_WATER_COND_TOO_LOW );
    status |= isAlarmActive( ALARM_ID_DG_CLEANING_MODE_INLET_WATER_PRESSURE_TOO_HIGH );
    status |= isAlarmActive( ALARM_ID_DG_CLEANING_MODE_INLET_WATER_PRESSURE_TOO_LOW );

    return status;
}

/*********************************************************************//**
 * @brief
 * The alarmUserNotify function activates Fault LED and Audio if FAULT exists.
 * @details Inputs: none
 * @details Outputs: LED and Audio control
 * @return none
 *************************************************************************/
static void alarmUserNotify( void )
{
    if ( getCurrentOperationMode() == DG_MODE_FAUL )
    {
        alarmLEDTimer++;
        // Flash Fault LED
        if ( alarmLEDTimer <= ALARM_DG_FAULT_LED_ON_INTERVAL )
        {
            setCPLDFaultLED( PIN_SIGNAL_HIGH, TRUE );   // Set Fault LED
        }
        else if ( alarmLEDTimer <= ALARM_DG_FAULT_LED_OFF_INTERVAL )
        {
            setCPLDFaultLED( PIN_SIGNAL_LOW, TRUE );    // Clear Fault LED
        }
        else
        {
            alarmLEDTimer = 0;  // restart timer
        }

        // If HD COM has failed, sound alarm
        if ( FALSE == isHDCommunicating() )
        {
            setCPLDFaultAudio( PIN_SIGNAL_HIGH );       // Set Fault Audio
        }
        else
        {
            setCPLDFaultAudio( PIN_SIGNAL_LOW );        // Clear Fault Audio
        }
    }
    else
    {
        // No FAULTs
        setCPLDFaultLED( PIN_SIGNAL_LOW, FALSE );       // Clear Fault LED
        setCPLDFaultAudio( PIN_SIGNAL_LOW );            // Clear Fault Audio
    }
}

/*********************************************************************//**
 * @brief
 * The isTransitionToFaultRequired function checks whether the alarm management
 * should request a transition to fault mode immediately or it should be deferred
 * @details Inputs: none
 * @details Outputs: none
 * @return TRUE if transition to fault is required otherwise, FALSE
 *************************************************************************/
static BOOL isTransitionToFaultRequired( void )
{
    BOOL status         = TRUE;
    DG_OP_MODE_T opMode = getCurrentOperationMode();

    switch( opMode )
    {
        case DG_MODE_FLUS:
        case DG_MODE_HEAT:
        case DG_MODE_CHEM:
        case DG_MODE_SERV:
        case DG_MODE_CHFL:
        case DG_MODE_HCOL:
        case DG_MODE_ROPS:
            status = FALSE;
            break;

        default:
            // NOTE: Do nothing for the other modes
            break;
    }

    return status;
}

/*************************************************************************
 *                       TEST SUPPORT FUNCTIONS
 *************************************************************************/


/*********************************************************************//**
 * @brief
 * The testSetAlarmStateOverride function overrides the state of the alarm active
 * state for a given alarm with the alarm management with a given active state.
 * @details Inputs: none
 * @details Outputs: alarm activated or cleared
 * @param alarmID ID of alarm to activate or clear
 * @param value override state for the given alarm ID (1=activate, 0=clear)
 * @return TRUE if override successful, FALSE if not
 *************************************************************************/
BOOL testSetAlarmStateOverride( U32 alarmID, U32 state )
{
    BOOL result = FALSE;

    if ( alarmID < NUM_OF_ALARM_IDS )
    {
        if ( TRUE == isTestingActivated() )
        {
            if ( TRUE == (BOOL)state )
            {
                activateAlarmNoData( (ALARM_ID_T)alarmID );
            }
            else
            {
                clearAlarm( (ALARM_ID_T)alarmID );
            }
            result = TRUE;
        }
    }

    return result;
}

/*********************************************************************//**
 * @brief
 * The testResetAlarmStateOverride function resets the override of the
 * state of the active state for a given alarm with the alarm management.
 * @details Inputs: none
 * @details Outputs: alarm cleared
 * @param alarmID ID of alarm to clear
 * @return TRUE if alarm clear successful, FALSE if not
 *************************************************************************/
BOOL testResetAlarmStateOverride( U32 alarmID )
{
    BOOL result = FALSE;

    if ( alarmID < NUM_OF_ALARM_IDS )
    {
        if ( TRUE == isTestingActivated() )
        {
            result = TRUE;
            clearAlarm( (ALARM_ID_T)alarmID );
        }
    }

    return result;
}

/*********************************************************************//**
 * @brief
 * The testClearAllAlarms function clears all active alarms, even if they
 * are non-recoverable or faults.  The caller of this function must provide
 * the correct 32-bit key.  A Dialin user must also be logged into DG.
 * @details Inputs: none
 * @details Outputs: alarmIsActive[], alarmStartedAt[]
 * @param key 32-bit supervior alarm key required to perform this function
 * @return TRUE if override reset successful, FALSE if not
 *************************************************************************/
BOOL testClearAllAlarms( U32 key )
{
    BOOL result = FALSE;

    // Verify key
    if ( SUPERVISOR_ALARM_KEY == key )
    {
        // Verify tester has logged in with HD
        if ( TRUE == isTestingActivated() )
        {
            ALARM_ID_T a;

            // Clear all active alarms
            for ( a = ALARM_ID_NO_ALARM; a < NUM_OF_ALARM_IDS; a++ )
            {
                if ( TRUE == alarmIsActive[ a ] )
                {
                    ALARM_NAME_DATA_T data;

                    data.alarmName = (U32)a;

                    broadcastData( MSG_ID_ALARM_CLEARED, COMM_BUFFER_OUT_CAN_DG_ALARM, (U08*)&data, sizeof( ALARM_NAME_DATA_T ) );
                    alarmIsActive[ a ] = FALSE;
                }
            }
            result = TRUE;
        }
    }

    return result;
}

/*********************************************************************//**
 * @brief
 * The testSetAlarmInfoPublishIntervalOverride function sets the override of the
 * alarm information publication interval.
 * @details Inputs: none
 * @details Outputs: alarmInfoPublishInterval
 * @param ms milliseconds between alarm info broadcasts
 * @return TRUE if override set successful, FALSE if not
 *************************************************************************/
BOOL testSetAlarmInfoPublishIntervalOverride( U32 ms )
{
    BOOL result = FALSE;

    if ( TRUE == isTestingActivated() )
    {
        U32 intvl = ms / TASK_GENERAL_INTERVAL;

        result = TRUE;
        alarmInfoPublishInterval.ovData = intvl;
        alarmInfoPublishInterval.override = OVERRIDE_KEY;
    }

    return result;
}

/*********************************************************************//**
 * @brief
 * The testResetAlarmInfoPublishIntervalOverride function resets the override of the
 * alarm information publication interval.
 * @details Inputs: none
 * @details Outputs: alarmInfoPublishInterval
 * @return TRUE if override reset successful, FALSE if not
 *************************************************************************/
BOOL testResetAlarmInfoPublishIntervalOverride( void )
{
    BOOL result = FALSE;

    if ( TRUE == isTestingActivated() )
    {
        result = TRUE;
        alarmInfoPublishInterval.override = OVERRIDE_RESET;
        alarmInfoPublishInterval.ovData = alarmInfoPublishInterval.ovInitData;
    }

    return result;
}

/**@}*/