#include "line_proto.h"

#include <string.h>
#include <stdlib.h>
#include <assert.h>

#include <err.h>

/*
 * Our state
 */
struct line_proto {
    /* The sock_stream we read/write with */
    struct sock_stream *sock;

    /* The incoming line buffer */
    char *buf;

    /* Incoming buffer size */
    size_t buf_len;

    /* Offset of trailing data in buf */
    size_t tail_offset;

    /* Length of trailing data in buf, if any */
    size_t tail_len;

    /* Last error */
    struct error_info err;

    /* Callback info */
    line_proto_read_cb cb_read;
    void *cb_arg;
};

// function prototypes
static err_t line_proto_schedule_events (struct line_proto *lp, short what);

/*
 * Our sock_stream on_read handler
 */
static void line_proto_on_read (struct sock_stream *sock, void *arg)
{
    struct line_proto *lp = arg;
    const char *line;

    // sanity-check
    assert(lp->tail_offset < lp->buf_len);
    
    do {
        // attempt to read a line
        if (line_proto_read(lp, &line))
            // XXX: fail
            errx(1, "line_proto_read: %s", error_msg(&lp->err));
        
        // got a line?
        if (line)
            lp->cb_read(line, lp->cb_arg);

    } while (line);

    // reschedule
    if (line_proto_schedule_events(lp, EV_READ))
        errx(1, "line_proto_schedule_events: %s", error_msg(&lp->err));
}

/*
 * Schedule our sock_stream callback
 */
static err_t line_proto_schedule_events (struct line_proto *lp, short what) 
{
    // just use sock_stream's interface
    if (sock_stream_event_enable(lp->sock, what))
        RETURN_SET_ERROR_INFO(&lp->err, sock_stream_error(lp->sock));

    return SUCCESS;
}

struct sock_stream_callbacks line_proto_sock_stream_callbacks = {
    .on_read    = &line_proto_on_read,
};

err_t line_proto_create (struct line_proto **lp_ptr, struct sock_stream *sock, size_t buf_size,
        line_proto_read_cb cb_func, void *cb_arg, struct error_info *err)
{
    struct line_proto *lp;

    // allocate
    if ((lp = calloc(1, sizeof(*lp))) == NULL)
        return SET_ERROR(err, ERR_CALLOC);
    
    // allocate buffer
    if ((lp->buf = malloc(buf_size)) == NULL) {
        free(lp);
        return SET_ERROR(err, ERR_CALLOC);
    }

    // store
    lp->sock = sock;
    lp->buf_len = buf_size;
    lp->cb_read = cb_func;
    lp->cb_arg = cb_arg;

    // initialize event-based stuff
    sock_stream_event_init(sock, &line_proto_sock_stream_callbacks, lp);
    line_proto_schedule_events(lp, EV_READ);

    // return
    *lp_ptr = lp;

    return SUCCESS;
}

/*
 * This looks for a full '\r\n' terminated line at the beginning of the given buffer. If found, the \r\n will be
 * replaced with a '\0', and the offset to the beginning of the next line returned. If not found, zero is returned
 * (which is never a valid next-line offset).
 *
 * The given \a hint is an hint as to the offset at which to start scanning, used for incremental invocations of this
 * on the same buffer.
 *
 */
int _parse_line (char *buf, size_t len, size_t *hint) {
    int i;

    // empty buffer -> nothing
    if (len == 0)
        return 0;

    // look for terminating '\r\n' sequence
    for (i = *hint; i < len - 1; i++) {
        // match this + next char
        if (buf[i] == '\r' && buf[i + 1] == '\n')
            break;
    }

    // incomplete?
    if (i >= len - 1) {
        *hint = len - 1;
        return 0;
    }

    // mangle the newline off
    buf[i] = '\0';

    // return offset to next line
    return i + 2;
}

err_t line_proto_read (struct line_proto *lp, const char **line_ptr)
{
    // offset to recv() new data into, offset to _parse_line hint, offset to next line from _parse_line
    size_t recv_offset = 0, peek_offset = 0, next_offset = 0;
    int ret;

    // adjust offset from previous data
    recv_offset = lp->tail_len;

    // move trailing data from previous line to front of buffer
    if (lp->tail_offset) {
        // move to front
        memmove(lp->buf, lp->buf + lp->tail_offset, lp->tail_len);

        // reset
        lp->tail_offset = 0;
        lp->tail_len = 0;
    }

    // readline loop
    do {
        // parse any line at the beginning of the buffer
        if ((next_offset = _parse_line(lp->buf, recv_offset, &peek_offset)) > 0) {
            // store a valid *line_ptr
            *line_ptr = lp->buf;
            
            // exit loop and return
            break;
        }

        // ensure there's enough space for the rest of the line
        // XXX: this must be an error, not an assert
        assert(recv_offset < lp->buf_len);
        
        // otherwise, read more data
        if ((ret = sock_stream_read(lp->sock, lp->buf + recv_offset, lp->buf_len - recv_offset)) < 0) {
            // we can special-case EAGAIN, as it's expected
            if (MATCH_ERROR(sock_stream_error(lp->sock), ERR_READ, EAGAIN)) {
                // return a NULL *line_ptr
                *line_ptr = NULL;
                break;

            } else {
                // store and return NULL on errors
                RETURN_SET_ERROR_INFO(&lp->err, sock_stream_error(lp->sock));

            }
        }

        // EOF?
        if (ret == 0)
            return SET_ERROR(&lp->err, ERR_READ_EOF);
        
        // update recv_offset
        recv_offset += ret;

    } while (1);

    // update state for next call
    lp->tail_offset = next_offset;
    lp->tail_len = recv_offset - next_offset;

    // ok
    return SUCCESS;
}

const struct error_info* line_proto_error (struct line_proto *lp)
{
    // return pointer
    return &lp->err;
}