#include <stdlib.h>

#include "lmtp.h"
#include "lmtp_p.h"

static int readline(lmtp_readline_t *rl, int fd, char *buf, size_t buflen)
{
    size_t n;
    ssize_t rc;
    char c = '\0', *cp;

    cp = (char *)buf;
    for (n = 1; n < buflen; n++) {

        /* fetch one character (but read more) */
        rc = 1;
        if (rl->rl_cnt <= 0) {
            if ((rl->rl_cnt = rl->rl_read(fd, rl->rl_buf, LMTP_READLINE_MAXLEN)) < 0)
                rc = -1;
            else if (rl->rl_cnt == 0)
                rc = 0;
            else
                rl->rl_bufptr = rl->rl_buf;
        }
        if (rc == 1) {
            rl->rl_cnt--;
            c = *rl->rl_bufptr++;
        }

        /* act on fetched character */
        if (rc == 1) {
            if (c == '\r') {
                n--;
                continue;
            }
            *cp++ = c;
            if (c == '\n')
                break;
        }
        else if (rc == 0) {
            if (n == 1)
                return 0;
            else
                break;
        }
        else
            return -1;
    }
    *cp = '\0';
    return n;
}

lmtp_t *lmtp_create(int rfd, int wfd, lmtp_io_t *io)
{
    lmtp_t *lmtp = NULL;

    if ((lmtp = (lmtp_t *)malloc(sizeof(lmtp_t))) == NULL) 
        return NULL;
    lmtp->io.select = select;
    lmtp->io.read = read;
    lmtp->io.write = write;
    lmtp->rl.rl_cnt = 0;
    lmtp->rl.rl_bufptr = NULL;
    lmtp->rl.rl_read = lmtp->io.read;
    /* lmtp->dispatch = ... */
    return lmtp;
}

void lmtp_destroy(lmtp_t *lmtp)
{
    return;
}

lmtp_rc_t lmtp_request(lmtp_t *lmtp, lmtp_req_t *req)
{
    lmtp_rc_t rc = LMTP_OK;
    return rc;
}

lmtp_rc_t lmtp_result(lmtp_t *lmtp, lmtp_res_t *res)
{
    lmtp_rc_t rc = LMTP_OK;
    return rc;
}

char **lmtp_message(lmtp_t *lmtp, char *verb)
{
    char **cpp = NULL;
    return cpp;
}

void lmtp_reset(lmtp_t *lmtp)
{
    return;
}

char *lmtp_error(lmtp_t *lmtp, lmtp_rc_t rc)
{
    char *str = NULL;
    return str;
}

lmtp_cb_t lmtp_register(lmtp_t *lmtp, char *verb, lmtp_type_t type, lmtp_cb_t *cb, void *ctx)
{
    lmtp_cb_t old = NULL;
    return old;
}

lmtp_rc_t lmtp_loop(lmtp_t *lmtp)
{
    lmtp_req_t req;
    lmtp_res_t res;
    lmtp_rc_t rc;
    int i;

    while ((rc = lmtp_request(lmtp, &req)) == LMTP_OK) {
        for (i = 0; lmtp->dispatch[i]->verb != NULL; i++) {
            if (strcmp(req.verb, lmtp->dispatch[i]->verb) == 0) {
                lmtp->dispatch[i]->cb(&lmtp->io, &req, &res, lmtp->dispatch[i]->cbctx);
                if ((rc = lmtp_result(lmtp, &res)) != LMTP_OK)
                    return rc;
            }
        }
    }
    return rc;
}