#include <assert.h>
#include <err.h>
#include <errno.h>
#include <libprop/proplib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "trivial.h"
#include "plotter.h"

struct ploticus_plot {
        unsigned type;
        prop_dictionary_t params;
        FILE *fp;
        char *path;
};

struct ploticus_plotter {
        int nr_plots;
        struct ploticus_plot **plots;
        const char *basepath;
};

const char *plot_prefabs[] = {
        [PLOT_TYPE_HIST] = "dist",
        [PLOT_TYPE_LINE] = "lines",
};

static
void *
ploticus_init(const char *base)
{
        struct ploticus_plotter *ctx;

        if (!(ctx = calloc(1, sizeof(*ctx))))
                return ctx;
        if (!(ctx->basepath = strdup(base)))
                goto free_ctx;
        return ctx;
free_ctx:
        free(ctx);
        return NULL;
}

static
int
ploticus_new_plot_hist(struct ploticus_plot *plot)
{
        prop_dictionary_t params = plot->params;
        prop_string_t str;

        if (!(str = prop_string_create_cstring_nocopy("1")))
                return !0;
        if (!prop_dictionary_set(params, "x", str)) {
                prop_object_release(str);
                return !0;
        }
        if (!(str = prop_string_create_cstring_nocopy("yes")))
                return !0;
        if (!prop_dictionary_set(params, "curve", str)) {
                prop_object_release(str);
                return !0;
        }
        return 0;
}

static
int
ploticus_new_plot_line(struct ploticus_plot *plot)
{
        prop_dictionary_t params = plot->params;
        prop_string_t str;

        if (!(str = prop_string_create_cstring_nocopy("1")))
                return !0;
        if (!prop_dictionary_set(params, "x", str)) {
                prop_object_release(str);
                return !0;
        }
        if (!(str = prop_string_create_cstring_nocopy("2")))
                return !0;
        if (!prop_dictionary_set(params, "y", str)) {
                prop_object_release(str);
                return !0;
        }
        return 0;
}

int (*plot_type_initializers[])(struct ploticus_plot *) = {
        [PLOT_TYPE_HIST] = ploticus_new_plot_hist,
        [PLOT_TYPE_LINE] = ploticus_new_plot_line,
};

static
plotid_t
ploticus_new_plot(void *_ctx, enum plot_type type, const char *title)
{
        struct ploticus_plot *plot;
        prop_dictionary_t params;
        prop_string_t str;
        struct ploticus_plotter *ctx = _ctx;
        struct ploticus_plot **tmp;
        char *datapath;

        if ((type <= PLOT_TYPE_START) || (type >= PLOT_TYPE_END))
                return -1;
        if (!(tmp = realloc(ctx->plots, sizeof(struct ploticus_plot *) *
                            (ctx->nr_plots + 1))))
                return -1;
        ctx->plots = tmp;

        if (!(params = prop_dictionary_create()))
                return -1;
        if (!(plot = calloc(1, sizeof(*plot))))
                goto free_params;
        plot->params = params;
        plot->type = type;

        if (asprintf(&plot->path, "%s-%d-%s", ctx->basepath, type,
                     title) < 0)
                goto free_plot;
        if (asprintf(&datapath, "%s.data", plot->path) < 0)
                goto free_path;

        if (!(str = prop_string_create_cstring(title)))
                goto free_datapath;
        if (!prop_dictionary_set(params, "title", str)) {
                prop_object_release(str);
                goto free_datapath;
        }
        if (!(str = prop_string_create_cstring(datapath)))
                goto free_datapath;
        if (!prop_dictionary_set(params, "data", str)) {
                prop_object_release(str);
                goto free_datapath;
        }

        if (plot_type_initializers[type](plot))
                goto free_datapath;
        if (!(plot->fp = fopen(datapath, "w"))) {
                goto free_datapath;
        }
        free(datapath);
        ctx->plots[ctx->nr_plots] = plot;
        return ctx->nr_plots++;

free_datapath:
        free(datapath);
free_path:
        free(plot->path);
free_plot:
        free(plot);
free_params:
        prop_object_release(params);
        return -1;
}

static
int
ploticus_plot_histogram(void *_ctx, plotid_t id, double val)
{
        struct ploticus_plotter *ctx = _ctx;
        struct ploticus_plot *plot;

        if ((id < 0) || (id >= ctx->nr_plots))
                return ERANGE;
        plot = ctx->plots[id];
        assert(plot != NULL);

        fprintf(plot->fp, "%lf\n", val);

        return 0;
}

static
int
ploticus_plot_line(void *_ctx, plotid_t id, double x, double y)
{
        struct ploticus_plotter *ctx = _ctx;
        struct ploticus_plot *plot;

        if ((id < 0) || (id >= ctx->nr_plots))
                return ERANGE;
        plot = ctx->plots[id];
        assert(plot != NULL);

        fprintf(plot->fp, "%lf %lf\n", x, y);

        return 0;
}

extern char **environ;

static
void
ploticus_run(struct ploticus_plot *plot)
{
        unsigned nr_params;
        const char **pl_argv;
        prop_object_iterator_t it;
        prop_object_t key, val;
        const char *keystr;
        const char *output_format = "-svg";
        int i;

        printd(PLOT, "ploticus_run\n");
        nr_params = prop_dictionary_count(plot->params);
        if (!(pl_argv = calloc(nr_params +
                               1 +      /* progname */
                               1 +      /* trailing NULL */
                               1 +      /* -prefab */
                               1 +      /* dist */
                               1 +      /* output format */
                               1 +      /* -o */
                               1        /* outpath */
                               , sizeof(char *))))
                err(1, "can't allocate argv");
        if (!(it = prop_dictionary_iterator(plot->params)))
                err(1, "can't allocate dictionary iterator");
        pl_argv[0] = "ploticus";
        pl_argv[1] = "-prefab";
        pl_argv[2] = plot_prefabs[plot->type];
        pl_argv[2 + nr_params + 1] = output_format;
        pl_argv[2 + nr_params + 2] = "-o";
        if (asprintf(__DECONST(char **, &pl_argv[2 + nr_params + 3]),
                     "%s.svg", plot->path) < 0)
                err(1, "Can't allocate args");
        key = prop_object_iterator_next(it);
        for (i = 3; key; ++i, key = prop_object_iterator_next(it)) {
                keystr = prop_dictionary_keysym_cstring_nocopy(key);
                assert(keystr != NULL);
                val = prop_dictionary_get_keysym(plot->params, key);
                assert(val != NULL);
                printd(PLOT, "%s=%s\n", keystr,
                       prop_string_cstring_nocopy(val));
                if (asprintf(__DECONST(char **, &pl_argv[i]), "%s=%s", keystr,
                             prop_string_cstring_nocopy(val)) < 0)
                        err(1, "can't allocate exec arguments");
        }
        prop_object_iterator_release(it);
        printd(PLOT, "about to exec with args:\n");
        for (i = 0; pl_argv[i]; ++i)
                printd(PLOT, "%s\n", pl_argv[i]);
        execve("/usr/local/bin/ploticus", __DECONST(char * const *, pl_argv), environ);
        err(1, "failed to exec ploticus");
}

static
int
ploticus_plot_generate(struct ploticus_plot *plot)
{
        pid_t pid;
        int status;

        fclose(plot->fp);

        switch ((pid = fork())) {
        case -1:
                return -1;
        case 0: /* child */
                ploticus_run(plot);
                assert(!"can't get here");
        }
        /* parent */
        if (waitpid(pid, &status, 0) != pid)
                err(1, "waitpid() failed");
        if (!WIFEXITED(status))
                warn("ploticus did not exit!");
        if (WEXITSTATUS(status))
                warn("ploticus did not run successfully");
        return 0;
}

static
int
ploticus_plot_finish(void *_ctx)
{
        struct ploticus_plotter *ctx = _ctx;
        int i;

        for (i = 0; i < ctx->nr_plots; ++i) {
                if (ploticus_plot_generate(ctx->plots[i]))
                        return -1;
        }
        return 0;
}

static struct plotter ploticus_plotter = {
        .plot_init = ploticus_init,
        .plot_new = ploticus_new_plot,
        .plot_histogram = ploticus_plot_histogram,
        .plot_line = ploticus_plot_line,
        .plot_finish = ploticus_plot_finish,
};

static const char *ploticus_path = "/usr/local/bin/ploticus";

struct plotter *
plotter_factory(void)
{
        struct stat st;
        if ((!stat(ploticus_path, &st)) &&
            S_ISREG(st.st_mode) &&
            (st.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH)))
                return &ploticus_plotter;
        warnx("%s does not exist or is not an executable file", ploticus_path);
        return NULL;
}