#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <unistd.h>

#include "al.h"
#include "sio.h"
#include "sio_module.h"

#include "sa.h"

typedef struct {
    char *mem;
    size_t size;
} buffer_t;

typedef struct {
    sa_t *sa;
    buffer_t input;
    size_t written;
    void *label_data;
    void *label_error;
    void *label_eof;
    char eof;
    char error;
} private_t;

/*
 * create stage
 *
 * allocate private instance data
 */
static
sio_rc_t sa_init(sio_t *sio, void **u)
{
    private_t *my;
    
    my = (private_t *)malloc(sizeof(private_t));
    if (my == NULL)
        return SIO_ERR_MEM;

    my->sa           = NULL;

    my->input.mem    = NULL;
    my->input.size   = 0;

    sio_label(sio, SIO_LN_DATA,  &my->label_data);
    sio_label(sio, SIO_LN_ERROR, &my->label_error);
    sio_label(sio, SIO_LN_EOF,   &my->label_eof);

    my->eof   = '\0';
    my->error = '\0';

    *u = my;

    return SIO_OK;
}

/*
 * configure stage
 *
 */
static
sio_rc_t sa_configure(sio_t *sio, void *u, void *obj, void *val)
{
    private_t *my = (private_t *)u;
    const char *name = (const char *)obj;

    if (!strcmp(name, "sa")) {
        my->sa = (sa_t *)val;
    } else if (!strcmp(name, "buflen")) {
        my->input.size = *(size_t *)val;
    } else {
        return SIO_ERR_ARG;
    }

    return SIO_OK;
}

/*
 * destroy stage
 */
static
sio_rc_t sa_cleanup(sio_t *sio, void *u)
{
    return SIO_OK;
}

static
sio_rc_t sa_openr(sio_t *sio, al_t *al, void *u)
{
    private_t *my = (private_t *)u;
    buffer_t *buf = &my->input;
    char *p;
    size_t n;

    n = buf->size;
    p = realloc(buf->mem, n);
    if (p != NULL)
        buf->mem = p;

    if (buf->mem == NULL)
        return SIO_ERR_MEM;

    return SIO_OK;
}

static
sio_rc_t sa_closer(sio_t *sio, al_t *al, void *u)
{
    private_t *my = (private_t *)u;
    buffer_t *buf = &my->input;

    if (buf->mem != NULL) {
        free(buf->mem);
        buf->mem = NULL;
    }

    return SIO_OK;
}

static
sio_rc_t sa_openw(sio_t *sio, al_t *al, void *u)
{
    return SIO_OK;
}

static
sio_rc_t sa_closew(sio_t *sio, al_t *al, void *u)
{
    return SIO_OK;
}

static
void sa_writeeof(al_t *al, private_t *my)
{
    al_splice(al, 0, al_bytes(al), NULL, NULL);
    al_append_bytes(al, &my->eof, sizeof(my->eof), my->label_eof);
}

static
void sa_writeerror(al_t *al, private_t *my)
{
    al_splice(al, 0, al_bytes(al), NULL, NULL);
    al_append_bytes(al, &my->error, sizeof(my->error), my->label_error);
}

static
sio_rc_t sa_input(sio_t *sio, al_t *al, void *u)
{
    private_t *my = (private_t *)u;
    buffer_t *buf = &my->input;
    size_t actual;
    sa_rc_t src;

    src = sa_read(my->sa, buf->mem, buf->size, &actual);
    if (src != SA_OK) {
        sa_writeerror(al, my);
        return SIO_DOWNSTREAM;
    } else if (src == SA_ERR_EOF) {
        sa_writeeof(al, my);
        return SIO_DOWNSTREAM;
    }

    al_append_bytes(al, buf->mem, actual, my->label_data);

    return SIO_DOWNSTREAM;
}

static
al_rc_t sa_output_chunk(al_chunk_t *alc, void *u)
{
    private_t *my = (private_t *)u;
    char   *p;
    size_t n, actual;
    sa_rc_t src;

    p = al_chunk_ptr(alc, 0);
    n = al_chunk_len(alc);

    src = sa_write(my->sa, p, n, &actual);
    if (src != SA_OK)
        return AL_ERR_EOF;

    my->written += actual; /* XXX not used */

    return AL_OK;
}

static
sio_rc_t sa_output(sio_t *sio, al_t *al, void *u)
{
    private_t *my = (private_t *)u;
    al_rc_t arc;
    size_t n = al_bytes(al);

    my->written = 0;

    arc = al_traverse_cb(al, 0, n, AL_FORWARD, my->label_data,
                         sa_output_chunk, u);
    if (arc != AL_OK) return SIO_ERR_INT;

    arc = al_splice(al, 0, al_bytes(al), NULL, NULL);
    if (arc != AL_OK) return SIO_ERR_INT;

    return SIO_DOWNSTREAM;
}

sio_module_t sio_module_sa = {
    "sa",
    sa_init,
    sa_configure,
    sa_cleanup,
    sa_openr,
    sa_closer,
    sa_openw,
    sa_closew,
    sa_input,
    sa_output
};