/*
 * Copyright (C) Andrew Clayton
 * Copyright (C) F5, Inc.
 */

#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stdarg.h>
#include <unistd.h>
#include <time.h>

#include <wasm_export.h>

#include "nxt_wasm.h"


typedef struct nxt_wamr_ctx_s  nxt_wamr_ctx_t;

struct nxt_wamr_ctx_s {
    uint8_t             *mod_buf;
    wasm_module_t       module;
    wasm_module_inst_t  module_inst;
    wasm_exec_env_t     exec_env;
};

static nxt_wamr_ctx_t  nxt_wamr_ctx;


static void
nxt_wamr_err_msg(const char *fmt, ...)
{
    char       dstr[20];
    time_t     t;
    va_list    args;
    struct tm  *tmp;

    t = time(NULL);
    tmp = localtime(&t);
    if (tmp == NULL) {
        return;
    }

    strftime(dstr, sizeof(dstr), "%Y/%m/%d %T", tmp);

    fprintf(stderr, "%s [WAMR ERROR] %d ", dstr, getpid());
    va_start(args, fmt);
    vfprintf(stderr, fmt, args);
    va_end(args);
    fprintf(stderr, "\n");
}


static uint32_t
nxt_wasm_get_init_mem_size(wasm_exec_env_t exec_env)
{
    return NXT_WASM_MEM_SIZE;
}


static void
nxt_wasm_response_end(wasm_exec_env_t exec_env)
{
    nxt_wasm_ctx_t  *ctx = wasm_runtime_get_user_data(exec_env);

    nxt_wasm_do_response_end(ctx);
}


static void
nxt_wasm_send_response(wasm_exec_env_t exec_env, uint32_t offset)
{
    nxt_wasm_ctx_t  *ctx = wasm_runtime_get_user_data(exec_env);

    nxt_wasm_do_send_response(ctx, offset);
}


static void
nxt_wasm_send_headers(wasm_exec_env_t exec_env, uint32_t offset)
{
    nxt_wasm_ctx_t  *ctx = wasm_runtime_get_user_data(exec_env);

    nxt_wasm_do_send_headers(ctx, offset);
}


static void
nxt_wasm_set_resp_status(wasm_exec_env_t exec_env, uint16_t status)
{
    nxt_wasm_ctx_t  *ctx = wasm_runtime_get_user_data(exec_env);

    ctx->status = status;
}


static void
nxt_wamr_execute_hook(const nxt_wasm_ctx_t *ctx, nxt_wasm_fh_t hook)
{
    bool                   ok;
    const char             *name = ctx->fh[hook].func_name;
    nxt_wamr_ctx_t         *rt_ctx = &nxt_wamr_ctx;
    const nxt_wasm_func_t  *func = ctx->fh[hook].func;

    if (name == NULL) {
        return;
    }

    ok = wasm_runtime_call_wasm_a(rt_ctx->exec_env, (nxt_wasm_func_t)func,
                                  0, NULL, 0, NULL);
    if (!ok) {
        nxt_wamr_err_msg("failed to call hook function [%s]. (%s)", name,
                         wasm_runtime_get_exception(rt_ctx->module_inst));
    }
}


static int
nxt_wamr_execute_request(const nxt_wasm_ctx_t *ctx)
{
    bool                   ok;
    uint32_t               i = 0;
    wasm_val_t             args[1] = { };
    wasm_val_t             results[1] = { };
    nxt_wamr_ctx_t         *rt_ctx = &nxt_wamr_ctx;
    const nxt_wasm_func_t  *func = ctx->fh[NXT_WASM_FH_REQUEST].func;

    args[i].kind = WASM_I32;
    args[i++].of.i32 = ctx->baddr_off;

    ok = wasm_runtime_call_wasm_a(rt_ctx->exec_env, (nxt_wasm_func_t)func,
                                  1, results, i, args);
    if (!ok) {
        nxt_wamr_err_msg("Failed to call function [->wasm_request_handler]. "
                         "(%s)",
                         wasm_runtime_get_exception(rt_ctx->module_inst));
        return -1;
    }

    return results[0].of.i32;
}


static bool
nxt_wamr_set_function_imports(void)
{
    int                  nr_funcs;
    bool                 ok;

    static NativeSymbol  import_functions[] = {
        EXPORT_WASM_API_WITH_SIG(nxt_wasm_get_init_mem_size, "()i"),
        EXPORT_WASM_API_WITH_SIG(nxt_wasm_response_end,      "()"),
        EXPORT_WASM_API_WITH_SIG(nxt_wasm_send_response,     "(i)"),
        EXPORT_WASM_API_WITH_SIG(nxt_wasm_send_headers,      "(i)"),
        EXPORT_WASM_API_WITH_SIG(nxt_wasm_set_resp_status,   "(i)"),
    };

    nr_funcs = sizeof(import_functions) / sizeof(NativeSymbol);

    ok = wasm_runtime_register_natives("env", import_functions, nr_funcs);
    if (!ok) {
        return false;
    }

    return true;
}


static int
nxt_wamr_get_function_exports(nxt_wasm_ctx_t *ctx)
{
    int             i;
    nxt_wamr_ctx_t  *rt_ctx = &nxt_wamr_ctx;

    for (i = 0; i < NXT_WASM_FH_NR; i++) {
        if (ctx->fh[i].func_name == NULL) {
            continue;
        }

        ctx->fh[i].func = wasm_runtime_lookup_function(rt_ctx->module_inst,
                                                       ctx->fh[i].func_name,
                                                       NULL);
        if (ctx->fh[i].func == NULL) {
            return -1;
        }
    }

    return 0;
}


static void
nxt_wamr_wasi_init(const nxt_wasm_ctx_t *ctx)
{
    nxt_wamr_ctx_t  *rt_ctx = &nxt_wamr_ctx;

    wasm_runtime_set_wasi_args(rt_ctx->module,
                               (const char **)ctx->dirs, ctx->nr_dirs,
                               NULL, 0, NULL, 0, NULL, 0);
}


static int
nxt_wamr_init_memory(nxt_wasm_ctx_t *ctx)
{
    bool                   ok;
    uint32_t               i = 0;
    wasm_val_t             args[1] = { };
    wasm_val_t             results[1] = { };
    nxt_wamr_ctx_t         *rt_ctx = &nxt_wamr_ctx;
    const nxt_wasm_func_t  *func = ctx->fh[NXT_WASM_FH_MALLOC].func;

    args[i].kind = WASM_I32;
    args[i++].of.i32 = NXT_WASM_MEM_SIZE + NXT_WASM_PAGE_SIZE;

    ok = wasm_runtime_call_wasm_a(rt_ctx->exec_env, (nxt_wasm_func_t)func,
                                  1, results, i, args);
    if (!ok) {
        return -1;
    }

    ctx->baddr_off = results[0].of.i32;
    ctx->baddr = wasm_runtime_addr_app_to_native(rt_ctx->module_inst,
                                                 ctx->baddr_off);

    return 0;
}


static int
nxt_wamr_init(nxt_wasm_ctx_t *ctx)
{
    int             err;
    bool            ok;
    char            error_buf[128];
    FILE            *fp;
    size_t          file_size;
    uint32_t        stack_size = 16384, heap_size = 16384;
    nxt_wamr_ctx_t  *rt_ctx = &nxt_wamr_ctx;

    ok = wasm_runtime_init();
    if (!ok) {
        nxt_wamr_err_msg("wasm_runtime_init() failed");
        return -1;
    }

    ok = nxt_wamr_set_function_imports();
    if (!ok) {
        nxt_wamr_err_msg("nxt_wamr_set_function_imports() failed");
        return -1;
    }

    fp = fopen(ctx->module_path, "r");
    if (!fp) {
        nxt_wamr_err_msg("fopen(\"%s\") failed", ctx->module_path);
        return -1;
    }

    fseek(fp, 0L, SEEK_END);
    file_size = ftell(fp);
    rt_ctx->mod_buf = malloc(file_size);
    fseek(fp, 0L, SEEK_SET);
    if (fread(rt_ctx->mod_buf, file_size, 1, fp) != 1) {
        nxt_wamr_err_msg("fread(\"%s\") failed", ctx->module_path);
        return -1;
    }
    fclose(fp);

    rt_ctx->module = wasm_runtime_load(rt_ctx->mod_buf, file_size, error_buf,
                                       sizeof(error_buf));
    if (rt_ctx->module == NULL) {
        nxt_wamr_err_msg("wasm_runtime_load() failed");
        return -1;
    }

    nxt_wamr_wasi_init(ctx);

    rt_ctx->module_inst = wasm_runtime_instantiate(rt_ctx->module, stack_size,
                                                   heap_size, error_buf,
                                                   sizeof(error_buf));
    if (rt_ctx->module_inst == NULL) {
        nxt_wamr_err_msg("wasm_runtime_instantiate() failed");
        return -1;
    }

    rt_ctx->exec_env = wasm_runtime_create_exec_env(rt_ctx->module_inst,
                                                    stack_size);
    if (rt_ctx->exec_env == NULL) {
        nxt_wamr_err_msg("wasm_runtime_create_exec_env() failed");
        return -1;
    }
    wasm_runtime_set_user_data(rt_ctx->exec_env, ctx);

    err = nxt_wamr_get_function_exports(ctx);
    if (err) {
        nxt_wamr_err_msg("nxt_wamr_get_function_exports() failed");
        return -1;
    }

    err = nxt_wamr_init_memory(ctx);
    if (err) {
        nxt_wamr_err_msg("nxt_wamr_init_memory() failed");
        return -1;
    }

    return 0;
}


static void
nxt_wamr_destroy(const nxt_wasm_ctx_t *ctx)
{
    uint32_t               i = 0;
    wasm_val_t             args[1] = { };
    nxt_wamr_ctx_t         *rt_ctx = &nxt_wamr_ctx;
    const nxt_wasm_func_t  *func = ctx->fh[NXT_WASM_FH_FREE].func;

    args[i].kind = WASM_I32;
    args[i++].of.i32 = ctx->baddr_off;

    wasm_runtime_call_wasm_a(rt_ctx->exec_env, (nxt_wasm_func_t)func,
                             0, NULL, i, args);

    wasm_runtime_destroy_exec_env(rt_ctx->exec_env);
    wasm_runtime_deinstantiate(rt_ctx->module_inst);
    wasm_runtime_unload(rt_ctx->module);
    free(rt_ctx->mod_buf);
    wasm_runtime_destroy();
}


const nxt_wasm_operations_t  nxt_wasm_ops = {
    .init               = nxt_wamr_init,
    .destroy            = nxt_wamr_destroy,
    .exec_request       = nxt_wamr_execute_request,
    .exec_hook          = nxt_wamr_execute_hook,
};