#include <arpa/inet.h>
#include <json-c/json.h>
#include <signal.h>
#include <sqlite3.h>
#include <string.h>
#include <threads.h>

#include "logger.c"
#include "sql.c"

#define BACKLOG 10

struct Socket {
    int fd;
    struct sockaddr_in addr;
};

// ----------------------------------------------------------------------------
// SQL functions
// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------
// Main functions
// ----------------------------------------------------------------------------
void sig_handler(int signo) {
    (void)signo;
    log_warn("Signal received, will stop SALIS data server");
    sql_close();
    exit(0);
}

void respond_name(int socket_fd) {
    log_info("Client requested simulation name");

    struct json_object *sim_name = json_object_new_object();
    json_object_object_add(sim_name, "name", json_object_new_string(NAME));
    json_object_to_fd(socket_fd, sim_name, 0);
    json_object_put(sim_name);
}

void respond_opts(int socket_fd) {
    log_info("Client requested simulation options");

    struct json_object *sim_opts = json_object_from_file(SIM_OPTS);
    json_object_to_fd(socket_fd, sim_opts, 0);
    json_object_put(sim_opts);
}

void respond_hash(int socket_fd) {
    log_info("Client requested git hash");

    char buff[41] = { 0 };
    FILE *pipe = popen("git rev-parse HEAD", "r");
    fread(buff, sizeof(char), 40, pipe);
    pclose(pipe);

    struct json_object *git_hash = json_object_new_object();
    json_object_object_add(git_hash, "hash", json_object_new_string(buff));
    json_object_to_fd(socket_fd, git_hash, 0);
    json_object_put(git_hash);
}

void respond_data(int socket_fd, struct json_object *request) {
    assert(request);

    const char *request_str = json_object_to_json_string(request);
    log_info("Client requested simulation data with the following parameters: %s", request_str);

    struct json_object *response = json_object_new_object();
    json_object_object_add(response, "response", json_object_new_string("hello!"));
    const char *response_str = json_object_to_json_string(response);
    log_info("Sending response to client: %s", response_str);
    json_object_to_fd(socket_fd, response, 0);

    shutdown(socket_fd, SHUT_WR);
    json_object_put(response);
}

int handle_client(struct Socket *socket) {
    assert(socket);

    char socket_ip[INET_ADDRSTRLEN];
    inet_ntop(AF_INET, &socket->addr.sin_addr, socket_ip, INET_ADDRSTRLEN);
    log_info("Client connected: %s:%d", socket_ip, ntohs(socket->addr.sin_port));

    struct json_object *request_json = json_object_from_fd(socket->fd);
    struct json_object *request_str = NULL;

    if (!json_object_object_get_ex(request_json, "request", &request_str)) assert(false);

    const char *request = json_object_get_string(request_str);
    assert(request);

    if (!strcmp(request, "name")) {
        respond_name(socket->fd);
    } else if (!strcmp(request, "opts")) {
        respond_opts(socket->fd);
    } else if (!strcmp(request, "hash")) {
        respond_hash(socket->fd);
    } else if (!strcmp(request, "data")) {
        respond_data(socket->fd, request_json);
    } else {
        assert(false);
    }

    json_object_put(request_json);

    log_info("Client disconnected: %s:%d", socket_ip, ntohs(socket->addr.sin_port));
    close(socket->fd);

    free(socket);
    return 0;
}

int main(void) {
    log_info("Initializing salis data server");
    log_info("Connecting to database in: %s", DATA_PUSH_PATH);
    sql_open();

    signal(SIGINT, sig_handler);
    signal(SIGTERM, sig_handler);

    log_info("Binding to port: %d", PORT);
    int opt = 1;
    int socket_fd = socket(AF_INET, SOCK_STREAM, 0);
    setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    struct sockaddr_in socket_addr = { 0 };
    socket_addr.sin_family = AF_INET;
    socket_addr.sin_addr.s_addr = INADDR_ANY;
    socket_addr.sin_port = htons(PORT);
    bind(socket_fd, (struct sockaddr *)&socket_addr, sizeof(struct sockaddr_in));

    log_info("Listening...");
    listen(socket_fd, BACKLOG);

    while (true) {
        struct Socket *socket = calloc(1, sizeof(struct Socket));
        socklen_t socket_len = sizeof(struct sockaddr_in);
        socket->fd = accept(socket_fd, (struct sockaddr *)&socket->addr, &socket_len);

        thrd_t thrd;
        thrd_create(&thrd, (thrd_start_t)handle_client, socket);
        thrd_detach(thrd);
    }

    return 0;
}