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

#include "log.h"
#include "utils.h"

enum STAT_FIELD
{
    STAT_RX_PKT,
    STAT_RX_B,

    STAT_RX_ERR_PKT,
    STAT_RX_ERR_B,

    STAT_SUCC_TX_V4_PKT,
    STAT_SUCC_TX_V4_B,

    STAT_SUCC_TX_V6_PKT,
    STAT_SUCC_TX_V6_B,

    STAT_ERR_TX_V4_PKT,
    STAT_ERR_TX_V4_B,

    STAT_ERR_TX_V6_PKT,
    STAT_ERR_TX_V6_B,

    STAT_MAX,
};

static const char *stat_map[] =
    {
        [STAT_RX_PKT] = "nf_rx_pkt",
        [STAT_RX_B] = "nf_rx_B",

        [STAT_RX_ERR_PKT] = "rx_err_pkt",
        [STAT_RX_ERR_B] = "rx_err_B",

        [STAT_SUCC_TX_V4_PKT] = "succ_tx_4_pkt",
        [STAT_SUCC_TX_V4_B] = "succ_tx_4_B",

        [STAT_SUCC_TX_V6_PKT] = "succ_tx_6_pkt",
        [STAT_SUCC_TX_V6_B] = "succ_tx_6_B",

        [STAT_ERR_TX_V4_PKT] = "err_tx_4_pkt",
        [STAT_ERR_TX_V4_B] = "err_tx_4_B",

        [STAT_ERR_TX_V6_PKT] = "err_tx_6_pkt",
        [STAT_ERR_TX_V6_B] = "err_tx_6_B",

        [STAT_MAX] = NULL};

struct stat_config
{
    char output_file[256];
    int statsd_cycle;
};

struct packet_stat
{
    struct stat_config config;
    struct fieldstat_easy *fs_handle;
    int fs_id[512];
};

static void packet_stat_config(const char *profile, struct stat_config *config)
{
    MESA_load_profile_string_def(profile, "STAT", "output_file", config->output_file, sizeof(config->output_file), "log/packet_adapter.fs2");
    MESA_load_profile_int_def(profile, "STAT", "statsd_cycle", &(config->statsd_cycle), 1);

    LOG_DEBUG("STAT->output_file            : %s", config->output_file);
    LOG_DEBUG("STAT->statsd_cycle           : %d", config->statsd_cycle);
}

void packet_stat_destory(struct packet_stat *handle)
{
    if (handle)
    {
        if (handle->fs_handle)
        {
            fieldstat_easy_free(handle->fs_handle);
            handle->fs_handle = NULL;
        }

        free(handle);
        handle = NULL;
    }
}

struct packet_stat *packet_stat_create(const char *profile)
{
    struct packet_stat *handle = (struct packet_stat *)calloc(1, sizeof(struct packet_stat));
    assert(handle != NULL);

    packet_stat_config(profile, &handle->config);

    handle->fs_handle = fieldstat_easy_new(1, "packet_adapter", NULL, 0);
    if (handle->fs_handle == NULL)
    {
        LOG_ERROR("fieldstat_easy_new failed");
        goto error_out;
    }

    if (fieldstat_easy_enable_auto_output(handle->fs_handle, handle->config.output_file, handle->config.statsd_cycle) != 0)
    {
        LOG_ERROR("fieldstat_easy_enable_auto_output failed");
        goto error_out;
    }

    for (int i = 0; i < STAT_MAX; i++)
    {
        handle->fs_id[i] = fieldstat_easy_register_counter(handle->fs_handle, stat_map[i]);
    }

    return handle;

error_out:
    packet_stat_destory(handle);
    return NULL;
}

void packet_stat_flush(struct packet_stat *handle, struct metrics *metrics)
{
    static struct metrics last_metrics = {0};
    struct metrics curr_metrics = {
        .rx_pkts = ATOMIC_READ(&(metrics->rx_pkts)),
        .rx_bytes = ATOMIC_READ(&(metrics->rx_bytes)),
        .rx_err_pkts = ATOMIC_READ(&(metrics->rx_err_pkts)),
        .rx_err_bytes = ATOMIC_READ(&(metrics->rx_err_bytes)),
        .succ_tx_v4_pkts = ATOMIC_READ(&(metrics->succ_tx_v4_pkts)),
        .succ_tx_v4_bytes = ATOMIC_READ(&(metrics->succ_tx_v4_bytes)),
        .succ_tx_v6_pkts = ATOMIC_READ(&(metrics->succ_tx_v6_pkts)),
        .succ_tx_v6_bytes = ATOMIC_READ(&(metrics->succ_tx_v6_bytes)),
        .err_tx_v4_pkts = ATOMIC_READ(&(metrics->err_tx_v4_pkts)),
        .err_tx_v4_bytes = ATOMIC_READ(&(metrics->err_tx_v4_bytes)),
        .err_tx_v6_pkts = ATOMIC_READ(&(metrics->err_tx_v6_pkts)),
        .err_tx_v6_bytes = ATOMIC_READ(&(metrics->err_tx_v6_bytes)),
    };

    fieldstat_easy_counter_incrby(handle->fs_handle, 0, handle->fs_id[STAT_RX_PKT], NULL, 0, curr_metrics.rx_pkts - last_metrics.rx_pkts);
    fieldstat_easy_counter_incrby(handle->fs_handle, 0, handle->fs_id[STAT_RX_B], NULL, 0, curr_metrics.rx_bytes - last_metrics.rx_bytes);

    fieldstat_easy_counter_incrby(handle->fs_handle, 0, handle->fs_id[STAT_RX_ERR_PKT], NULL, 0, curr_metrics.rx_err_pkts - last_metrics.rx_err_pkts);
    fieldstat_easy_counter_incrby(handle->fs_handle, 0, handle->fs_id[STAT_RX_ERR_B], NULL, 0, curr_metrics.rx_err_bytes - last_metrics.rx_err_bytes);

    fieldstat_easy_counter_incrby(handle->fs_handle, 0, handle->fs_id[STAT_SUCC_TX_V4_PKT], NULL, 0, curr_metrics.succ_tx_v4_pkts - last_metrics.succ_tx_v4_pkts);
    fieldstat_easy_counter_incrby(handle->fs_handle, 0, handle->fs_id[STAT_SUCC_TX_V4_B], NULL, 0, curr_metrics.succ_tx_v4_bytes - last_metrics.succ_tx_v4_bytes);

    fieldstat_easy_counter_incrby(handle->fs_handle, 0, handle->fs_id[STAT_SUCC_TX_V6_PKT], NULL, 0, curr_metrics.succ_tx_v6_pkts - last_metrics.succ_tx_v6_pkts);
    fieldstat_easy_counter_incrby(handle->fs_handle, 0, handle->fs_id[STAT_SUCC_TX_V6_B], NULL, 0, curr_metrics.succ_tx_v6_bytes - last_metrics.succ_tx_v6_bytes);

    fieldstat_easy_counter_incrby(handle->fs_handle, 0, handle->fs_id[STAT_ERR_TX_V4_PKT], NULL, 0, curr_metrics.err_tx_v4_pkts - last_metrics.err_tx_v4_pkts);
    fieldstat_easy_counter_incrby(handle->fs_handle, 0, handle->fs_id[STAT_ERR_TX_V4_B], NULL, 0, curr_metrics.err_tx_v4_bytes - last_metrics.err_tx_v4_bytes);

    fieldstat_easy_counter_incrby(handle->fs_handle, 0, handle->fs_id[STAT_ERR_TX_V6_PKT], NULL, 0, curr_metrics.err_tx_v6_pkts - last_metrics.err_tx_v6_pkts);
    fieldstat_easy_counter_incrby(handle->fs_handle, 0, handle->fs_id[STAT_ERR_TX_V6_B], NULL, 0, curr_metrics.err_tx_v6_bytes - last_metrics.err_tx_v6_bytes);

    last_metrics = curr_metrics;
}