#ifndef RENDER_REMOTE_H
#define RENDER_REMOTE_H

#include <event2/util.h>
#include <event2/buffer.h>

#include "render.h"

/*
 * Execute a render_t operation on a remote render_node
 */


#define RENDER_PORT 6159

struct remote_render_ctx;

/*
 * Execute the given render operation on the render_node at the given remote address.
 *
 * The various callback functions must all be provided.
 *
 * cb_sent will be invoked after the request has succesfully been written, and before cb_data is called.
 * cb_data is called whenever new data has been received. See also, render_remote_set_chunk_size
 * cb_done is called when all the data has been passed to cb_data
 * cb_fail is called when an error is encountered. This can (and will) happen at any time!
 */
struct remote_render_ctx *render_remote (
        struct event_base *evbase,
        render_t *render_ctx,               // what to render
        struct sockaddr_storage *remote,    // what render node to use
        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;
);

/*
 * Cancel the given request. No more callbacks will be called, buffered data is discarded and the remote render process will cancel asap.
 */
void render_remote_cancel (struct remote_render_ctx *ctx);

/*
 * If you don't want to receive the rendered data one byte at a time, you can set a minimum chunk size.
 *
 * cb_done will only be called when the buffer contains at least chunk_size bytes, or no more data is available (cb_done will be called next).
 *
 * overflow_buffer is how many bytes will be buffered, at most, in addition to chunk_size (in case rendering is paused). After that, the render node will start to block.
 *
 * Only call this once cb_sent has fired
 */
int render_remote_set_chunk_size (struct remote_render_ctx *ctx, size_t chunk_size, size_t overflow_buffer);

#endif /* RENDER_REMOTE_H */