#include <arpa/inet.h>
#include <netinet/tcp.h>
#include <event2/bufferevent.h>
#include <event2/event.h>
#include <event2/buffer.h>
#include <unistd.h>

#include <tfe_utils.h>
#include <watchdog_kni.h>
#include <MESA/MESA_prof_load.h>


struct watchdog_kni
{
    struct tfe_proxy * proxy;
    const char * profile;
    void * logger;

    unsigned int enable;
    struct sockaddr_in sk_kni_watchdog;
    int fd;
    struct event_base * ev_base;
    struct bufferevent * bev;
    pthread_t pthread;
};

static int watchdog_kni_fd_create()
{
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    unsigned int so_keepalive = 1;
    unsigned int tcp_keepcnt = 1;
    unsigned int tcp_keepintvl = 1;
    unsigned int tcp_keepidle = 1;

    evutil_make_socket_nonblocking(fd);

    if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (const void *) &so_keepalive, sizeof(int)) == -1)
    {
        TFE_LOG_ERROR(g_default_logger, "watchdog fd setup setsockopt(SO_KEEPALIVE, %d) failed : %s",
            so_keepalive, strerror(errno)); goto errout;
    }

    if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, (const void *) &tcp_keepcnt, sizeof(int)) == -1)
    {
        TFE_LOG_ERROR(g_default_logger, "watchdog fd setup setsockopt(TCP_KEEPCNT, %d) failed: %s",
            tcp_keepcnt, strerror(errno)); goto errout;
    }

    if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, (const void *) &tcp_keepintvl, sizeof(int)) == -1)
    {
        TFE_LOG_ERROR(g_default_logger, "watchdog fd setup setsockopt(TCP_KEEPINTVL, %d) failed: %s",
            tcp_keepintvl, strerror(errno));
    }

    if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, (const void *) &tcp_keepidle, sizeof(int)) == -1)
    {
        TFE_LOG_ERROR(g_default_logger, "watchdog fd setup setsockopt(TCP_KEEPIDLE, %d) failed: %s",
            tcp_keepidle, strerror(errno));
    }

    return fd;

errout:
    if(fd > 0) close(fd);
    return -1;
}

static void watchdog_kni_readcb(struct bufferevent *bev, void *ctx)
{
    struct evbuffer * evbuffer_in = bufferevent_get_input(bev);
    evbuffer_drain(evbuffer_in, evbuffer_get_length(evbuffer_in));
}

static void watchdog_kni_eventcb(struct bufferevent *bev, short what, void *ctx)
{
    struct watchdog_kni * __ctx = (struct watchdog_kni *)ctx;
    if (what & BEV_EVENT_CONNECTED)
    {
        TFE_LOG_INFO(__ctx->bev, "KNI watchdog connection is established.");
        return;
    }

    if (what & (BEV_EVENT_EOF | BEV_EVENT_ERROR))
    {
        if (what & BEV_EVENT_EOF)
        {
            TFE_LOG_ERROR(__ctx->logger, "KNI watchdog connection broken, KNI is shutdown, EXIT.");
            exit(EXIT_FAILURE);
        }

        if (what & BEV_EVENT_ERROR)
        {
            if (errno)
            {
                TFE_LOG_ERROR(__ctx->logger, "KNI watchdog connection broken: %s, EXIT.", strerror(errno));
            }
            else
            {
                TFE_LOG_ERROR(__ctx->logger, "KNI watchdog connection broken: Unknown, EXIT.");
            }
            exit(EXIT_FAILURE);
        }
    }

    return;
}

void * watchdog_kni_thread(void * arg)
{
    struct watchdog_kni * __ctx = (struct watchdog_kni *)arg;
    while(event_base_dispatch(__ctx->ev_base) >= 0) {}
    DIE("watchdog thread is terminated.");
}

struct watchdog_kni * watchdog_kni_create(struct tfe_proxy * proxy, const char * profile, void * logger)
{
    struct watchdog_kni * __ctx = ALLOC(struct watchdog_kni, 1);
    int ret = 0;

    __ctx->proxy = proxy;
    __ctx->profile = profile;
    __ctx->logger = logger;

    unsigned int en_watchdog = 0;
    MESA_load_profile_uint_def(profile, "kni", "watchdog_switch", &en_watchdog, 0);
    __ctx->enable = en_watchdog;

    if (!__ctx->enable)
    {
        return __ctx;
    }

    char str_kni_ip[TFE_STRING_MAX] = {0};
    MESA_load_profile_string_def(profile, "kni", "ip", str_kni_ip, sizeof(str_kni_ip), "127.0.0.1");

    struct sockaddr_in sk_kni_address{};
    sk_kni_address.sin_family = AF_INET;
    ret = inet_pton(AF_INET, str_kni_ip, &sk_kni_address.sin_addr);

    if (ret < 0)
    {
        TFE_LOG_ERROR(logger, "failed at parsing kni's address, in file %s, section %s, entry %s: %s",
            profile, "kni", "ip", str_kni_ip); goto __errout;
    }

    unsigned int kni_port;
    MESA_load_profile_uint_def(profile, "kni", "watchdog_port", &kni_port, 2476);

    __ctx->sk_kni_watchdog = sk_kni_address;
    __ctx->sk_kni_watchdog.sin_port = htons(kni_port);

    /* Prepare watchdog fd */
    __ctx->fd = watchdog_kni_fd_create();
    if (__ctx->fd < 0)
    {
        TFE_LOG_ERROR(logger, "failed at creating watchdog fd : %s", strerror(errno));
        goto __errout;
    }

    __ctx->ev_base = event_base_new();
    if (!__ctx->ev_base)
    {
        TFE_LOG_ERROR(logger, "failed at watchdog event_base_new(): %s", strerror(errno));
        goto __errout;
    }

    __ctx->bev = bufferevent_socket_new(__ctx->ev_base, __ctx->fd, BEV_OPT_CLOSE_ON_FREE);
    if (!__ctx->bev)
    {
        TFE_LOG_ERROR(logger, "failed at watchdog bufferevent_socket_new(): %s", strerror(errno));
        goto __errout;
    }

    ret = bufferevent_socket_connect(__ctx->bev, (const sockaddr *)&__ctx->sk_kni_watchdog,
        sizeof(__ctx->sk_kni_watchdog));

    if (ret < 0)
    {
        TFE_LOG_ERROR(logger, "failed at watchdog connect(): %s", strerror(errno));
        goto __errout;
    }

    bufferevent_setcb(__ctx->bev, watchdog_kni_readcb, NULL, watchdog_kni_eventcb, __ctx);
    bufferevent_enable(__ctx->bev, EV_READ | EV_WRITE);

    /* Create a thread to dispatch ctx->evbase */
    ret = pthread_create(&__ctx->pthread, NULL, watchdog_kni_thread, (void *) __ctx);
    if (unlikely(ret < 0))
    {
        TFE_LOG_ERROR(__ctx->logger, "Failed at creating watchdog thread: %s", strerror(errno));
        goto __errout;
    }

    TFE_LOG_INFO(__ctx->logger, "KNI watchdong init successfully.");
    return __ctx;

__errout:
    return NULL;
}