/**************************************************************************
*
* Copyright (c) 2020-2022 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)      Dara Navaei
* @date    (last)      06-Jul-2022
*
* @author  (original)  Sean
* @date    (original)  04-Feb-2020
*
***************************************************************************/

#define __ALARM_MGMT_C__

#include "AlarmMgmt.h"
#include "OperationModes.h"
#include "PersistentAlarm.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.

// *** 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 ) ];

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.
/// 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 );

/*********************************************************************//**
 * @brief
 * The initAlarmMgmt function initializes the AlarmMgmt module.
 * @details Inputs: none
 * @details Outputs: AlarmMgmt module initialized.
 * @return none
 *************************************************************************/
void initAlarmMgmt( void )
{
    ALARM_ID_T alrm;

    alarmInfoPublicationTimerCounter = DATA_PUBLISH_COUNTER_START_COUNT;

    // 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 )
{
    // TODO - any alarm audio or LED/lamp management for DG?

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

/*********************************************************************//**
 * @brief
 * The activateAlarm function activates a given alarm.
 * @details Inputs: none
 * @details Outputs: alarmIsActive[]
 * @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 alarm is a DG fault, request transition to fault mode
            if ( ( TRUE == ALARM_TABLE[ alarm ].alarmIsDGFault ) && ( getCurrentOperationMode() != DG_MODE_SERV ) )
            {
                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 );
}

/*********************************************************************//**
 * @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 );
}

/*********************************************************************//**
 * @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
 * @return none
 *************************************************************************/
void activateAlarm2Data( ALARM_ID_T alarm, ALARM_DATA_T alarmData1, ALARM_DATA_T alarmData2 )
{
    // 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
        if ( TRUE == alarmIsActive[ alarm ] )
        {
            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 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, COMM_BUFFER_OUT_CAN_DG_ALARM, (U08*)&data, sizeof( SAFETY_SHUTDOWN_ACTIVATION_DATA_T ) );
        alarmInfoPublicationTimerCounter = 0;
    }
}

/*********************************************************************//**
 * @brief
 * The checkPersistentAlarm function triggers/clears an alarm if an alarm condition
 * has persisted/cleared over given time limit.
 * @details Inputs: none
 * @details Outputs: checks whether an alarm is triggered or an alarm condition is cleared
 * @param alarmID ID of alarm to check
 * @param isErrorOccured Flag indicates alarm condition is active or not
 * @param data alarm data
 * @param limit alarm condition limit
 * @return TRUE if given alarm is active, FALSE if not
 *************************************************************************/
BOOL checkPersistentAlarm( ALARM_ID_T alarm, BOOL const isErrorOccured, F32 const data, F32 const limit )
{
    BOOL status = FALSE;

    if ( TRUE == isPersistentAlarmTriggered( alarm, isErrorOccured ) )
    {
        SET_ALARM_WITH_2_F32_DATA( alarm, data, limit );
    }

    if ( TRUE == isPersistentAlarmConditionCleared( alarm, isErrorOccured ) )
    {
        clearAlarmCondition( alarm );
        status = TRUE;
    }

    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;
}

/**@}*/