#include <errno.h>
#include <stdlib.h>

#include "preason.h"
#include "utils.h"

void erase_job_preason(xce_job_preason_t* reasons)
{
    if (reasons == NULL) {
        return;
    }

    if (reasons->host_based_reasons != NULL) {
        int i;

        for (i = 0; i < reasons->nhost_reasons; i++) {
            if (reasons->host_based_reasons[i] != NULL) {
                FREEUP(reasons->host_based_reasons[i]->host);
                FREEUP(reasons->host_based_reasons[i]);
            }
        }

        FREEUP(reasons->host_based_reasons);
        reasons->nhost_reasons = 0;
    }

    if (reasons->res_based_reasons != NULL) {
        int i;

        for (i = 0; i < reasons->nres_reasons; i++) {
            if (reasons->res_based_reasons[i] == NULL) {
                continue;
            }

            FREEUP(reasons->res_based_reasons[i]->resource);
            FREEUP(reasons->res_based_reasons[i]->host);
            FREEUP(reasons->res_based_reasons[i]);
        }

        FREEUP(reasons->res_based_reasons);
        reasons->nres_reasons = 0;
    }

    reasons->main_reason = 0;
}

static int add_host_preason(xce_job_preason_t* reasons, int code, char* host)
{
    xce_host_reason_t** p;
    xce_host_reason_t*  p1;
    char*               h;
    int                 count;

    if ((reasons == NULL) || (host == NULL)) {
        return -EINVAL;
    }

    h = strdup(host);
    if (h == NULL) {
        return -ENOMEM;
    }

    p1 = (xce_host_reason_t*)calloc(1, sizeof(*p1));
    if (p1 == NULL) {
        FREEUP(h);
        return -ENOMEM;
    }

    p1->reason = code;
    p1->host   = h;

    count = reasons->nhost_reasons;
    p     = (xce_host_reason_t**)realloc(reasons->host_based_reasons,
                                         (count + 1) * sizeof(xce_host_reason_t*));
    if (p == NULL) {
        FREEUP(h);
        FREEUP(p1);
        return -ENOMEM;
    }

    reasons->host_based_reasons        = p;
    reasons->host_based_reasons[count] = p1;
    reasons->nhost_reasons++;

    return reasons->nhost_reasons;
}

static int add_res_preason(xce_job_preason_t* reasons, int code, char* host,
                           char* res)
{
    xce_res_reason_t** p;
    char*              h;
    char*              r;
    int                count;
    xce_res_reason_t*  p1;

    if ((reasons == NULL) || (host == NULL) || (res == NULL)) {
        return -EINVAL;
    }

    h  = strdup(host);
    r  = strdup(res);
    p1 = (xce_res_reason_t*)calloc(1, sizeof(*p1));

    if ((h == NULL) || (r == NULL) || (p1 == NULL)) {
        FREEUP(h);
        FREEUP(r);
        FREEUP(p1);
        return -ENOMEM;
    }

    p1->host     = h;
    p1->resource = r;
    p1->reason   = code;

    count = reasons->nres_reasons;
    p     = (xce_res_reason_t**)realloc(reasons->res_based_reasons,
                                        (count + 1) * sizeof(*p));
    if (p == NULL) {
        FREEUP(h);
        FREEUP(r);
        FREEUP(p1);

        return -ENOMEM;
    }

    reasons->res_based_reasons        = p;
    reasons->res_based_reasons[count] = p1;

    reasons->nres_reasons++;

    return reasons->nres_reasons;
}

int add_job_preason(xce_job_preason_t* reasons, int code, char* host, char* res)
{
    int rc = 0;

    if ((host == NULL) && (res == NULL)) {
        /* set main reason */
        erase_job_preason(reasons);
        reasons->main_reason = code;
    } else if (res == NULL) {
        /* set host reason */
        rc = add_host_preason(reasons, code, host);
    } else {
        /* set resource reason */
        rc = add_res_preason(reasons, code, host, res);
    }

    return rc;
}

xce_pendreason_t *make_pendreason(uint64_t jobid) {
    xce_pendreason_t *reason = NULL;
    xce_job_preason_t *preason =  NULL;

    preason = (xce_job_preason_t *)calloc(1, sizeof(*preason));
    reason = (xce_pendreason_t*)calloc(1, sizeof(*reason));

    if ((preason == NULL) || (reason == NULL)) {
        FREEUP(reason);
        FREEUP(preason);

        return NULL;
    }

    reason->jobid = jobid;
    reason->reasons = preason;

    return reason;
}