#include <libgen.h>
#include <pthread.h>
#include <ftw.h>
#include <signal.h>
#include <sys/sendfile.h>

#define GEBS_IMPLEMENTATION
#include "gebs/gebs.h"
#include "mongoose/mongoose.h"
#define STB_DS_IMPLEMENTATION
#include "stb/stb_ds.h"
#include "md5-c/md5.h"

#include "routes.h"
#include "baked.h"
#include "timer.h"
#include "CONFIG.h"
#include "locked.h"

static locked(Route *) route_hashtable = locked_init(nil);
static locked(char *)  baked_dump_path   = locked_init(nil);

char *clonestr_alloc(Allocator *alloc, char *s)
{
    char *p = gebs_malloc(alloc, strlen(s)+1);
    strcpy(p, s);
    return p;
}

void *zmalloc_alloc(Allocator *alloc, size_t size)
{
    void *p = gebs_malloc(alloc, size);
    memset(p, 0, size);
    return p;
}

void run_in_thread(void *(*f)(void *), void *p)
{
    pthread_t tid = 0;

    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

    pthread_create(&tid, &attr, f, p);
    pthread_attr_destroy(&attr);
}

void *route_thread_function(void *param)
{
    Route_Thread_Data *data = (Route_Thread_Data *)param;
    Arena *arena = data->arena;

    struct mg_http_message http_msg = {0};
    int r = mg_http_parse(data->message.buf, data->message.len, &http_msg);
    if (r <= 0) {
        Route_Result *result = zmalloc_alloc((Allocator *)arena, sizeof(*result));
        result->arena = arena;
        result->status_code = 400;
        result->type = ROUTE_RESULT_DYNAMIC;
        sb_append_nstr_alloc(arena, &result->body, "Could not parse HTTP request");
        sb_finish_alloc(arena, &result->body);
        mg_wakeup(data->mgr, data->conn_id, &result, sizeof(result));
        free(data->message.buf);
        free(data);
        pthread_exit(nil);
    } else {
        if (mg_match(http_msg.uri, mg_str("/bakedres/*"), nil)) {
            Route_Result *result = zmalloc_alloc((Allocator *)arena, sizeof(*result));
            result->arena = arena;
            result->type = ROUTE_RESULT_STATIC;

            char *p = gebs_malloc(arena, http_msg.uri.len+1);
            strncpy(p, http_msg.uri.buf, http_msg.uri.len);
            p[http_msg.uri.len] = 0;

            char *file = basename(p);
            char *full_path = gebs_malloc(arena, PATH_MAX);

            lockx(&baked_dump_path);
            snprintf(full_path, PATH_MAX, "%s/%s", baked_dump_path.value, file);
            unlockx(&baked_dump_path);

            sb_append_nstr_alloc(arena, &result->body, full_path);
            sb_finish_alloc(arena, &result->body);
            mg_wakeup(data->mgr, data->conn_id, &result, sizeof(result));
            free(data->message.buf);
            free(data);
            pthread_exit(nil);
        } else {
            char key[MG_PATH_MAX] = {0};
            strncpy(key, http_msg.uri.buf, http_msg.uri.len);
            lockx(&route_hashtable);
            ssize_t idx = shgeti(route_hashtable.value, key);

            Route_Result *result = zmalloc_alloc((Allocator *)arena, sizeof(*result));
            result->arena = arena;
            route_hashtable.value[idx].value((Allocator *)arena, &http_msg, result, route_hashtable.value[idx].context_data);
            unlockx(&route_hashtable);
            mg_wakeup(data->mgr, data->conn_id, &result, sizeof(result));

            free(data->message.buf);
            free(data);
            pthread_exit(nil);
        }
    }
    return nil;
}

void event_handler(struct mg_connection *conn, int ev, void *ev_data)
{
    if (ev == MG_EV_HTTP_MSG) {
        LOGI("HTTP EVENT\n");
        struct mg_http_message *msg = (struct mg_http_message *)ev_data;
        LOGI("Route: %.*s\n", msg->uri.len, msg->uri.buf);

        Route_Thread_Data *data = calloc(1, sizeof(*data));
        data->message = mg_strdup(msg->message);
        data->conn_id = conn->id;
        data->mgr = conn->mgr;
        data->arena = malloc(sizeof(*data->arena));
        *data->arena = arena_get();
        LOGI("starting handler thread...\n");
        run_in_thread(&route_thread_function, data);
    } else if (ev == MG_EV_WAKEUP) {
        LOGI("WAKEUP EVENT\n");
        struct mg_str *data = (struct mg_str *)ev_data;
        Route_Result *result = *(Route_Result **)data->buf;
        Arena *arena = result->arena;

        Gebs_String_Builder sb = {0};
        nsl_join_alloc(arena, &result->headers, &sb, "\r\n");
        if (result->headers.count > 0) {
            sb_append_nstr_alloc(arena, &sb, "\r\n");
        }
        sb_finish_alloc(arena, &sb);

        if (result->type == ROUTE_RESULT_DYNAMIC) {
            mg_http_reply(conn, result->status_code, sb.items, "%s", result->body.items);
        } else if (result->type == ROUTE_RESULT_STATIC) {
            char *path = result->body.items;
            mg_http_serve_file(conn, ev_data, path, &(struct mg_http_serve_opts){0});
        }

        arena_destroy(arena);
        free(arena);

        LOGI("WAKEUP done, arena cleaned\n");
    }
}


void route_hashtable_put_blogs(Baked_Resource *resource, void *udata)
{
    if ((strlen(resource->key) >= strlen("blog-"))
     && strncmp(resource->key, "blog-", strlen("blog-")) == 0) {
        char *path = malloc(MG_PATH_MAX);
        snprintf(path, MG_PATH_MAX, "/%s", resource->key);
        shput(route_hashtable.value, path, &route_generic_blog);
        route_hashtable.value[shgeti(route_hashtable.value, path)].context_data = (void *)resource;
    }
}

void init_route_hashtable(void)
{
    shdefault(route_hashtable.value, &route_page_not_found);
    shput(route_hashtable.value,    clonestr_alloc(&default_allocator, "/"),              &route_home);
    shput(route_hashtable.value,    clonestr_alloc(&default_allocator, "/page-missing"),  &route_page_not_found);
    shput(route_hashtable.value,    clonestr_alloc(&default_allocator, "/blog"),          &route_blog);
#if MY_DEBUG
    shput(route_hashtable.value,    clonestr_alloc(&default_allocator, "/build-id"),      &route_build_id);
#endif

    baked_resource_each(&route_hashtable_put_blogs, nil);
}

void free_route_hashtable(void)
{
    for (size_t i = 0; i < shlen(route_hashtable.value); i++) {
        free(route_hashtable.value[i].key);
    }
    shfree(route_hashtable.value);
}

char *init_baked_dump(void)
{
    char template[] = "/tmp/aboba-bakedres.XXXXXX";
    char *baked_dump1 = mkdtemp(template);
    char *baked_dump = malloc(strlen(baked_dump1)+1);
    strcpy(baked_dump, baked_dump1);

    if (baked_dump == nil) {
        LOGE("Could not create bakedres dump\n");
        return nil;
    }
    LOGI("bakedres dump dir is %s\n", baked_dump);

    return baked_dump;
}

int baked_dump_rm_cb(const char *path,
                   discard const struct stat *st,
                   discard int type,
                   discard struct FTW *ftw)
{
    return remove(path);
}

bool free_baked_dump(char *baked_dump)
{
    LOGI("Removing bakedres dump %s\n", baked_dump);
    bool ok = nftw(baked_dump, baked_dump_rm_cb, FOPEN_MAX, FTW_DEPTH | FTW_MOUNT | FTW_PHYS) != -1;
    if (!ok) {
        LOGE("Could not remove %s\n", baked_dump);
    }
    free(baked_dump);
    return ok;
}

// https://stackoverflow.com/questions/2180079/how-can-i-copy-a-file-on-unix-using-c
int cp(const char* source, const char* destination)
{
    int result = 0;
    int input, output;
    if ((input = open(source, O_RDONLY)) == -1)
    {
        return -1;
    }
    if ((output = creat(destination, 0660)) == -1)
    {
        close(input);
        return -1;
    }

    // sendfile will work with non-socket output (i.e. regular file) under
    // Linux 2.6.33+ and some other unixy systems.
    struct stat file_stat = {0};
    result = fstat(input, &file_stat);
    off_t copied = 0;
    while (result == 0 && copied < file_stat.st_size) {
        ssize_t written = sendfile(output, input, &copied, SSIZE_MAX);
        copied += written;
        if (written == -1) {
            result = -1;
        }
    }

    close(input);
    close(output);

    return result;
}

void copy_baked_resources_to_baked_dump(Baked_Resource *resource, void *udata)
{
    char *baked_dump = (char *)udata;
    char path[PATH_MAX];
    get_baked_resource_path(resource->key, path, sizeof(path));
    char dest[PATH_MAX];
    snprintf(dest, sizeof(dest), "%s/%s", baked_dump, resource->key);
    cp(path, dest);
}

void populate_baked_dump(char *baked_dump)
{
    baked_resource_each(&copy_baked_resources_to_baked_dump, baked_dump);
}

volatile sig_atomic_t alive = true;

void graceful_shutdown(int no) { alive = false; }

int main(int argc, char ** argv)
{
    struct sigaction sa;
    sa.sa_handler = &graceful_shutdown;
    sa.sa_flags = 0;
    sigemptyset(&sa.sa_mask);
    sigaction(SIGINT, &sa, nil);

    start_timer();

    init_baked_resources();
    if ((baked_dump_path.value = init_baked_dump()) == nil) {
        return 1;
    }
    populate_baked_dump(baked_dump_path.value);

    mg_log_set(MG_LL_DEBUG);
    struct mg_mgr mgr;
    mg_mgr_init(&mgr);
    init_route_hashtable();
    defer { free_route_hashtable(); }

    mg_wakeup_init(&mgr);
    mg_http_listen(&mgr, CONFIG_LISTEN_URL, &event_handler, NULL);

    while (alive) {
        mg_mgr_poll(&mgr, 1000);
        scratch_arena_reset();
    }
    
    mg_mgr_free(&mgr);

    free_baked_dump(baked_dump_path.value);
    free_baked_resources();

    return 0;
}