#include <libgen.h>
#include <pthread.h>

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

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

Route *route_hashtable = NULL;

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;

    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 = {0};
        result.status_code = 400;
        mg_wakeup(data->mgr, data->conn_id, &result, sizeof(result));
        return nil;
    }

    char key[MG_PATH_MAX] = {0};
    strncpy(key, http_msg.uri.buf, http_msg.uri.len);
    ssize_t idx = shgeti(route_hashtable, key);

    Route_Result result = {0};
    route_hashtable[idx].value(&http_msg, &result, route_hashtable[idx].context_data);
    mg_wakeup(data->mgr, data->conn_id, &result, sizeof(result));

    free(data->message.buf);
    free(data);

    return nil;
}

void event_handler(struct mg_connection *conn, int ev, void *ev_data)
{
    if (ev == MG_EV_HTTP_MSG) {
        struct mg_http_message *msg = (struct mg_http_message *)ev_data;

        Route_Thread_Data *data = calloc(1, sizeof(*data));
        data->message = mg_strdup(msg->message);
        data->conn_id = conn->id;
        data->mgr = conn->mgr;
        run_in_thread(&route_thread_function, data);
    } else if (ev == MG_EV_WAKEUP) {
        struct mg_str *data = (struct mg_str *)ev_data;
        Route_Result *result = (Route_Result *)data->buf;
        defer {
            for (size_t i = 0; i < result->headers.count; i++) {
                free(result->headers.items[i]);
            }
            list_free(&result->headers);
            sb_free(&result->body);
        }
    
        Gebs_String_Builder sb = {0};
        defer { sb_free(&sb); }
        nsl_join(&result->headers, &sb, "\r\n");
        if (result->headers.count > 0) {
            sb_append_nstr(&sb, "\r\n");
        }
        sb_finish(&sb);

        mg_http_reply(conn, result->status_code, sb.items, "%s", result->body.items);
    }
}

void init_route_hashtable(void)
{
    shdefault(route_hashtable, &route_page_not_found);
    shput(route_hashtable,      "/page-missing",        &route_page_not_found);
    shput(route_hashtable,      "/simple.min.css",      &route_simple_css);
    shput(route_hashtable,      "/favicon.ico",         &route_favicon);
    shput(route_hashtable,      "/hotreload.js",        &route_hotreload_js);
    shput(route_hashtable,      "/",                    &route_home);
    shput(route_hashtable,      "/build-id",            &route_build_id);
    shput(route_hashtable,      "/blog",                &route_blog);

    void put_blogs(Baked_Resource *resource)
    {
        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, path, &route_generic_blog);
            route_hashtable[shgeti(route_hashtable, path)].context_data = (void *)resource;
        }
    }

    baked_resource_each(&put_blogs);
}

int main(int argc, char ** argv)
{
    start_timer();

    init_baked_resources();

    mg_log_set(MG_LL_DEBUG);
    struct mg_mgr mgr;
    mg_mgr_init(&mgr);
    init_route_hashtable();

    mg_wakeup_init(&mgr);
    mg_http_listen(&mgr, "http://localhost:8080", &event_handler, NULL);

    for (;;) {
        mg_mgr_poll(&mgr, 1000);
        scratch_arena_reset();
    }
    
    mg_mgr_free(&mgr);
    shfree(route_hashtable);
    
    free_baked_resources();

    return 0;
}