#include <stdio.h>
#include <assert.h>
#include <errno.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include <sys/prctl.h>
#include <signal.h>

#include "packet.h"
#include "timestamp.h"
#include "session_manager.h"
#include "dupkt_filter.h"
#include "eviction_filter.h"

#ifndef STELLAR_LOG_ERROR
#define STELLAR_LOG_ERROR(format, ...) \
    fprintf(stderr, "ERROR (stellar), " format "\n", ##__VA_ARGS__);
#endif
#ifndef STELLAR_LOG_DEBUG
#define STELLAR_LOG_DEBUG(format, ...) \
    fprintf(stderr, "DEBUG (stellar), " format "\n", ##__VA_ARGS__);
#endif

#define ATOMIC_SET(x, y) __atomic_store_n(x, y, __ATOMIC_RELAXED)
#define ATOMIC_READ(x) __atomic_load_n(x, __ATOMIC_RELAXED)

struct thread_ctx
{
    pthread_t tid;
    uint16_t index;
    uint64_t need_exit;
    uint64_t is_runing;
    struct session_manager *sess_mgr;
    struct dupkt_filter *dupkt_filter;
    struct eviction_filter *eviction_filter;
};

struct stellar_ctx
{
    uint64_t need_exit;
    uint16_t max_worker_num;

    // session manager
    uint64_t sess_mgr_max_session_num;
    uint64_t sess_mgr_timeout_ms_toclsoing;
    uint64_t sess_mgr_timeout_ms_toclosed;

    // duplicated packet filter
    uint8_t dupkt_filter_enable;
    unsigned int dupkt_filter_capacity;
    double dupkt_filter_error_rate;
    int dupkt_filter_timeout_s;

    // eviction filter
    uint8_t eviction_filter_enable;
    unsigned int eviction_filter_capacity;
    double eviction_filter_error_rate;
    int eviction_filter_timeout_s;

    // thread
    struct thread_ctx thread_ctx[128];
} g_stellar_ctx = {
    .need_exit = 0,
    .max_worker_num = 1,

    // session manager
    .sess_mgr_max_session_num = 1000000,
    .sess_mgr_timeout_ms_toclsoing = 1000,
    .sess_mgr_timeout_ms_toclosed = 10000,

    // duplicated packet filter
    .dupkt_filter_enable = 1,
    .dupkt_filter_capacity = 1000000,
    .dupkt_filter_error_rate = 0.0001,
    .dupkt_filter_timeout_s = 10,

    // eviction filter
    .eviction_filter_enable = 1,
    .eviction_filter_capacity = 1000000,
    .eviction_filter_error_rate = 0.0001,
    .eviction_filter_timeout_s = 10,
};

// TODO
static int recv_packet(const char **data)
{
    static unsigned char packet_data[] = {
        0x5c, 0x5e, 0xab, 0x2a, 0xa2, 0x00, 0x2c, 0x6b, 0xf5, 0x45, 0x88, 0x29, 0x08, 0x00, 0x45, 0x00, 0x00, 0x5c, 0x0b, 0x4d, 0x00, 0x00, 0x3b, 0x29, 0x09, 0xc8,
        0xd2, 0x4d, 0x58, 0xa3, 0x3b, 0x42, 0x04, 0x32, 0x60, 0x00, 0x00, 0x00, 0x00, 0x20, 0x06, 0x40, 0x20, 0x01, 0x0d, 0xa8, 0x02, 0x00, 0x90, 0x0e, 0x02, 0x00,
        0x5e, 0xfe, 0xd2, 0x4d, 0x58, 0xa3, 0x26, 0x00, 0x14, 0x0e, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x02, 0x10, 0x58, 0xcd, 0x4c, 0x00, 0x50,
        0x81, 0x80, 0x5c, 0x76, 0x00, 0x00, 0x00, 0x00, 0x80, 0x02, 0x20, 0x00, 0xf7, 0x57, 0x00, 0x00, 0x02, 0x04, 0x04, 0xc4, 0x01, 0x03, 0x03, 0x08, 0x01, 0x01,
        0x04, 0x02};

    *data = (const char *)packet_data;
    return sizeof(packet_data);
}

static void signal_handler(int signo)
{
    if (signo == SIGINT)
    {
        STELLAR_LOG_DEBUG("recv SIGINT, exit !!!");
        ATOMIC_SET(&g_stellar_ctx.need_exit, 1);
    }

    if (signo == SIGQUIT)
    {
        STELLAR_LOG_DEBUG("recv SIGQUIT, exit !!!");
        ATOMIC_SET(&g_stellar_ctx.need_exit, 1);
    }

    if (signo == SIGTERM)
    {
        STELLAR_LOG_DEBUG("recv SIGTERM, exit !!!");
        ATOMIC_SET(&g_stellar_ctx.need_exit, 1);
    }
}

static void __session_dispatch(struct session *sess)
{
    if (sess == NULL)
    {
        return;
    }

    printf("\n");
    printf("=> session dispatch: %p\n", sess);
    session_dump(sess);
    printf("<= session dispatch\n");

    session_set0_cur_pkt(sess, NULL);
    session_set_cur_dir(sess, SESSION_DIR_NONE);
}

static void thread_ctx_init(struct stellar_ctx *ctx)
{
    for (uint16_t i = 0; i < ctx->max_worker_num; i++)
    {
        struct thread_ctx *thd_ctx = &ctx->thread_ctx[i];
        thd_ctx->index = i;
        thd_ctx->need_exit = 0;
        thd_ctx->is_runing = 0;
        // session manager
        thd_ctx->sess_mgr = session_manager_create(ctx->sess_mgr_max_session_num);
        assert(thd_ctx->sess_mgr != NULL);
        session_manager_set_timeout_toclosing(thd_ctx->sess_mgr, ctx->sess_mgr_timeout_ms_toclsoing);
        session_manager_set_timeout_toclosed(thd_ctx->sess_mgr, ctx->sess_mgr_timeout_ms_toclosed);
        // duplicated packet filter
        thd_ctx->dupkt_filter = dupkt_filter_create(ctx->dupkt_filter_enable, ctx->dupkt_filter_capacity, ctx->dupkt_filter_error_rate, ctx->dupkt_filter_timeout_s);
        assert(thd_ctx->dupkt_filter != NULL);
        // eviction filter
        thd_ctx->eviction_filter = eviction_filter_create(ctx->eviction_filter_enable, ctx->eviction_filter_capacity, ctx->eviction_filter_error_rate, ctx->eviction_filter_timeout_s);
        assert(thd_ctx->eviction_filter != NULL);
    }
}

static void thread_ctx_free(struct stellar_ctx *ctx)
{
    for (uint16_t i = 0; i < ctx->max_worker_num; i++)
    {
        struct thread_ctx *thd_ctx = &ctx->thread_ctx[i];
        if (ATOMIC_READ(&thd_ctx->is_runing) == 0)
        {
            session_manager_destroy(thd_ctx->sess_mgr);
        }
    }
}

static void *thread_cycle(void *arg)
{
    uint16_t len = 0;
    const char *data = NULL;
    struct packet pkt;
    struct session *sess = NULL;
    struct thread_ctx *thd_ctx = (struct thread_ctx *)arg;
    struct session_manager *sess_mgr = thd_ctx->sess_mgr;
    struct dupkt_filter *dupkt_filter = thd_ctx->dupkt_filter;
    char thread_name[16];

    ATOMIC_SET(&thd_ctx->is_runing, 1);
    snprintf(thread_name, sizeof(thread_name), "stellar:%d", thd_ctx->index);
    prctl(PR_SET_NAME, (unsigned long long)thread_name, NULL, NULL, NULL);
    STELLAR_LOG_DEBUG("worker thread %s runing\n", thread_name);

    while (ATOMIC_READ(&thd_ctx->need_exit) == 0)
    {
        // TODO recv packet
        len = recv_packet(&data);

        // parse packet
        packet_parse(&pkt, data, len);

        // duplicated packet filter
        if (dupkt_filter_lookup(dupkt_filter, &pkt) == 0)
        {
            STELLAR_LOG_DEBUG("duplicated packet, forward it");
            goto fast_forward;
        }

        // eviction filter
        if (eviction_filter_lookup(thd_ctx->eviction_filter, &pkt) == 0)
        {
            STELLAR_LOG_DEBUG("eviction packet, forward it");
            goto fast_forward;
        }

        // update session
        sess = session_manager_update(sess_mgr, &pkt);
        if (sess == NULL)
        {
            goto fast_forward;
        }

        // TODO session synchronization

        __session_dispatch(sess);
        dupkt_filter_add(dupkt_filter, &pkt);

    fast_forward:
        // TODO send packet

        // dispatch expire session
        sess = session_manager_expire(sess_mgr);
        if (sess && session_get_type(sess) == SESSION_TYPE_UDP && session_get_state(sess) == SESSION_STATE_CLOSING)
        {
            const struct packet *sess_1st_pkt = session_get0_1st_pkt(sess);
            eviction_filter_add(thd_ctx->eviction_filter, sess_1st_pkt);
        }
        __session_dispatch(sess);

        sess = session_manager_evicte(sess_mgr);
        if (sess && session_get_type(sess) == SESSION_TYPE_UDP)
        {
            const struct packet *sess_1st_pkt = session_get0_1st_pkt(sess);
            eviction_filter_add(thd_ctx->eviction_filter, sess_1st_pkt);
        }
        __session_dispatch(sess);

        // TODO get next timeout
        sleep(1);
    }

    ATOMIC_SET(&thd_ctx->is_runing, 0);
    STELLAR_LOG_DEBUG("worker thread %s exit\n", thread_name);

    return NULL;
}

int main(int argc, char **argv)
{
    // TODO parse command line

    // TODO init log

    // TODO init plugin

    // register signal handler
    signal(SIGINT, signal_handler);
    signal(SIGQUIT, signal_handler);
    signal(SIGTERM, signal_handler);

    // update timestamp
    timestamp_update();

    // init thread context
    thread_ctx_init(&g_stellar_ctx);

    // create worker thread
    for (uint16_t i = 0; i < g_stellar_ctx.max_worker_num; i++)
    {
        struct thread_ctx *thd_ctx = &g_stellar_ctx.thread_ctx[i];
        if (pthread_create(&thd_ctx->tid, NULL, thread_cycle, (void *)thd_ctx) < 0)
        {
            STELLAR_LOG_ERROR("unable to create worker thread, error %d: %s", errno, strerror(errno));
            goto error_out;
        }
    }

    // master thread update timestamp
    while (!g_stellar_ctx.need_exit)
    {
        timestamp_update();
        sleep(1);
    }

    // wait worker thread exit
    for (uint16_t i = 0; i < g_stellar_ctx.max_worker_num; i++)
    {
        struct thread_ctx *thd_ctx = &g_stellar_ctx.thread_ctx[i];
        ATOMIC_SET(&thd_ctx->need_exit, 1);
        while (ATOMIC_READ(&thd_ctx->is_runing) == 1)
        {
            sleep(1);
        }
    }

error_out:
    thread_ctx_free(&g_stellar_ctx);

    // TODO free plugin

    // TODO free log

    return 0;
}