/*
 * Copyright (c) 2013, 2024 Wind River Systems, Inc.
*
* SPDX-License-Identifier: Apache-2.0
*
 */

 /**
  * @file
  * Wind River CGCS Platform common Alarm utilities
  */

#define __MODULE_PRIVATE__

#include "daemon_common.h"   /* for ... daemon_is_file_present */

#include "nodeBase.h"
#include "nodeUtil.h"        /* for ... get_mtclogd_sockPtr    */
#include "alarm.h"           /* for ... alarm Utilities        */


string alarmUtil_getSev_str ( EFmAlarmSeverityT sev )
{
    switch ( sev )
    {
        case FM_ALARM_SEVERITY_CLEAR:   return ("clear");
        case FM_ALARM_SEVERITY_WARNING: return ("warning");
        case FM_ALARM_SEVERITY_MINOR:   return ("minor");
        case FM_ALARM_SEVERITY_MAJOR:   return ("major");
        case FM_ALARM_SEVERITY_CRITICAL:return ("critical");
        default :                       return ("unknown");
    }
}

EFmAlarmSeverityT alarmUtil_getSev_enum ( string sev )
{
   if ( !sev.compare("clear"))    return (FM_ALARM_SEVERITY_CLEAR) ;
   if ( !sev.compare("warning"))  return (FM_ALARM_SEVERITY_WARNING);
   if ( !sev.compare("minor"))    return (FM_ALARM_SEVERITY_MINOR);
   if ( !sev.compare("major"))    return (FM_ALARM_SEVERITY_MAJOR);
   if ( !sev.compare("critical")) return (FM_ALARM_SEVERITY_CRITICAL);
   wlog ("Unsupported severity '%s'\n", sev.c_str() );
   return (FM_ALARM_SEVERITY_CLEAR) ;
}

int alarmUtil_getId_enum ( string alarmid, alarm_id_enum & id )
{
    /* Get the ID */
    if ( alarmid.compare(CLSTR_HB_ALARM_ID) == 0 )
    {
        id = HBS_ALARM_ID__HB_CLSTR ;
    }
    else if ( alarmid.compare(MGMNT_HB_ALARM_ID) == 0 )
    {
        id = HBS_ALARM_ID__HB_MGMNT ;
    }
    else if ( alarmid.compare(PMOND_ALARM_ID) == 0 )
    {
        id = HBS_ALARM_ID__PMOND ;
    }
    else if ( alarmid.compare(SERVICESTATUS_LOG_ID) == 0 )
    {
        id = HBS_ALARM_ID__SERVICE ;
    }
    else
    {
       wlog ("Unsupported alarm id '%s'\n", alarmid.c_str());
       return (FAIL_BAD_PARM);
    }
    return (PASS);
}

/* update the passed in alarm struct's instance_id entity path for the specified host */
void _build_entity_path ( string & hostname, string & instance, SFmAlarmDataT & alarm )
{
    snprintf ( &alarm.entity_type_id[0], FM_MAX_BUFFER_LENGTH, "system.host" );

    if ( instance.empty() )
    {
        snprintf ( &alarm.entity_instance_id[0], FM_MAX_BUFFER_LENGTH, "%s%s",
                    ENTITY_PREFIX, hostname.data());
    }
    else
    {
        snprintf ( &alarm.entity_instance_id[0], FM_MAX_BUFFER_LENGTH, "%s%s.%s",
                    ENTITY_PREFIX, hostname.data(), instance.data());
    }
}

void alarmUtil_clear_all ( string hostname )
{
    SFmAlarmDataT alarm ;
    string instance = "" ;

    _build_entity_path ( hostname, instance, alarm );

    /* This will clear all the alarms for this host ;
     * even ones that are raised against this host by other daemons */
    fm_clear_all ( &alarm.entity_instance_id );
}

/******************************************************************************
 *
 * Name       : alarmUtil_query
 *
 * Description: Utility will query a specific alarm for its current severity
 *
 * @param     : identity may be 200.xxx
 *
 * @param     : instance may be
 *
 *              host=<hostname>
 *
 *                  example:
 *
 *                       hostname=compute-1
 *
 *              host=<hostname>.<function>=<specific>
 *
 *                  example:
 *
 *                       hostname=compute-1.process=mtcClient
 *
 *                       hostname=compute-1.sensor=Fan_PSU2
 *
 * Updates    : None
 *
 * Returns    : FM severity code for the specified alarm.
 *              FM_ALARM_SEVERITY_CLEAR if it not set.
 *
 ******************************************************************************/
EFmAlarmSeverityT alarmUtil_query ( string hostname,
                                    string identity,
                                    string instance )
{
    SFmAlarmDataT alarm_query  ;
    AlarmFilter   alarm_filter ;
    EFmErrorT     rc           ;

    memset(&alarm_query, 0, sizeof(alarm_query));
    memset(&alarm_filter, 0, sizeof(alarm_filter));

    snprintf ( &alarm_filter.alarm_id[0], FM_MAX_BUFFER_LENGTH, "%s", identity.data());

    if ( instance.empty() )
    {
        snprintf ( &alarm_filter.entity_instance_id[0], FM_MAX_BUFFER_LENGTH, "%s%s",
                    ENTITY_PREFIX, hostname.data());
    }
    else
    {
        snprintf ( &alarm_filter.entity_instance_id[0], FM_MAX_BUFFER_LENGTH, "%s%s.%s",
                    ENTITY_PREFIX, hostname.data(), instance.data());
    }

    dlog ("entity_instance:%s\n", alarm_filter.entity_instance_id );
    if (( rc = fm_get_fault ( &alarm_filter, &alarm_query )) == FM_ERR_OK )
    {
        dlog ("Found with Severity: %d\n", alarm_query.severity );
        return (alarm_query.severity) ;
    }
    else if ( rc != FM_ERR_ENTITY_NOT_FOUND )
    {
        elog ("%s fm_get_fault returned error (%d)\n", hostname.c_str(), rc );
    }
    return (FM_ALARM_SEVERITY_CLEAR);
}

int alarmUtil_query_identity ( string identity, SFmAlarmDataT * alarm_list_ptr, unsigned int max_alarms )
{
    int rc = 0 ;

    if ( max_alarms == 0 )
    {
        slog ("max alarms is zero !\n");
    }
    else if ( identity.empty() )
    {
        slog ("empty alarm 'identity'\n");
    }
    else if ( alarm_list_ptr )
    {
        AlarmFilter alarm_filter ;

        memset(&alarm_filter, 0, sizeof(alarm_filter));
        snprintf ( alarm_filter.alarm_id, FM_MAX_BUFFER_LENGTH, "%s", identity.data());
        rc = fm_get_faults_by_id ( &alarm_filter.alarm_id, alarm_list_ptr, &max_alarms );
        dlog ("%s fm_get_faults_by_id rc = %d\n", alarm_filter.alarm_id, rc );
        if ( rc == FM_ERR_OK )
        {
            return (PASS);
        }
        else if ( rc == FM_ERR_ENTITY_NOT_FOUND )
        {
            return (RETRY);
        }
        else
        {
            return (FAIL);
        }
    }
    else
    {
        slog ("caller supplied null alarm_list_ptr\n");
    }
    return (FAIL_NULL_POINTER);
}


/*********************************************************************************
 *
 * Name    : alarmUtil
 *
 * Purpose : Primary module API used to set/clear severity alarms and logs in FM.
 *
 * Description : Other maintenance services are expected to use ths interface to
 *
 *
 ********************************************************************************/

int alarmUtil ( string & hostname,
                string & identity,
                string & instance,
                SFmAlarmDataT & alarm )
{
    int rc = PASS ;

    // msgSock_type * mtclogd_ptr = get_mtclogd_sockPtr() ;

    /* Don't report events while we are in reset mode */
    if ( daemon_is_file_present ( NODE_RESET_FILE ) )
    {
       return (rc);
    }

    _build_entity_path ( hostname, instance, alarm );

#ifdef WANT_ALARM_QUERY

    /* See if the alarm is already in the requested state */
    EFmAlarmSeverityT curr_sev = alarmUtil_query ( hostname, identity, instance ) ;

    /* If its not a log message and we are already at this
     * severity level then ignore the call */
    if (( alarm.alarm_state != FM_ALARM_STATE_MSG ) &&
        ( curr_sev == alarm.severity ))
    {
        ilog ("%s %s %s already at desired (%s) severity level\n",
                  hostname.c_str(),
                  identity.c_str(),
                  instance.c_str(),
                  alarmUtil_getSev_str(alarm.severity).c_str());
        return (rc);
    }
#endif

    snprintf(&alarm.alarm_id[0], FM_MAX_BUFFER_LENGTH, "%s", identity.data());

    if (( alarm.alarm_state == FM_ALARM_STATE_SET ) ||
        ( alarm.alarm_state == FM_ALARM_STATE_MSG ))
    {
        if ( alarm.alarm_state == FM_ALARM_STATE_SET )
        {
            dlog ("%s setting %s %s alarm\n", hostname.c_str(), alarm.alarm_id, alarm.entity_instance_id );
        }
        else
        {
            dlog ("%s creating %s %s log\n", hostname.c_str(), alarm.alarm_id, alarm.entity_instance_id );
        }

        /* Debug Logs */
        dlog ("%s Alarm Reason: %s\n", hostname.c_str(), alarm.reason_text );
        dlog ("%s Alarm Action: %s\n", hostname.c_str(), alarm.proposed_repair_action );
        dlog ("%s Alarm Ident : %s : %s\n", hostname.c_str(), alarm.entity_type_id, alarm.entity_instance_id );
        dlog ("%s Alarm State : state:%d sev:%d type:%d cause:%d sa:%c supp:%c\n",
                  hostname.c_str(),
                  alarm.alarm_state,
                  alarm.severity,
                  alarm.alarm_type,
                  alarm.probable_cause,
                  alarm.service_affecting ? 'Y' : 'N',
                  alarm.suppression ? 'Y' : 'N' );

#ifdef WANT_FIT_TESTING
        if (( daemon_is_file_present ( MTC_CMD_FIT__FM_ERROR_CODE )) &&
            ( daemon_want_fit ( FIT_CODE__FM_SET_ALARM, hostname )))
        {
            rc = daemon_get_file_int(MTC_CMD_FIT__FM_ERROR_CODE) ;
        }
        else
#endif
        {
            rc = fm_set_fault ( &alarm , NULL );
        }
        if ( rc == FM_ERR_OK )
        {
            ilog  ( "%s %s %s alarm raised (%s)",
                        hostname.c_str(),
                        alarm.alarm_id,
                        alarm.entity_instance_id,
                        alarmUtil_getSev_str(alarm.severity).c_str());
        }
        /* error cases are handled/logged in the caller's ; dequeue API */
    }
    else
    {
        AlarmFilter filter ; memset(&filter, 0, sizeof(filter));

        /* Setup the alarm filter */
        snprintf(filter.alarm_id,           FM_MAX_BUFFER_LENGTH, "%s", alarm.alarm_id);
        snprintf(filter.entity_instance_id, FM_MAX_BUFFER_LENGTH, "%s", alarm.entity_instance_id);

        dlog ( "fm_clear_fault: %s %s:%s", hostname.c_str(), alarm.entity_instance_id, alarm.alarm_id );

#ifdef WANT_FIT_TESTING
        if (( daemon_is_file_present ( MTC_CMD_FIT__FM_ERROR_CODE )) &&
            ( daemon_want_fit ( FIT_CODE__FM_CLR_ALARM, hostname )))
        {
            rc = daemon_get_file_int(MTC_CMD_FIT__FM_ERROR_CODE) ;
        }
        else
#endif
        {
            rc = fm_clear_fault ( &filter );
        }

        if ( rc == FM_ERR_OK )
        {
            ilog ("%s %s %s alarm cleared\n",
                      hostname.c_str(),
                      alarm.alarm_id,
                      alarm.entity_instance_id);
        }
        /* error cases are handled/logged in the caller's ; dequeue API */
    }

    return (rc);
}

/* Clear the specified hosts's alarm */
int alarmUtil_clear ( string hostname, string alarm_id , string entity )
{
    alarmUtil_type * alarm_ptr = alarmData_getAlarm_ptr(alarm_id);
    if ( alarm_ptr )
    {
        string instance = alarm_ptr->instc_prefix ;
        instance.append(entity);

        alarm_ptr->alarm.severity    = FM_ALARM_SEVERITY_CLEAR ;
        alarm_ptr->alarm.alarm_state = FM_ALARM_STATE_CLEAR ;
       return ( alarmUtil ( hostname, alarm_id, instance, alarm_ptr->alarm ));
    }
    return (FAIL_NULL_POINTER);
}

/** Assert a specified hosts's alarm with a CRITICAL severity level */
int alarmUtil_critical ( string hostname, string alarm_id , string entity, FMTimeT & timestamp )
{
    alarmUtil_type * alarm_ptr = alarmData_getAlarm_ptr(alarm_id);
    if ( alarm_ptr )
    {
        string instance = alarm_ptr->instc_prefix ;
        instance.append(entity);

        alarm_ptr->alarm.severity    = FM_ALARM_SEVERITY_CRITICAL ;
        alarm_ptr->alarm.alarm_state = FM_ALARM_STATE_SET ;
        if ( timestamp ) alarm_ptr->alarm.timestamp = timestamp ;

        snprintf ( alarm_ptr->alarm.reason_text, FM_MAX_BUFFER_LENGTH, "%s %s", hostname.data(), alarm_ptr->critl_reason.data());

        return ( alarmUtil ( hostname, alarm_id, instance, alarm_ptr->alarm ));
    }
    return (FAIL_NULL_POINTER);
}


/** Assert a specified host's alarm with a MAJOR severity level */
int alarmUtil_major ( string hostname, string alarm_id , string entity, FMTimeT & timestamp )
{
    alarmUtil_type * alarm_ptr = alarmData_getAlarm_ptr(alarm_id);
    if ( alarm_ptr )
    {
        string instance = alarm_ptr->instc_prefix ;
        instance.append(entity);

        alarm_ptr->alarm.severity    = FM_ALARM_SEVERITY_MAJOR ;
        alarm_ptr->alarm.alarm_state = FM_ALARM_STATE_SET ;
        if ( timestamp ) alarm_ptr->alarm.timestamp = timestamp ;

        snprintf ( alarm_ptr->alarm.reason_text, FM_MAX_BUFFER_LENGTH, "%s %s", hostname.data(), alarm_ptr->major_reason.data());

        return ( alarmUtil ( hostname, alarm_id, instance, alarm_ptr->alarm ));
    }
    return (FAIL_NULL_POINTER);
}

/** Assert a specified host's alarm with a MINOR severity level */
int alarmUtil_minor        ( string hostname, string alarm_id , string entity, FMTimeT & timestamp )
{
    alarmUtil_type * alarm_ptr = alarmData_getAlarm_ptr(alarm_id);
    if ( alarm_ptr )
    {
        string instance = alarm_ptr->instc_prefix ;
        instance.append(entity);

        alarm_ptr->alarm.severity    = FM_ALARM_SEVERITY_MINOR ;
        alarm_ptr->alarm.alarm_state = FM_ALARM_STATE_SET ;
        if ( timestamp ) alarm_ptr->alarm.timestamp = timestamp ;

        snprintf ( alarm_ptr->alarm.reason_text, FM_MAX_BUFFER_LENGTH, "%s %s", hostname.data(), alarm_ptr->minor_reason.data());

        return ( alarmUtil ( hostname, alarm_id, instance, alarm_ptr->alarm ));
    }
    return (FAIL_NULL_POINTER);
}

/** Assert a specified host's alarm with a WARNING severity level */
int alarmUtil_warning        ( string hostname, string alarm_id , string entity, FMTimeT & timestamp )
{
    alarmUtil_type * alarm_ptr = alarmData_getAlarm_ptr(alarm_id);
    if ( alarm_ptr )
    {
        string instance = alarm_ptr->instc_prefix ;
        instance.append(entity);

        alarm_ptr->alarm.severity    = FM_ALARM_SEVERITY_WARNING ;
        alarm_ptr->alarm.alarm_state = FM_ALARM_STATE_SET ;
        if ( timestamp ) alarm_ptr->alarm.timestamp = timestamp ;

        snprintf ( alarm_ptr->alarm.reason_text, FM_MAX_BUFFER_LENGTH, "%s %s", hostname.data(), alarm_ptr->minor_reason.data());

        return ( alarmUtil ( hostname, alarm_id, instance, alarm_ptr->alarm ));
    }
    return (FAIL_NULL_POINTER);
}

/** Create CRITICAL log */
int alarmUtil_critical_log ( string hostname, string alarm_id , string entity, FMTimeT & timestamp )
{
    alarmUtil_type * alarm_ptr = alarmData_getAlarm_ptr(alarm_id);
    if ( alarm_ptr )
    {
        string instance = alarm_ptr->instc_prefix ;
        instance.append(entity);

        alarm_ptr->alarm.severity    = FM_ALARM_SEVERITY_CRITICAL ;
        alarm_ptr->alarm.alarm_state = FM_ALARM_STATE_MSG ;
        if ( timestamp ) alarm_ptr->alarm.timestamp = timestamp ;

        snprintf ( alarm_ptr->alarm.reason_text, FM_MAX_BUFFER_LENGTH, "%s %s", hostname.data(), alarm_ptr->critl_reason.data());

        return ( alarmUtil ( hostname, alarm_id, instance, alarm_ptr->alarm ));
    }
    return (FAIL_NULL_POINTER);
}


/** Create MAJOR log */
int alarmUtil_major_log ( string hostname, string alarm_id , string entity, FMTimeT & timestamp )
{
    alarmUtil_type * alarm_ptr = alarmData_getAlarm_ptr(alarm_id);
    if ( alarm_ptr )
    {
        string instance = alarm_ptr->instc_prefix ;
        instance.append(entity);

        alarm_ptr->alarm.severity    = FM_ALARM_SEVERITY_MAJOR ;
        alarm_ptr->alarm.alarm_state = FM_ALARM_STATE_MSG ;
        if ( timestamp ) alarm_ptr->alarm.timestamp = timestamp ;

        snprintf ( alarm_ptr->alarm.reason_text, FM_MAX_BUFFER_LENGTH, "%s %s", hostname.data(), alarm_ptr->major_reason.data());

        return ( alarmUtil ( hostname, alarm_id, instance, alarm_ptr->alarm ));
    }
    return (FAIL_NULL_POINTER);
}
/** Create MINOR log */
int alarmUtil_minor_log        ( string hostname, string alarm_id , string entity, FMTimeT & timestamp )
{
    alarmUtil_type * alarm_ptr = alarmData_getAlarm_ptr(alarm_id);
    if ( alarm_ptr )
    {
        string instance = alarm_ptr->instc_prefix ;
        instance.append(entity);

        alarm_ptr->alarm.severity    = FM_ALARM_SEVERITY_MINOR ;
        alarm_ptr->alarm.alarm_state = FM_ALARM_STATE_MSG ;
        if ( timestamp ) alarm_ptr->alarm.timestamp = timestamp ;

        snprintf ( alarm_ptr->alarm.reason_text, FM_MAX_BUFFER_LENGTH, "%s %s", hostname.data(), alarm_ptr->minor_reason.data());

        return ( alarmUtil ( hostname, alarm_id, instance, alarm_ptr->alarm ));
    }
    return (FAIL_NULL_POINTER);
}

/** Create WARNING log */
int alarmUtil_warning_log ( string hostname, string alarm_id, string entity, string prefix, FMTimeT & timestamp )
{
    alarmUtil_type * alarm_ptr = alarmData_getAlarm_ptr(alarm_id);
    if ( alarm_ptr )
    {
        string instance = alarm_ptr->instc_prefix ;
        instance.append(prefix);

        alarm_ptr->alarm.severity    = FM_ALARM_SEVERITY_WARNING ;
        alarm_ptr->alarm.alarm_state = FM_ALARM_STATE_MSG ;
        if ( timestamp ) alarm_ptr->alarm.timestamp = timestamp ;

        snprintf ( alarm_ptr->alarm.reason_text, FM_MAX_BUFFER_LENGTH, "%s %s", hostname.data(), entity.data());

        return ( alarmUtil ( hostname, alarm_id, instance, alarm_ptr->alarm ));
    }
    return (FAIL_NULL_POINTER);
}