/*
 * Copyright (c) 2022 Egor Tensin <egor@tensin.name>
 * This file is part of the "cimple" project.
 * For details, see https://github.com/egor-tensin/cimple.
 * Distributed under the MIT License.
 */

#include "run_queue.h"

#include "json.h"
#include "log.h"

#include <json-c/json_object.h>

#include <stdlib.h>
#include <string.h>
#include <sys/queue.h>

struct run {
    int id;
    char* repo_url;
    char* repo_rev;
    int status;
    int exit_code;

    SIMPLEQ_ENTRY(run) entries;
};

int run_new(
    struct run** _entry,
    int id,
    const char* _repo_url,
    const char* _repo_rev,
    enum run_status status,
    int exit_code
) {
    struct run* entry = malloc(sizeof(struct run));
    if (!entry) {
        log_errno("malloc");
        goto fail;
    }

    char* repo_url = strdup(_repo_url);
    if (!repo_url) {
        log_errno("strdup");
        goto free_entry;
    }

    char* repo_rev = strdup(_repo_rev);
    if (!repo_rev) {
        log_errno("strdup");
        goto free_repo_url;
    }

    entry->id = id;
    entry->repo_url = repo_url;
    entry->repo_rev = repo_rev;
    entry->status = status;
    entry->exit_code = exit_code;

    *_entry = entry;
    return 0;

free_repo_url:
    free(repo_url);

free_entry:
    free(entry);

fail:
    return -1;
}

void run_destroy(struct run* entry) {
    free(entry->repo_rev);
    free(entry->repo_url);
    free(entry);
}

int run_queued(struct run** entry, const char* repo_url, const char* repo_rev) {
    return run_new(entry, -1, repo_url, repo_rev, RUN_STATUS_CREATED, -1);
}

int run_created(struct run** entry, int id, const char* repo_url, const char* repo_rev) {
    return run_new(entry, id, repo_url, repo_rev, RUN_STATUS_CREATED, -1);
}

int run_to_json(const struct run* entry, struct json_object** _json) {
    struct json_object* json = NULL;
    int ret = 0;

    ret = libjson_new_object(&json);
    if (ret < 0)
        return -1;
    ret = libjson_set_int_const_key(json, "id", entry->id);
    if (ret < 0)
        goto free;
    ret = libjson_set_int_const_key(json, "exit_code", entry->exit_code);
    if (ret < 0)
        goto free;
    ret = libjson_set_string_const_key(json, "repo_url", entry->repo_url);
    if (ret < 0)
        goto free;
    ret = libjson_set_string_const_key(json, "repo_rev", entry->repo_rev);
    if (ret < 0)
        goto free;

    *_json = json;
    return ret;

free:
    libjson_free(json);

    return ret;
}

int run_get_id(const struct run* entry) {
    return entry->id;
}

const char* run_get_repo_url(const struct run* entry) {
    return entry->repo_url;
}

const char* run_get_repo_rev(const struct run* entry) {
    return entry->repo_rev;
}

void run_set_id(struct run* entry, int id) {
    entry->id = id;
}

void run_queue_create(struct run_queue* queue) {
    SIMPLEQ_INIT(queue);
}

void run_queue_destroy(struct run_queue* queue) {
    struct run* entry1 = SIMPLEQ_FIRST(queue);
    while (entry1) {
        struct run* entry2 = SIMPLEQ_NEXT(entry1, entries);
        run_destroy(entry1);
        entry1 = entry2;
    }
    SIMPLEQ_INIT(queue);
}

int run_queue_to_json(const struct run_queue* queue, struct json_object** _json) {
    struct json_object* json = NULL;
    int ret = 0;

    ret = libjson_new_array(&json);
    if (ret < 0)
        return ret;

    struct run* entry = NULL;
    SIMPLEQ_FOREACH(entry, queue, entries) {
        struct json_object* entry_json = NULL;
        ret = run_to_json(entry, &entry_json);
        if (ret < 0)
            goto free;

        ret = libjson_append(json, entry_json);
        if (ret < 0) {
            libjson_free(entry_json);
            goto free;
        }
    }

    *_json = json;
    return ret;

free:
    libjson_free(json);

    return ret;
}

int run_queue_is_empty(const struct run_queue* queue) {
    return SIMPLEQ_EMPTY(queue);
}

void run_queue_add_first(struct run_queue* queue, struct run* entry) {
    SIMPLEQ_INSERT_HEAD(queue, entry, entries);
}

void run_queue_add_last(struct run_queue* queue, struct run* entry) {
    SIMPLEQ_INSERT_TAIL(queue, entry, entries);
}

struct run* run_queue_remove_first(struct run_queue* queue) {
    struct run* entry = SIMPLEQ_FIRST(queue);
    SIMPLEQ_REMOVE_HEAD(queue, entries);
    return entry;
}