/**************************************************************************
*
* Copyright (c) 2019-2020 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 PersistentAlarm.c
*
* @author (last) Sean Nash
* @date (last) 01-Oct-2020
*
* @author (original) Quang Nguyen
* @date (original) 17-Aug-2020
*
***************************************************************************/

#include "AlarmMgmt.h"
#include "PersistentAlarm.h"
#include "Timers.h"

/**
 *  @addtogroup PersistentAlarm
 *  @{
 */

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

/// Persistent alarm structure
typedef struct
{
    ALARM_ID_T alarm;                               ///< Alarm id

    U32  persistentClearPeriod;                     ///< Persistent count limit before clear alarm
    U32  persistentTriggerPeriod;                   ///< Persistent count limit before trigger alarm

    U32  errorClearedStartTime;                     ///< Error cleared start time
    U32  errorOccurredStartTime;                    ///< Error occurred start time
} PERSISTENT_ALARM_DATA_T;

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

static PERSISTENT_ALARM_DATA_T persistentAlarms[ NUM_OF_ALARM_IDS ];   ///< Array of persistent alarm structure

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

/*********************************************************************//**
 * @brief
 * The initPersistentAlarm function initializes the PersistentAlarm module
 * when the alarm count lower than maximum persistent alarm allowed.
 * @details Inputs: none
 * @details Outputs: PersistentAlarm module initialized
 * @param alarmId Alarm id
 * @param persistentClearPeriod Persistent period limit before clear alarm (in ms)
 * @param persistentTriggerPeriod Persistent period limit before trigger alarm (in ms)
 * @return none
 *************************************************************************/
void initPersistentAlarm( ALARM_ID_T alarmId, U32 persistentClearPeriod, U32 persistentTriggerPeriod )
{
   if ( alarmId < NUM_OF_ALARM_IDS )
   {
       persistentAlarms[ alarmId ].persistentClearPeriod   = persistentClearPeriod;
       persistentAlarms[ alarmId ].persistentTriggerPeriod = persistentTriggerPeriod;
       persistentAlarms[ alarmId ].errorClearedStartTime   = 0U;
       persistentAlarms[ alarmId ].errorOccurredStartTime  = 0U;
   }
   else
   {
#ifdef _DG_
       SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX, alarmId );
#else
       SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX, alarmId );
#endif
   }
}

/*********************************************************************//**
 * @brief
 * The isPersistentAlarmTriggered function checks if the error condition has
 * persisted for given time limit.
 * @details Inputs: persistentAlarms[]
 * @details Outputs: none
 * @param alarmId Alarm id
 * @param isErrorOccurred Flag indicates error condition is occurring or not
 * @return TRUE if error condition persisted over given time limit, FALSE if not
 *************************************************************************/
BOOL isPersistentAlarmTriggered( ALARM_ID_T alarmId, BOOL const isErrorOccurred )
{
    BOOL isAlarmTriggered = FALSE;

    if ( alarmId < NUM_OF_ALARM_IDS )
    {
        // Update start time when error occurs for the first time
        if ( ( TRUE == isErrorOccurred ) && ( persistentAlarms[ alarmId ].errorOccurredStartTime == 0 ) )
        {
            persistentAlarms[ alarmId ].errorOccurredStartTime = getMSTimerCount();
        }

        if ( TRUE == isErrorOccurred )
        {
            isAlarmTriggered = didTimeout( persistentAlarms[ alarmId ].errorOccurredStartTime, persistentAlarms[ alarmId ].persistentTriggerPeriod );
        }
        else
        {
            persistentAlarms[ alarmId ].errorOccurredStartTime = 0;
        }
    }
    else
    {
#ifdef _DG_
        SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX, alarmId );
#else
        SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX, alarmId );
#endif
    }

    return isAlarmTriggered;
}

/*********************************************************************//**
 * @brief
 * The isPersistentAlarmConditionCleared function checks if the error condition has
 * been cleared for given time limit.
 * @details Inputs: persistentAlarms[]
 * @details Outputs: none
 * @param alarmId Alarm id
 * @param isErrorOccurred Flag indicates error condition is occurring or not
 * @return TRUE if error condition has been cleared over given time limit, FALSE if not
 *************************************************************************/
BOOL isPersistentAlarmConditionCleared( ALARM_ID_T alarmId, BOOL const isErrorOccurred )
{
    BOOL isErrorConditionCleared = FALSE;

    if ( alarmId < NUM_OF_ALARM_IDS )
    {
        // Update start time when error condition clears for the first time
        if ( ( FALSE == isErrorOccurred ) && ( persistentAlarms[ alarmId ].errorClearedStartTime == 0 ) )
        {
            persistentAlarms[ alarmId ].errorClearedStartTime = getMSTimerCount();
        }

        if ( FALSE == isErrorOccurred )
        {
            isErrorConditionCleared = didTimeout( persistentAlarms[ alarmId ].errorClearedStartTime, persistentAlarms[ alarmId ].persistentClearPeriod );
        }
        else
        {
            persistentAlarms[ alarmId ].errorClearedStartTime = 0;
        }
    }
    else
    {
#ifdef _DG_
        SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX, alarmId );
#else
        SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX, alarmId );
#endif
    }

    return isErrorConditionCleared;
}

/*********************************************************************//**
 * @brief
 * The resetPersistentAlarmTimer function resets the start time for error
 * condition clear start time and error start time.
 * @details Inputs: none
 * @details Outputs: reset condition clear start time and error occur start time
 * @param alarmId Alarm id of the alarm to reset timer
 * @return none
 *************************************************************************/
void resetPersistentAlarmTimer( ALARM_ID_T alarmId )
{
    persistentAlarms[ alarmId ].errorOccurredStartTime = 0;
    persistentAlarms[ alarmId ].errorClearedStartTime = 0;
}

/**@}*/