#include <apr_bucket_nginx.h>

static apr_status_t nginx_bucket_read(apr_bucket *b, const char **str,
                                      apr_size_t *len, apr_read_type_e block);
static void nginx_bucket_destroy(void *data);

static const apr_bucket_type_t apr_bucket_type_nginx = {
    "NGINX", 5, APR_BUCKET_DATA,
    nginx_bucket_destroy,
    nginx_bucket_read,
    apr_bucket_setaside_noop,
    apr_bucket_shared_split,
    apr_bucket_shared_copy
};


typedef struct apr_bucket_nginx {
    apr_bucket_refcount  refcount;
    ngx_buf_t           *buf;
} apr_bucket_nginx;

/* ngx_buf_t to apr_bucket */
apr_bucket * apr_bucket_nginx_create(ngx_buf_t *buf,
                                     apr_pool_t *p,
                                     apr_bucket_alloc_t *list)
{

    apr_bucket *b = apr_bucket_alloc(sizeof(*b), list);

    APR_BUCKET_INIT(b); /* link */
    b->free = apr_bucket_free;
    b->list = list;
    return apr_bucket_nginx_make(b, buf, p);
}

apr_bucket * apr_bucket_nginx_make(apr_bucket *b, ngx_buf_t *buf,
                                   apr_pool_t *pool)
{
    apr_bucket_nginx *n;

    n = apr_bucket_alloc(sizeof(*n), b->list);

    n->buf = buf;

    b = apr_bucket_shared_make(b, n, 0, ngx_buf_size(buf));
    b->type = &apr_bucket_type_nginx;
    return b;
}

static apr_status_t nginx_bucket_read(apr_bucket *b, const char **str,
                                      apr_size_t *len, apr_read_type_e block)
{
    apr_bucket_nginx *n = b->data;
    ngx_buf_t        *buf = n->buf;
    u_char           *data;
    ssize_t           size;

    if (buf->pos == NULL && ngx_buf_size(buf) != 0) {
        data = apr_bucket_alloc(ngx_buf_size(buf), b->list);
        if (data == NULL) {
            return APR_EGENERAL;
        }

        size = ngx_read_file(buf->file, data, ngx_buf_size(buf), buf->file_pos);
        if (size != ngx_buf_size(buf)) {
            apr_bucket_free(data);
            return APR_EGENERAL;
        }
        buf->pos = data;
    }

    *str = (char *)buf->pos + b->start;
    *len = b->length;

    return APR_SUCCESS;
}


static void nginx_bucket_destroy(void *data)
{
    apr_bucket_nginx *n = data;
    ngx_buf_t *buf = n->buf;

    if (apr_bucket_shared_destroy(n)) {
        if (!ngx_buf_in_memory(buf) && buf->pos != NULL) {
            apr_bucket_free(buf->pos);
            buf->pos = NULL;
        }
        apr_bucket_free(n);
    }
}

ngx_buf_t * apr_bucket_to_ngx_buf(apr_bucket *e, ngx_pool_t *pool) {
    ngx_buf_t         *buf, *b;
    apr_bucket_nginx  *n;
    ngx_uint_t         len;
    u_char            *data;

    if (e->type->is_metadata) {
        return NULL;
    }

    if (e->type == &apr_bucket_type_nginx) {
        n = e->data;
        b = n->buf;

        /* whole buf */
        if (e->length == (apr_size_t)ngx_buf_size(b)) {
            b->last_buf = 0;
            return b;
        }

        buf = ngx_palloc(pool, sizeof(ngx_buf_t));
        if (buf == NULL) {
            return NULL;
        }
        ngx_memcpy(buf, b, sizeof(ngx_buf_t));

        if (ngx_buf_in_memory(buf)) {
            buf->start = buf->pos = buf->pos + e->start;
            buf->end = buf->last = buf->pos + e->length;
        } else {
            buf->pos = NULL;
            buf->file_pos += e->start;
            buf->file_last = buf->file_pos + e->length;
        }

        buf->last_buf = 0;
        return buf;
    }

    if (apr_bucket_read(e, (const char **)&data,
                        &len, APR_BLOCK_READ) != APR_SUCCESS) {
        return NULL;
    }

    buf = ngx_calloc_buf(pool);
    if (buf == NULL) {
        return NULL;
    }

    if (e->type == &apr_bucket_type_pool) {
        buf->start = data;
    } else if (len != 0) {
        buf->start = ngx_palloc(pool, len);
        ngx_memcpy(buf->start, data, len);
    }

    buf->pos = buf->start;
    buf->end = buf->last = buf->start + len;
    buf->temporary = 1;
    return buf;
}

ngx_int_t
move_chain_to_brigade(ngx_chain_t *chain, apr_bucket_brigade *bb, ngx_pool_t *pool, ngx_int_t last_buf) {
    apr_bucket         *e;
    ngx_chain_t        *cl;

    while (chain) {
        e = ngx_buf_to_apr_bucket(chain->buf, bb->p, bb->bucket_alloc);
        if (e == NULL) {
            return NGX_ERROR;
        }

        APR_BRIGADE_INSERT_TAIL(bb, e);
        if (chain->buf->last_buf) {
            e = apr_bucket_eos_create(bb->bucket_alloc);
            APR_BRIGADE_INSERT_TAIL(bb, e);
            chain->buf->last_buf = 0;
            return NGX_OK;
        }
        cl = chain;
        chain = chain->next;
        ngx_free_chain(pool, cl);
    }

    if (last_buf) {
        e = apr_bucket_eos_create(bb->bucket_alloc);
        APR_BRIGADE_INSERT_TAIL(bb, e);
        return NGX_OK;
    }

    return NGX_AGAIN;
}

ngx_int_t
move_brigade_to_chain(apr_bucket_brigade *bb, ngx_chain_t **ll, ngx_pool_t *pool) {
    apr_bucket  *e;
    ngx_buf_t   *buf;
    ngx_chain_t *cl;

    cl = NULL;

    if (APR_BRIGADE_EMPTY(bb)) {
        *ll = NULL;
        return NGX_OK;
    }

    for (e = APR_BRIGADE_FIRST(bb);
            e != APR_BRIGADE_SENTINEL(bb);
            e = APR_BUCKET_NEXT(e)) {

        if (APR_BUCKET_IS_EOS(e)) {
            if (cl == NULL) {
                cl = ngx_alloc_chain_link(pool);
                if (cl == NULL) {
                    break;
                }
                
                cl->buf = ngx_calloc_buf(pool);
                if (cl->buf == NULL) {
                    break;
                }

                cl->buf->last_buf = 1;
                *ll = cl;
            } else {
                cl->buf->last_buf = 1;
            }
            apr_brigade_cleanup(bb);
            return NGX_OK;
        }

        if (APR_BUCKET_IS_METADATA(e)) {
            continue;
        }

        buf = apr_bucket_to_ngx_buf(e, pool);
        if (buf == NULL) {
            break;
        }

        cl = ngx_alloc_chain_link(pool);
        if (cl == NULL) {
            break;
        }

        cl->buf = buf;
        cl->next = NULL;
        *ll = cl;
        ll = &cl->next;
    }

    apr_brigade_cleanup(bb);
    /* no eos or error */
    return NGX_ERROR;
}