/* $%BEGINLICENSE%$
 Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved.

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License as
 published by the Free Software Foundation; version 2 of the
 License.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 02110-1301  USA

 $%ENDLICENSE%$ */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "glib-ext.h"
#include "network-queue.h"
#include "network-mysqld-proto.h"

network_queue *
network_queue_new()
{
    network_queue *queue;

    queue = g_new0(network_queue, 1);

    queue->chunks = g_queue_new();

    return queue;
}

void
network_queue_free(network_queue *queue)
{

    if (!queue)
        return;

    GString *packet;
    while ((packet = g_queue_pop_head(queue->chunks))) {
        g_string_free(packet, TRUE);
    }

    g_queue_free(queue->chunks);

    g_free(queue);
}

void
network_queue_clear(network_queue *queue)
{
    if (!queue)
        return;

    GString *packet;
    while ((packet = g_queue_pop_head(queue->chunks)) != NULL) {
        g_string_free(packet, TRUE);
    }
    queue->len = queue->offset = 0;
}

int
network_queue_append(network_queue *queue, GString *s)
{
    if (s->len == 0) {
        g_warning("%s: packet len:%d", G_STRLOC, (int)s->len);
    }

    if (s->len > PACKET_LEN_MAX) {
        g_warning("%s: packet len:%d is too long", G_STRLOC, (int)s->len);
    }

    queue->len += s->len;

    g_queue_push_tail(queue->chunks, s);

    return 0;
}

/**
 * get a string from the head of the queue and leave the queue unchanged 
 *
 * @param  queue the queue to read from
 * @param  peek_len  bytes to collect
 * @param  dest      GString to write it. If NULL, we allow a new one and return it
 * @return NULL if not enough data
 *         if dest is not NULL, dest, otherwise a new GString containing the data
 */
GString *
network_queue_peek_str(network_queue *queue, gsize peek_len, GString *dest)
{
    gsize we_want = peek_len;
    GList *node;

    /* 
     * TODO: convert to DTrace probe
     * g_debug("[%s] looking for %d bytes, queue has %d", G_STRLOC, peek_len, queue->len);
     */
    if (queue->len < peek_len) {
        return NULL;
    }

    if (!dest) {
        /* no define */
        dest = g_string_sized_new(calculate_alloc_len(peek_len));
    }

    g_assert_cmpint(dest->allocated_len, >, peek_len);

    for (node = queue->chunks->head; node && we_want; node = node->next) {
        GString *chunk = node->data;

        if (node == queue->chunks->head) {
            gsize we_have = we_want < (chunk->len - queue->offset) ? we_want : (chunk->len - queue->offset);

            g_string_append_len(dest, chunk->str + queue->offset, we_have);

            we_want -= we_have;
        } else {
            gsize we_have = we_want < chunk->len ? we_want : chunk->len;

            g_string_append_len(dest, chunk->str, we_have);

            we_want -= we_have;
        }
    }

    return dest;
}

/**
 * get a string from the head of the queue and remove the chunks from the queue 
 */
GString *
network_queue_pop_str(network_queue *queue, gsize steal_len, GString *dest)
{
    gsize we_want = steal_len;
    GString *chunk;

    if (queue->len < steal_len) {
        return NULL;
    }

    while ((chunk = g_queue_peek_head(queue->chunks))) {
        gsize we_have = we_want < (chunk->len - queue->offset) ? we_want : (chunk->len - queue->offset);

        if (!dest && (queue->offset == 0) && (chunk->len == steal_len)) {
            /* optimize the common case that we want to have to full chunk
             *
             * if dest is null, we can remove the GString from the queue and
             * return it directly without copying it
             */
            dest = g_queue_pop_head(queue->chunks);
            queue->len -= we_have;
            return dest;
        }

        if (!dest) {
            /* if we don't have a dest-buffer yet, create one */
            dest = g_string_sized_new(calculate_alloc_len(steal_len));
        }
        g_string_append_len(dest, chunk->str + queue->offset, we_have);

        queue->offset += we_have;
        queue->len -= we_have;
        we_want -= we_have;

        if (chunk->len == queue->offset) {
            /* the chunk is done, remove it */
            g_string_free(g_queue_pop_head(queue->chunks), TRUE);
            queue->offset = 0;
        } else {
            break;
        }
    }

    return dest;
}