#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <MESA/MESA_prof_load.h>

#include "tfe_proxy.h"
#include "tfe_packet_io_fs.h"

enum PACKET_IO_STAT_FIELD
{
    STAT_HIT_INTERCEPT_POLICY,
    STAT_HIT_NO_INTERCEPT_POLICY,
    STAT_CAN_INTERCEPT,

    // dev nf interface
    STAT_RAW_PKT_RX_PKT,
    STAT_RAW_PKT_RX_B,
    STAT_RAW_PKT_TX_PKT,
    STAT_RAW_PKT_TX_B,

    STAT_DECRYPTED_TX_PKT,
    STAT_DECRYPTED_TX_B,
    STAT_DECRYPTED_RX_PKT,
    STAT_DECRYPTED_RX_B,

    STAT_DUP_PKT_BYPASS_PKT,
    STAT_DUP_PKT_BYPASS_B,

    STAT_RAW_PKT_BYPASS_PKT,
    STAT_RAW_PKT_BYPASS_B,

    STAT_DECRYPT_RXDROP_PKT,
    STAT_DECRYPT_RXDROP_B,

    STAT_TAP_RX_PKT,
    STAT_TAP_RX_B,
    STAT_TAP_TX_PKT,
    STAT_TAP_TX_B,
    STAT_TAP_RXDROP_PKT,
    STAT_TAP_RXDROP_B,

    STAT_TAP_C_RX_PKT,
    STAT_TAP_C_RX_B,
    STAT_TAP_C_TX_PKT,
    STAT_TAP_C_TX_B,

    STAT_TAP_S_RX_PKT,
    STAT_TAP_S_RX_B,
    STAT_TAP_S_TX_PKT,
    STAT_TAP_S_TX_B,

    STAT_ASYMMETRIC_NUM,
    STAT_TUNNEL_NUM,
    STAT_TCP_PCY_INVAL_NUM,

    // keepalived packet
    STAT_KEEPALIVED_RX_PKT,
    STAT_KEEPALIVED_RX_B,
    STAT_KEEPALIVED_TX_PKT,
    STAT_KEEPALIVED_TX_B,

    // control packet
    STAT_CONTROL_RX_PKT,
    STAT_CONTROL_RX_B,
    STAT_CONTROL_TX_PKT,
    STAT_CONTROL_TX_B,

    STAT_CTRL_PKT_OPENING,
    STAT_CTRL_PKT_ACTIVE,
    STAT_CTRL_PKT_CLOSING,
    STAT_CTRL_PKT_RESETALL,
    STAT_CTRL_PKT_ERROR,

    STAT_SESSION_NUM,
    STAT_SESSION_LOG,

    // max
    STAT_MAX,
};

static const char *stat_map[] =
{
    // hit policy intercept
    [STAT_HIT_INTERCEPT_POLICY] = "hit_incpt",
    // hit policy no intercept
    [STAT_HIT_NO_INTERCEPT_POLICY] = "hit_no_incpt",

    [STAT_CAN_INTERCEPT] = "can_incpt",

    // dev nf interface
    [STAT_RAW_PKT_RX_PKT] = "raw_rx_pkt",
    [STAT_RAW_PKT_RX_B] = "raw_rx_B",
    [STAT_RAW_PKT_TX_PKT] = "raw_tx_pkt",
    [STAT_RAW_PKT_TX_B] = "raw_tx_B",

    // decrypted
    [STAT_DECRYPTED_TX_PKT] = "decrypt_tx_pkt",
    [STAT_DECRYPTED_TX_B] = "decrypt_tx_B",
    [STAT_DECRYPTED_RX_PKT] = "decrypt_rx_pkt",
    [STAT_DECRYPTED_RX_B] = "decrypt_rx_B",

    [STAT_DUP_PKT_BYPASS_PKT] = "dup_bypass_pkt",
    [STAT_DUP_PKT_BYPASS_B] = "dup_bypass_B",

    [STAT_RAW_PKT_BYPASS_PKT] = "raw_bypass_pkt",
    [STAT_RAW_PKT_BYPASS_B] = "raw_bypass_B",

    [STAT_DECRYPT_RXDROP_PKT] = "dec_rxdrop_pkt",
    [STAT_DECRYPT_RXDROP_B] = "dec_rxdrop_B",

    // tap packet
    [STAT_TAP_RX_PKT] = "tap_rx_pkt",
    [STAT_TAP_RX_B] = "tap_rx_B",
    [STAT_TAP_TX_PKT] = "tap_tx_pkt",
    [STAT_TAP_TX_B] = "tap_tx_B",
    [STAT_TAP_RXDROP_PKT] = "tap_rxdrop_pkt",
    [STAT_TAP_RXDROP_B] = "tap_rxdrop_B",

    // tap_c packet
    [STAT_TAP_C_RX_PKT] = "tap_c_rx_pkt",
    [STAT_TAP_C_RX_B] = "tap_c_rx_B",
    [STAT_TAP_C_TX_PKT] = "tap_c_tx_pkt",
    [STAT_TAP_C_TX_B] = "tap_c_tx_B",

    // tap_s packet
    [STAT_TAP_S_RX_PKT] = "tap_s_rx_pkt",
    [STAT_TAP_S_RX_B] = "tap_s_rx_B",
    [STAT_TAP_S_TX_PKT] = "tap_s_tx_pkt",
    [STAT_TAP_S_TX_B] = "tap_s_tx_B",

    [STAT_ASYMMETRIC_NUM] = "asymmetric",
    [STAT_TUNNEL_NUM] = "tunnel",
    [STAT_TCP_PCY_INVAL_NUM] = "tcp_pcy_inval",

    // keepalived packet
    [STAT_KEEPALIVED_RX_PKT] = "keep_rx_pkt",
    [STAT_KEEPALIVED_RX_B] = "keep_rx_B",
    [STAT_KEEPALIVED_TX_PKT] = "keep_tx_pkt",
    [STAT_KEEPALIVED_TX_B] = "keep_tx_B",

    // control packet
    [STAT_CONTROL_RX_PKT] = "ctrl_rx_pkt",
    [STAT_CONTROL_RX_B] = "ctrl_rx_B",
    [STAT_CONTROL_TX_PKT] = "ctrl_tx_pkt",
    [STAT_CONTROL_TX_B] = "ctrl_tx_B",

    [STAT_CTRL_PKT_OPENING] = "ctrl_pkt_open",
    [STAT_CTRL_PKT_ACTIVE] = "ctrl_pkt_active",
    [STAT_CTRL_PKT_CLOSING] = "ctrl_pkt_close",
    [STAT_CTRL_PKT_RESETALL] = "ctrl_pkt_reset",
    [STAT_CTRL_PKT_ERROR] = "ctrl_pkt_error",

    // send log
    [STAT_SESSION_NUM] = "session_num",
    [STAT_SESSION_LOG] = "session_log",

    [STAT_MAX] = NULL
};

/******************************************************************************
 * throughput_metrics
 ******************************************************************************/

struct packet_io_fs *packet_io_fs_create(const char *profile)
{
    int value=0;
    const char* app_name="packet_io";
    const char* fieldstat_output="log/packet_io.fs2";

    struct packet_io_fs *handle = (struct packet_io_fs *)calloc(1, sizeof(struct packet_io_fs));
    handle->fs_handle=FS_create_handle();
	FS_set_para(handle->fs_handle, APP_NAME, app_name, strlen(app_name)+1);
    FS_set_para(handle->fs_handle, OUTPUT_DEVICE, fieldstat_output, strlen(fieldstat_output)+1);
    value = 1;
    FS_set_para(handle->fs_handle, OUTPUT_PROMETHEUS, &value, sizeof(value));
    value=1;
    FS_set_para(handle->fs_handle, PRINT_MODE, &value, sizeof(value));
    value=0;
    FS_set_para(handle->fs_handle, CREATE_THREAD, &value, sizeof(value));

    for (int i = 0; i < STAT_MAX; i++)
    {
        handle->fs_id[i] = FS_register(handle->fs_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, stat_map[i]);
    }
    FS_start(handle->fs_handle);
    return handle;
}

void packet_io_fs_destory(struct packet_io_fs *handle)
{
    if (handle)
    {
        free(handle);
        handle = NULL;
    }
}

void packet_io_fs_dump(struct packet_io_fs *handle)
{
    if (handle == NULL)
        return;

    FS_operate(handle->fs_handle, handle->fs_id[STAT_HIT_INTERCEPT_POLICY], 0, FS_OP_SET, __atomic_fetch_add(&(handle->hit_intercept_num), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_HIT_NO_INTERCEPT_POLICY], 0, FS_OP_SET, __atomic_fetch_add(&(handle->hit_no_intercept_num), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_CAN_INTERCEPT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->can_intercept_num), 0, __ATOMIC_RELAXED));

    FS_operate(handle->fs_handle, handle->fs_id[STAT_RAW_PKT_RX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->raw_pkt_rx.n_pkts), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_RAW_PKT_RX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->raw_pkt_rx.n_bytes), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_RAW_PKT_TX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->raw_pkt_tx.n_pkts), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_RAW_PKT_TX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->raw_pkt_tx.n_bytes), 0, __ATOMIC_RELAXED));

    FS_operate(handle->fs_handle, handle->fs_id[STAT_DECRYPTED_TX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->decrypt_tx.n_pkts), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_DECRYPTED_TX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->decrypt_tx.n_bytes), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_DECRYPTED_RX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->decrypt_rx.n_pkts), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_DECRYPTED_RX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->decrypt_rx.n_bytes), 0, __ATOMIC_RELAXED));

    FS_operate(handle->fs_handle, handle->fs_id[STAT_DUP_PKT_BYPASS_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->dup_bypass.n_pkts), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_DUP_PKT_BYPASS_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->dup_bypass.n_bytes), 0, __ATOMIC_RELAXED));

    FS_operate(handle->fs_handle, handle->fs_id[STAT_RAW_PKT_BYPASS_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->raw_bypass.n_pkts), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_RAW_PKT_BYPASS_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->raw_bypass.n_bytes), 0, __ATOMIC_RELAXED));

    FS_operate(handle->fs_handle, handle->fs_id[STAT_DECRYPT_RXDROP_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->decrypt_rxdrop.n_pkts), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_DECRYPT_RXDROP_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->decrypt_rxdrop.n_bytes), 0, __ATOMIC_RELAXED));

    FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_RX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_pkt_rx.n_pkts), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_RX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_pkt_rx.n_bytes), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_TX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_pkt_tx.n_pkts), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_TX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_pkt_tx.n_bytes), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_RXDROP_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_pkt_rxdrop.n_pkts), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_RXDROP_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_pkt_rxdrop.n_bytes), 0, __ATOMIC_RELAXED));

    FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_C_RX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_c_pkt_rx.n_pkts), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_C_RX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_c_pkt_rx.n_bytes), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_C_TX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_c_pkt_tx.n_pkts), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_C_TX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_c_pkt_tx.n_bytes), 0, __ATOMIC_RELAXED));

    FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_S_RX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_s_pkt_rx.n_pkts), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_S_RX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_s_pkt_rx.n_bytes), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_S_TX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_s_pkt_tx.n_pkts), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_S_TX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_s_pkt_tx.n_bytes), 0, __ATOMIC_RELAXED));

    FS_operate(handle->fs_handle, handle->fs_id[STAT_ASYMMETRIC_NUM], 0, FS_OP_SET, __atomic_fetch_add(&(handle->asymmetric_num), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_TUNNEL_NUM], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tunnel_num), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_TCP_PCY_INVAL_NUM], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tcp_pcy_inval_num), 0, __ATOMIC_RELAXED));

    // keepalived packet
    FS_operate(handle->fs_handle, handle->fs_id[STAT_KEEPALIVED_RX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->keepalived_pkt_rx.n_pkts), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_KEEPALIVED_RX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->keepalived_pkt_rx.n_bytes), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_KEEPALIVED_TX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->keepalived_pkt_tx.n_pkts), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_KEEPALIVED_TX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->keepalived_pkt_tx.n_bytes), 0, __ATOMIC_RELAXED));

    // control packet
    FS_operate(handle->fs_handle, handle->fs_id[STAT_CONTROL_RX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->ctrl_pkt_rx.n_pkts), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_CONTROL_RX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->ctrl_pkt_rx.n_bytes), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_CONTROL_TX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->ctrl_pkt_tx.n_pkts), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_CONTROL_TX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->ctrl_pkt_tx.n_bytes), 0, __ATOMIC_RELAXED));

    FS_operate(handle->fs_handle, handle->fs_id[STAT_CTRL_PKT_OPENING], 0, FS_OP_SET, __atomic_fetch_add(&(handle->ctrl_pkt_opening_num), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_CTRL_PKT_ACTIVE], 0, FS_OP_SET, __atomic_fetch_add(&(handle->ctrl_pkt_active_num), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_CTRL_PKT_CLOSING], 0, FS_OP_SET, __atomic_fetch_add(&(handle->ctrl_pkt_closing_num), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_CTRL_PKT_RESETALL], 0, FS_OP_SET, __atomic_fetch_add(&(handle->ctrl_pkt_resetall_num), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_CTRL_PKT_ERROR], 0, FS_OP_SET, __atomic_fetch_add(&(handle->ctrl_pkt_error_num), 0, __ATOMIC_RELAXED));

    FS_operate(handle->fs_handle, handle->fs_id[STAT_SESSION_NUM], 0, FS_OP_SET, __atomic_fetch_add(&(handle->session_num), 0, __ATOMIC_RELAXED));
    FS_operate(handle->fs_handle, handle->fs_id[STAT_SESSION_LOG], 0, FS_OP_SET, __atomic_fetch_add(&(handle->session_log), 0, __ATOMIC_RELAXED));
    FS_passive_output(handle->fs_handle);
}