#include <errno.h>
#include <stdlib.h>
#include <string.h>

#include "config.h"
#include "toml.h"

// return  0: success
// retuun -1: failed
static int parse_device_options(toml_table_t *table, struct device_options *opts)
{
    const char *ptr;
    toml_table_t *device;

    device = toml_table_in(table, "device");
    if (device == NULL)
    {
        CONFIG_LOG_ERROR("config file missing device section");
        return -1;
    }

    ptr = toml_raw_in(device, "device_base");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing device.device_base");
        return -1;
    }
    opts->device_base = atoi(ptr);

    ptr = toml_raw_in(device, "device_offset");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing device.device_offset");
        return -1;
    }
    opts->device_offset = atoi(ptr);

    return 0;
}

// return  0: success
// retuun -1: failed
static int parse_packet_io_options(toml_table_t *table, struct packet_io_options *opts)
{
    const char *ptr;
    toml_table_t *packet_io;
    toml_array_t *mask_array;

    packet_io = toml_table_in(table, "packet_io");
    if (packet_io == NULL)
    {
        CONFIG_LOG_ERROR("config file missing packet_io section");
        return -1;
    }

    ptr = toml_raw_in(packet_io, "mode");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing packet_io.mode");
        return -1;
    }
    if (strcmp(ptr, "dumpfile") == 0)
    {
        opts->mode = PACKET_IO_DUMPFILE;
    }
    else if (strcmp(ptr, "marsio") == 0)
    {
        opts->mode = PACKET_IO_MARSIO;
    }
    else
    {
        CONFIG_LOG_ERROR("config file invalid packet_io.mode %s, only support dumpfile and marsio", ptr);
        return -1;
    }

    if (opts->mode == PACKET_IO_DUMPFILE)
    {
        ptr = toml_raw_in(packet_io, "dumpfile_dir");
        if (ptr == NULL)
        {
            CONFIG_LOG_ERROR("config file missing packet_io.dumpfile_dir");
            return -1;
        }
        // skip ""
        strncpy(opts->dumpfile_dir, ptr + 1, strlen(ptr) - 2);
    }
    else
    {
        ptr = toml_raw_in(packet_io, "app_symbol");
        if (ptr == NULL)
        {
            CONFIG_LOG_ERROR("config file missing packet_io.app_symbol");
            return -1;
        }
        strncpy(opts->app_symbol, ptr, sizeof(opts->app_symbol) - 1);

        ptr = toml_raw_in(packet_io, "dev_symbol");
        if (ptr == NULL)
        {
            CONFIG_LOG_ERROR("config file missing packet_io.dev_symbol");
            return -1;
        }
        strncpy(opts->dev_symbol, ptr, sizeof(opts->dev_symbol) - 1);
    }

    ptr = toml_raw_in(packet_io, "nr_threads");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing packet_io.nr_threads");
        return -1;
    }
    if (atoi(ptr) <= 0 || atoi(ptr) > MAX_THREAD_NUM)
    {
        CONFIG_LOG_ERROR("config file invalid packet_io.nr_threads %d, range [1, %d]", atoi(ptr), MAX_THREAD_NUM);
        return -1;
    }
    opts->nr_threads = atoi(ptr);

    mask_array = toml_array_in(packet_io, "cpu_mask");
    if (mask_array == NULL)
    {
        CONFIG_LOG_ERROR("config file missing packet_io.cpu_mask");
        return -1;
    }
    for (uint8_t i = 0; i < opts->nr_threads; i++)
    {
        ptr = toml_raw_at(mask_array, i);
        if (ptr == NULL)
        {
            CONFIG_LOG_ERROR("config file missing packet_io.cpu_mask[%d]", i);
            return -1;
        }
        opts->cpu_mask[i] = atoi(ptr);
    }

    return 0;
}

// return  0: success
// retuun -1: failed
static int parse_ip_reassembly_options(toml_table_t *table, struct ip_reassembly_options *opts)
{
    const char *ptr;
    toml_table_t *ip_reassembly;

    ip_reassembly = toml_table_in(table, "ip_reassembly");
    if (ip_reassembly == NULL)
    {
        CONFIG_LOG_ERROR("config file missing ip_reassembly section");
        return -1;
    }

    ptr = toml_raw_in(ip_reassembly, "enable");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing ip_reassembly.enable");
        return -1;
    }
    opts->enable = atoi(ptr);

    ptr = toml_raw_in(ip_reassembly, "timeout");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing ip_reassembly.timeout");
        return -1;
    }
    opts->timeout = atoi(ptr);

    ptr = toml_raw_in(ip_reassembly, "bucket_entries");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing ip_reassembly.bucket_entries");
        return -1;
    }
    opts->bucket_entries = atoi(ptr);

    ptr = toml_raw_in(ip_reassembly, "bucket_num");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing ip_reassembly.bucket_num");
        return -1;
    }
    opts->bucket_num = atoi(ptr);

    return 0;
}

// return  0: success
// retuun -1: failed
static int parse_session_manager_options(toml_table_t *table, struct session_manager_options *opts)
{
    const char *ptr;
    toml_table_t *session_manager;

    session_manager = toml_table_in(table, "session_manager");
    if (session_manager == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager section");
        return -1;
    }

    // max session number
    ptr = toml_raw_in(session_manager, "max_tcp_session_num");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.max_tcp_session_num");
        return -1;
    }
    opts->max_tcp_session_num = atoll(ptr);

    ptr = toml_raw_in(session_manager, "max_udp_session_num");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.max_udp_session_num");
        return -1;
    }
    opts->max_udp_session_num = atoll(ptr);

    // session overload (1: evict old session, 0: bypass new session)
    ptr = toml_raw_in(session_manager, "tcp_overload_evict_old_sess");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.tcp_overload_evict_old_sess");
        return -1;
    }
    opts->tcp_overload_evict_old_sess = atoi(ptr);

    ptr = toml_raw_in(session_manager, "udp_overload_evict_old_sess");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.udp_overload_evict_old_sess");
        return -1;
    }
    opts->udp_overload_evict_old_sess = atoi(ptr);

    // TCP timeout
    ptr = toml_raw_in(session_manager, "tcp_timeout_init");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.tcp_timeout_init");
        return -1;
    }
    opts->tcp_timeout_init = atoll(ptr);

    ptr = toml_raw_in(session_manager, "tcp_timeout_handshake");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.tcp_timeout_handshake");
        return -1;
    }
    opts->tcp_timeout_handshake = atoll(ptr);

    ptr = toml_raw_in(session_manager, "tcp_timeout_data");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.tcp_timeout_data");
        return -1;
    }
    opts->tcp_timeout_data = atoll(ptr);

    ptr = toml_raw_in(session_manager, "tcp_timeout_half_closed");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.tcp_timeout_half_closed");
        return -1;
    }
    opts->tcp_timeout_half_closed = atoll(ptr);

    ptr = toml_raw_in(session_manager, "tcp_timeout_time_wait");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.tcp_timeout_time_wait");
        return -1;
    }
    opts->tcp_timeout_time_wait = atoll(ptr);

    ptr = toml_raw_in(session_manager, "tcp_timeout_discard");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.tcp_timeout_discard");
        return -1;
    }
    opts->tcp_timeout_discard = atoll(ptr);

    // UDP timeout
    ptr = toml_raw_in(session_manager, "udp_timeout_data");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.udp_timeout_data");
        return -1;
    }
    opts->udp_timeout_data = atoll(ptr);

    // duplicate packet filter
    ptr = toml_raw_in(session_manager, "duplicated_packet_filter_enable");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.duplicated_packet_filter_enable");
        return -1;
    }
    opts->duplicated_packet_filter_enable = atoi(ptr);

    ptr = toml_raw_in(session_manager, "duplicated_packet_filter_capacity");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.duplicated_packet_filter_capacity");
        return -1;
    }
    opts->duplicated_packet_filter_capacity = atoll(ptr);

    ptr = toml_raw_in(session_manager, "duplicated_packet_filter_timeout");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.duplicated_packet_filter_timeout");
        return -1;
    }
    opts->duplicated_packet_filter_timeout = atoll(ptr);

    ptr = toml_raw_in(session_manager, "duplicated_packet_filter_error_rate");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.duplicated_packet_filter_error_rate");
        return -1;
    }
    opts->duplicated_packet_filter_error_rate = atof(ptr);

    // eviction filter
    ptr = toml_raw_in(session_manager, "evicted_session_filter_enable");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.evicted_session_filter_enable");
        return -1;
    }
    opts->evicted_session_filter_enable = atoi(ptr);

    ptr = toml_raw_in(session_manager, "evicted_session_filter_capacity");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.evicted_session_filter_capacity");
        return -1;
    }
    opts->evicted_session_filter_capacity = atoi(ptr);

    ptr = toml_raw_in(session_manager, "evicted_session_filter_timeout");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.evicted_session_filter_timeout");
        return -1;
    }
    opts->evicted_session_filter_timeout = atoi(ptr);

    ptr = toml_raw_in(session_manager, "evicted_session_filter_error_rate");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.evicted_session_filter_error_rate");
        return -1;
    }
    opts->evicted_session_filter_error_rate = atof(ptr);

    return 0;
}

// return  0: success
// retuun -1: failed
int parse_config_file(const char *file, struct config *config)
{
    int ret = -1;
    char errbuf[200];
    FILE *fp = NULL;
    toml_table_t *table = NULL;

    memset(config, 0, sizeof(*config));

    fp = fopen(file, "r");
    if (fp == NULL)
    {
        CONFIG_LOG_ERROR("open config file %s failed, %s", file, strerror(errno));
        goto error_out;
    }

    table = toml_parse_file(fp, errbuf, sizeof(errbuf));
    if (table == NULL)
    {
        CONFIG_LOG_ERROR("parse config file %s failed, %s", file, errbuf);
        goto error_out;
    }

    if (parse_device_options(table, &config->dev_opts) != 0)
    {
        goto error_out;
    }

    if (parse_packet_io_options(table, &config->pkt_io_opts) != 0)
    {
        goto error_out;
    }

    if (parse_ip_reassembly_options(table, &config->ip_reass_opts) != 0)
    {
        goto error_out;
    }

    if (parse_session_manager_options(table, &config->sess_mgr_opts) != 0)
    {
        goto error_out;
    }

    ret = 0;

error_out:
    if (table)
    {
        toml_free(table);
    }

    if (fp)
    {
        fclose(fp);
    }

    return ret;
}

void print_config_options(struct config *config)
{
    if (config == NULL)
    {
        return;
    }

    struct device_options *dev_opts = &config->dev_opts;
    struct packet_io_options *pkt_io_opts = &config->pkt_io_opts;
    struct ip_reassembly_options *ip_reass_opts = &config->ip_reass_opts;
    struct session_manager_options *sess_mgr_opts = &config->sess_mgr_opts;

    // device config
    CONFIG_LOG_DEBUG("device->device_base                             : %d", dev_opts->device_base);
    CONFIG_LOG_DEBUG("device->device_offset                           : %d", dev_opts->device_offset);

    // packet io config
    CONFIG_LOG_DEBUG("packet_io->mode                                 : %s", pkt_io_opts->mode == PACKET_IO_DUMPFILE ? "dumpfile" : "marsio");
    if (pkt_io_opts->mode == PACKET_IO_DUMPFILE)
    {
        CONFIG_LOG_DEBUG("packet_io->dumpfile_dir                         : %s", pkt_io_opts->dumpfile_dir);
    }
    else
    {
        CONFIG_LOG_DEBUG("packet_io->app_symbol                           : %s", pkt_io_opts->app_symbol);
        CONFIG_LOG_DEBUG("packet_io->dev_symbol                           : %s", pkt_io_opts->dev_symbol);
    }
    CONFIG_LOG_DEBUG("packet_io->nr_threads                           : %d", pkt_io_opts->nr_threads);
    for (uint8_t i = 0; i < pkt_io_opts->nr_threads; i++)
    {
        CONFIG_LOG_DEBUG("packet_io->cpu_mask[%03d]                        : %d", i, pkt_io_opts->cpu_mask[i]);
    }

    // ip reassemble config
    CONFIG_LOG_DEBUG("ip_reassembly->enable                           : %d", ip_reass_opts->enable);
    CONFIG_LOG_DEBUG("ip_reassembly->timeout                          : %d", ip_reass_opts->timeout);
    CONFIG_LOG_DEBUG("ip_reassembly->bucket_entries                   : %d", ip_reass_opts->bucket_entries);
    CONFIG_LOG_DEBUG("ip_reassembly->bucket_num                       : %d", ip_reass_opts->bucket_num);

    // session manager config
    CONFIG_LOG_DEBUG("session_manager->max_tcp_session_num            : %ld", sess_mgr_opts->max_tcp_session_num);
    CONFIG_LOG_DEBUG("session_manager->max_udp_session_num            : %ld", sess_mgr_opts->max_udp_session_num);

    CONFIG_LOG_DEBUG("session_manager->tcp_overload_evict_old_sess    : %d", sess_mgr_opts->tcp_overload_evict_old_sess);
    CONFIG_LOG_DEBUG("session_manager->udp_overload_evict_old_sess    : %d", sess_mgr_opts->udp_overload_evict_old_sess);

    CONFIG_LOG_DEBUG("session_manager->tcp_timeout_init               : %ld", sess_mgr_opts->tcp_timeout_init);
    CONFIG_LOG_DEBUG("session_manager->tcp_timeout_handshake          : %ld", sess_mgr_opts->tcp_timeout_handshake);
    CONFIG_LOG_DEBUG("session_manager->tcp_timeout_data               : %ld", sess_mgr_opts->tcp_timeout_data);
    CONFIG_LOG_DEBUG("session_manager->tcp_timeout_half_closed        : %ld", sess_mgr_opts->tcp_timeout_half_closed);
    CONFIG_LOG_DEBUG("session_manager->tcp_timeout_time_wait          : %ld", sess_mgr_opts->tcp_timeout_time_wait);
    CONFIG_LOG_DEBUG("session_manager->tcp_timeout_discard            : %ld", sess_mgr_opts->tcp_timeout_discard);

    CONFIG_LOG_DEBUG("session_manager->udp_timeout_data               : %ld", sess_mgr_opts->udp_timeout_data);

    CONFIG_LOG_DEBUG("session_manager->duplicated_packet_filter_enable        : %d", sess_mgr_opts->duplicated_packet_filter_enable);
    CONFIG_LOG_DEBUG("session_manager->duplicated_packet_filter_capacity      : %d", sess_mgr_opts->duplicated_packet_filter_capacity);
    CONFIG_LOG_DEBUG("session_manager->duplicated_packet_filter_timeout       : %d", sess_mgr_opts->duplicated_packet_filter_timeout);
    CONFIG_LOG_DEBUG("session_manager->duplicated_packet_filter_error_rate    : %f", sess_mgr_opts->duplicated_packet_filter_error_rate);

    CONFIG_LOG_DEBUG("session_manager->evicted_session_filter_enable          : %d", sess_mgr_opts->evicted_session_filter_enable);
    CONFIG_LOG_DEBUG("session_manager->evicted_session_filter_capacity        : %d", sess_mgr_opts->evicted_session_filter_capacity);
    CONFIG_LOG_DEBUG("session_manager->evicted_session_filter_timeout         : %d", sess_mgr_opts->evicted_session_filter_timeout);
    CONFIG_LOG_DEBUG("session_manager->evicted_session_filter_error_rate      : %f", sess_mgr_opts->evicted_session_filter_error_rate);
}