#ifndef _PACKET_TRACE_H
#define _PACKET_TRACE_H

#ifdef __cpluscplus
extern "C"
{
#endif

#include "utils.h"
#include "policy.h"

#include <marsio.h>

/*
 * SCE packet trace info format
 *
 * PACKET_TRACE_ON_NEW       : "(Packet I/O) new packet"
 * PACKET_TRACE_ON_FREE      : "(Packet I/O) free packet"
 * PACKET_TRACE_ON_CTRL      : "(Session Synchronization) ${MSG}"
 *
 * Service Function Path (SFP) https://datatracker.ietf.org/doc/html/rfc7665
 *
 * PACKET_TRACE_ON_POLICY    : "(Policy) rule_list: [${Rule_ID1}, ${Rule_ID2}, ...], SFP_list: [${SF_ID1}, ${SF_ID2}, ...]"
 * PACKET_TRACE_ON_CHAIN     : "(Forwarder) SF_id: ${SF_ID}, fwd_type: ${FWD_TYPE}, pkt_dir: ${PKT_DIR}, pkt_type: ${PKT_TYPE}, state: ${STATE} ${ACTION}"
 *
 * ${FWD_TYPE}
 *      steering
 *      mirroring
 *
 * ${PKT_DIR}
 *     I2E
 *     E2I
 *
 * ${PKT_TYPE}
 *      raw
 *      decrypted
 *
 * ${STATE}
 *      success
 *      failure
 *
 * ${ACTION}
 *      bypass
 *      block
 *      re-dispatch block
 *      re-dispatch bypass
 *      re-dispatch bypass(health SF limit)
 *
 *      bypass(default)
 *      bypass(invalid policy)
 */

static inline int rule_id_tostring(struct mutable_array *rule_ids, char *buffer, int size)
{
    int used = 0;
    used += snprintf(buffer + used, size - used, "[");
    for (int i = 0; i < rule_ids->num; i++)
    {
        used += snprintf(buffer + used, size - used, "%lu", rule_ids->elems[i]);
        if (i < rule_ids->num - 1)
        {
            used += snprintf(buffer + used, size - used, ", ");
        }
    }
    used += snprintf(buffer + used, size - used, "]");
    return used;
}

static inline int sf_id_tostring(struct selected_chaining *chain, char *buffer, int size)
{
    int used = 0;
    used += snprintf(buffer + used, size - used, "[");
    for (int i = 0; i < chain->chaining_used; i++)
    {
        used += snprintf(buffer + used, size - used, "%d", chain->chaining[i].sf_profile_id);
        if (i < chain->chaining_used - 1)
        {
            used += snprintf(buffer + used, size - used, ", ");
        }
    }
    used += snprintf(buffer + used, size - used, "]");
    return used;
}

#define PACKET_TRACE_ON_NEW(mr_ins, mr_buff)                                                                                      \
    do                                                                                                                            \
    {                                                                                                                             \
        marsio_dp_trace_filter_exec(mr_ins, mr_buff);                                                                             \
        if (marsio_dp_trace_measurements_can_emit(mr_ins, mr_buff))                                                               \
        {                                                                                                                         \
            marsio_dp_trace_measurement_emit_str(mr_ins, mr_buff, DP_TRACE_MEASUREMENT_TYPE_TRACE, "(Packet I/O)", "new packet"); \
        }                                                                                                                         \
    } while (0)

#define PACKET_TRACE_ON_FREE(mr_ins, mr_buff)                                                                                      \
    do                                                                                                                             \
    {                                                                                                                              \
        if (marsio_dp_trace_measurements_can_emit(mr_ins, mr_buff))                                                                \
        {                                                                                                                          \
            marsio_dp_trace_measurement_emit_str(mr_ins, mr_buff, DP_TRACE_MEASUREMENT_TYPE_TRACE, "(Packet I/O)", "free packet"); \
        }                                                                                                                          \
    } while (0)

#define PACKET_TRACE_ON_CTRL(mr_ins, mr_buff, state)                                                                            \
    do                                                                                                                          \
    {                                                                                                                           \
        if (marsio_dp_trace_measurements_can_emit(mr_ins, mr_buff))                                                             \
        {                                                                                                                       \
            marsio_dp_trace_measurement_emit_str(mr_ins, mr_buff, DP_TRACE_MEASUREMENT_TYPE_TRACE, "(Session Synchronization)", \
                                                 control_packte_state_to_string(state));                                        \
        }                                                                                                                       \
    } while (0)

#define PACKET_TRACE_ON_POLICY(mr_ins, mr_buff, rule_ids, chain)                                                          \
    do                                                                                                                    \
    {                                                                                                                     \
        if (marsio_dp_trace_measurements_can_emit(mr_ins, mr_buff))                                                       \
        {                                                                                                                 \
            char rule_id_str[1024] = {0};                                                                                 \
            char sf_id_str[1024] = {0};                                                                                   \
            char buff[4096] = {0};                                                                                        \
            rule_id_tostring(rule_ids, rule_id_str, sizeof(rule_id_str));                                                 \
            sf_id_tostring(chain, sf_id_str, sizeof(sf_id_str));                                                          \
            snprintf(buff, sizeof(buff), "rule_list: %s, SFP_list: %s", rule_id_str, sf_id_str);                          \
            marsio_dp_trace_measurement_emit_str(mr_ins, mr_buff, DP_TRACE_MEASUREMENT_TYPE_TRACE, "(Policy)", buff);     \
            marsio_dp_trace_measurement_emit_str(mr_ins, mr_buff, DP_TRACE_MEASUREMENT_TYPE_TELEMETRY, "(Policy)", buff); \
        }                                                                                                                 \
    } while (0)

#define PACKET_TRACE_ON_CHAIN(mr_ins, mr_buff, sf, meta)                                                                     \
    do                                                                                                                       \
    {                                                                                                                        \
        if (marsio_dp_trace_measurements_can_emit(mr_ins, mr_buff))                                                          \
        {                                                                                                                    \
            char buff[2048] = {0};                                                                                           \
            snprintf(buff, sizeof(buff), "SF_id: %d, fwd_type: %s, pkt_dir: %s, pkt_type: %s, state: %s %s",                 \
                     (sf)->sf_profile_id,                                                                                    \
                     forward_type_tostring((sf)->sff_forward_type),                                                          \
                     ((meta)->direction ? "E2I" : "I2E"),                                                                    \
                     ((meta)->is_decrypted ? "decrypted" : "raw"),                                                           \
                     ((sf)->sf_action == SESSION_ACTION_FORWARD ? "success" : "failure"),                                    \
                     ((sf)->sf_action == SESSION_ACTION_FORWARD ? "" : action_desc_tostring((sf)->sf_action_desc)));         \
            marsio_dp_trace_measurement_emit_str(mr_ins, mr_buff, DP_TRACE_MEASUREMENT_TYPE_TRACE, "(Forwarder)", buff);     \
            marsio_dp_trace_measurement_emit_str(mr_ins, mr_buff, DP_TRACE_MEASUREMENT_TYPE_TELEMETRY, "(Forwarder)", buff); \
        }                                                                                                                    \
    } while (0)

#ifdef __cpluscplus
}
#endif

#endif