#include <stdlib.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>

#include <event2/event.h>
#include <event2/bufferevent.h>

#include "render_remote.h"
#include "common.h"

struct remote_render_ctx {
    struct event *ev_conn;
    struct bufferevent *data_bev;

    struct remote_node *remote_node;

    #pragma pack(push)
    #pragma pack(1)

    struct {
        u_int8_t    mode;

        u_int32_t   img_w;
        u_int32_t   img_h;

        double      x1;
        double      y1;
        double      x2;
        double      y2;
    } render_cmd;

    #pragma pack(pop)

    void (*cb_sent)(void *arg);
    void (*cb_data)(struct evbuffer *buf, void *arg);
    void (*cb_done)(void *arg);
    void (*cb_fail)(void *arg);

    void *cb_arg;
};

void _remote_render_ctx_free (struct remote_render_ctx *ctx) {
    // close the socket (ctx->ev_conn remains valid even after we're done with it...)
    close(event_get_fd(ctx->ev_conn));
    
    // free the connect event
    event_free(ctx->ev_conn);

    // free the data_bev
    if (ctx->data_bev) {
        bufferevent_free(ctx->data_bev);
        ctx->data_bev = NULL;
    }

    // update remote_node load
    ctx->remote_node->current_load--;
    
    // free the context structure
    free(ctx);
    
    ctx = NULL;
}

#define RENDER_FAILED(ctx, desc) \
    do {                                        \
        perror(desc);                           \
        ctx->cb_fail(ctx->cb_arg);              \
        _remote_render_ctx_free(ctx);          \
        return;                                 \
    } while (0)

void _remote_write (struct bufferevent *bev, void *arg) {
    struct remote_render_ctx *ctx = arg;

    // the write buffer was drained, so the render command was sent
    ctx->cb_sent(ctx->cb_arg);
    
    // we don't care about EV_WRITE anymore
    if (bufferevent_disable(ctx->data_bev, EV_WRITE))
        RENDER_FAILED(ctx, "render_remote: bufferevent_disable");

    // start receiving data
    if (bufferevent_enable(ctx->data_bev, EV_READ))
        RENDER_FAILED(ctx, "render_remote: bufferevent_enable");
}

void _remote_read (struct bufferevent *bev, void *arg) {
    struct remote_render_ctx *ctx = arg;
    
    // pass the bufferevent's input buffer to our callback - libevent doesn't provide any function to access this, but hopefully this works correctly
    ctx->cb_data(EVBUFFER_INPUT(bev), ctx->cb_arg);
}

void _remote_error (struct bufferevent *bev, short what, void *arg) {
    struct remote_render_ctx *ctx = arg;

    // OH NOES; WHAT DO WE DO!?
    
    if (what & EVBUFFER_EOF) {
        // great!
        
        // send any remaining-chunk data
        if (EVBUFFER_LENGTH(EVBUFFER_INPUT(bev)) > 0)
            ctx->cb_data(EVBUFFER_INPUT(bev), ctx->cb_arg);

        // signal completion
        ctx->cb_done(ctx->cb_arg);

    } else if (what & EVBUFFER_ERROR) {
        // crap.
        perr("render_remote");

        ctx->cb_fail(ctx->cb_arg);

    } else if (what & EVBUFFER_TIMEOUT) {
        // ah well
        error("render_remote: timeout");

        ctx->cb_fail(ctx->cb_arg);

    } else {
        err_exit("weird bufferevent error code: 0x%02X", what);
    }

    // free resources
    _remote_render_ctx_free(ctx);
}

void _remote_connected (int fd, short event, void *arg) {
    struct remote_render_ctx *ctx = arg;

    // set up the read/write bufferevent
    if ((ctx->data_bev = bufferevent_new(fd, &_remote_read, &_remote_write, &_remote_error, ctx)) == NULL)
        RENDER_FAILED(ctx, "render_remote: bufferevent_new");

    // write the render command
    if (bufferevent_write(ctx->data_bev, &ctx->render_cmd, sizeof(ctx->render_cmd)))
        RENDER_FAILED(ctx, "render_remote: bufferevent_write");

    // wait for it to be written out
    if (bufferevent_enable(ctx->data_bev, EV_WRITE))
        RENDER_FAILED(ctx, "render_remote: bufferevent_enable");
}

void render_cmd_build (render_t *rctx, struct remote_render_ctx *rrctx) {
    // just copy over the render params to the render_cmd
    rrctx->render_cmd.mode = rctx->mode;
    rrctx->render_cmd.img_w = htonl(rctx->img_w);
    rrctx->render_cmd.img_h = htonl(rctx->img_h);
    rrctx->render_cmd.x1 = rctx->x1;
    rrctx->render_cmd.y1 = rctx->y1;
    rrctx->render_cmd.x2 = rctx->x2;
    rrctx->render_cmd.y2 = rctx->y2;
}

struct remote_render_ctx *render_remote (
        render_t *render_ctx,
        struct remote_node *remote_node,
        void (*cb_sent)(void *arg),
        void (*cb_data)(struct evbuffer *buf, void *arg),
        void (*cb_done)(void *arg),
        void (*cb_fail)(void *arg),
        void *cb_arg
) {    
    printf("render_remote: remote render load: %d/%d\n", remote_node->current_load, remote_node->parallel_renders);

    // alloc the remote render ctx
    struct remote_render_ctx *ctx = malloc(sizeof(struct remote_render_ctx));

    if (!ctx) {
        error("render_remote: malloc");
        return NULL;
    }
    
    // store the provided callback functions
    ctx->cb_sent = cb_sent;
    ctx->cb_data = cb_data;
    ctx->cb_done = cb_done;
    ctx->cb_fail = cb_fail;
    ctx->cb_arg = cb_arg;

    // keep a reference to remote_node so we can decr it's load
    ctx->remote_node = remote_node;
    
    // copy the relevant stuff from the render_ctx
    render_cmd_build(render_ctx, ctx);
    
    // create the socket
    int sock = socket(remote_node->addr.ss_family, SOCK_STREAM, 0);

    if (sock < 0) {
        perror("render_remote: socket");
        goto error;
    }

    // mark it as nonblocking
    if (fcntl(sock, F_SETFL, O_NONBLOCK) == -1) {
        perror("render_remote: fcntl");
        goto error;
    }
    
    // initiate the connect
    int err = connect(sock, (struct sockaddr *) &remote_node->addr, sizeof(remote_node->addr));

    if (err != -1 || errno != EINPROGRESS) {
        perror("render_remote: connect");
        goto error;
    }

    // do the libevent dance
    ctx->ev_conn = event_new(NULL, sock, EV_WRITE, &_remote_connected, ctx);

    if (!ctx->ev_conn) {
        error("render_remote: event_new");
        goto error;
    }

    if (event_add(ctx->ev_conn, NULL)) {
        error("render_remote: event_add");
        goto error;
    }

    // update remote_node load
    remote_node->current_load++;
    
    // success
    return ctx;

error:
    free(ctx);

    if (sock > 0)
        close(sock);

    return NULL;
}

int render_remote_set_recv (struct remote_render_ctx *ctx, size_t recv_threshold, size_t unread_buffer) {
    if (ctx->data_bev == NULL)
        return -1;

    bufferevent_setwatermark(ctx->data_bev, EV_READ, recv_threshold, recv_threshold + unread_buffer);

    return 0;
}

int render_remote_shake (struct remote_render_ctx *ctx) {
    if (ctx->data_bev == NULL)
        return -1;

    ctx->cb_data(EVBUFFER_INPUT(ctx->data_bev), ctx->cb_arg);

    return 0;
}

void render_remote_cancel (struct remote_render_ctx *ctx) {
    // if it's still just connecting, cancel that
    if (event_pending(ctx->ev_conn, EV_WRITE, NULL)) {
        event_del(ctx->ev_conn);
    }
    
    // this takes care of the rest
    _remote_render_ctx_free (ctx);
}