/**************************************************************************
*
* 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
    BOOL       isClearable;                         ///< Flag if alarm can be cleared

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

    U32  inRangeStartTime;                          ///< Data in range persistent counter
    U32  outOfRangeStartTime;                       ///< Data out of range persistent counter
} PERSISTENT_ALARM_DATA_T;

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

static PERSISTENT_ALARM_DATA_T persistentAlarms[ NUM_OF_PERSISTENT_ALARM ];   ///< 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 alarmIndex Persistent alarm index
 * @param alarm Alarm id
 * @param isClearable Flag to indicate alarm is clearable or not
 * @param persistentClearPeriod Persistent period limit before clear alarm (in ms)
 * @param persistentTriggerPeriod Persistent period limit before trigger alarm (in ms)
 * @return none
 *************************************************************************/
void initPersistentAlarm( PERSISTENT_ALARM_T alarmIndex, ALARM_ID_T alarm, BOOL isClearable,
                          U32 persistentClearPeriod, U32 persistentTriggerPeriod )
{
    if ( alarmIndex < NUM_OF_PERSISTENT_ALARM )
    {
        persistentAlarms[ alarmIndex ].alarm                   = alarm;
        persistentAlarms[ alarmIndex ].isClearable             = isClearable;
        persistentAlarms[ alarmIndex ].persistentClearPeriod   = persistentClearPeriod;
        persistentAlarms[ alarmIndex ].persistentTriggerPeriod = persistentTriggerPeriod;
        persistentAlarms[ alarmIndex ].inRangeStartTime        = 0U;
        persistentAlarms[ alarmIndex ].outOfRangeStartTime     = 0U;
    }
    else
    {
#ifdef _DG_
        SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX, alarmIndex );
#else
        SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX, alarmIndex );
#endif
    }
}

/*********************************************************************//**
 * @brief
 * The checkPersistentAlarm function check whether data is out of range or
 * not. Then the function set or clear alarm once the persistent counter
 * exceeds the limit.
 * @details Inputs: none
 * @details Outputs: Checks for out of range data and set/clear alarm
 * @param alarmIndex Persistent alarm index
 * @param isOutOfRange Flag indicates data out of range
 * @param data Data to be check for out of range
 * @param limit Upper or lower limit that data exceeded
 * @return none
 *************************************************************************/
void checkPersistentAlarm( PERSISTENT_ALARM_T const alarmIndex, BOOL const isOutOfRange, F32 const data, F32 const limit )
{
    if ( alarmIndex < NUM_OF_PERSISTENT_ALARM )
    {
        if ( isOutOfRange )
        {
            persistentAlarms[ alarmIndex ].inRangeStartTime = 0;
            if ( persistentAlarms[ alarmIndex ].outOfRangeStartTime == 0 )
            {
                persistentAlarms[ alarmIndex ].outOfRangeStartTime = getMSTimerCount();
            }
            if ( didTimeout( persistentAlarms[ alarmIndex ].outOfRangeStartTime, persistentAlarms[ alarmIndex ].persistentTriggerPeriod ) )
            {
                SET_ALARM_WITH_2_F32_DATA( persistentAlarms[ alarmIndex ].alarm, data, limit );
            }
        }
        else
        {
            persistentAlarms[ alarmIndex ].outOfRangeStartTime = 0;
            if ( persistentAlarms[ alarmIndex ].inRangeStartTime == 0 )
            {
                persistentAlarms[ alarmIndex ].inRangeStartTime = getMSTimerCount();
            }
            BOOL const isInRangePersistent = didTimeout( persistentAlarms[ alarmIndex ].inRangeStartTime, persistentAlarms[ alarmIndex ].persistentClearPeriod );
            if ( persistentAlarms[ alarmIndex ].isClearable && isInRangePersistent )
            {
                clearAlarmCondition( persistentAlarms[ alarmIndex ].alarm );
            }
        }
    }
    else
    {
#ifdef _DG_
        SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX, alarmIndex );
#else
        SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX, alarmIndex );
#endif
    }
}

/**@}*/