/* movstat/ringbuf.c
 *
 * Ring buffer module
 * 
 * Copyright (C) 2018 Patrick Alken
 * 
 * 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; either version 3 of the License, or (at
 * your option) any later version.
 * 
 * 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 Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#ifndef __GSL_RINGBUF_C__
#define __GSL_RINGBUF_C__

/*typedef int ringbuf_type;*/

typedef struct
{
  ringbuf_type_t *array;
  int head;
  int tail;
  int size;       /* total elements allocated */
} ringbuf;

static size_t ringbuf_size(const size_t n);
static int ringbuf_empty(ringbuf * d);
static int ringbuf_is_empty(const ringbuf * d);
static int ringbuf_is_full(const ringbuf * d);
static int ringbuf_insert(const ringbuf_type_t x, ringbuf * d);
static int ringbuf_pop_back(ringbuf * b);
static ringbuf_type_t ringbuf_peek(const int i, const ringbuf * b);
static ringbuf_type_t ringbuf_peek_front(const ringbuf * d);
static ringbuf_type_t ringbuf_peek_back(const ringbuf * d);
static size_t ringbuf_copy(double * dest, const ringbuf * b);

static size_t
ringbuf_size(const size_t n)
{
  size_t size = 0;

  size += sizeof(ringbuf);
  size += n * sizeof(ringbuf_type_t); /* b->array */

  return size;
}

static int
ringbuf_init(const size_t n, ringbuf * b)
{
  b->array = (ringbuf_type_t *) ((char *) b + sizeof(ringbuf));
  b->head = -1;
  b->tail = 0;
  b->size = (int) n;
  return GSL_SUCCESS;
}

/* empty the buffer */
static int
ringbuf_empty(ringbuf * b)
{
  b->head = -1;
  b->tail = 0;
  return GSL_SUCCESS;
}

/* check if buffer is empty */
static int
ringbuf_is_empty(const ringbuf * b)
{
  return (b->head == -1);
}

/* check if buffer is full */
static int
ringbuf_is_full(const ringbuf * b)
{
  return ((b->head == 0 && b->tail == b->size - 1) ||
          (b->head == b->tail + 1));
}

/* insert element into buffer, overwriting oldest element if necessary */
static int
ringbuf_insert(const ringbuf_type_t x, ringbuf * b)
{
  if (b->head == -1)     /* buffer is empty */
    {
      b->head = 0;
      b->tail = 0;
    }
  else if (b->head == 0) /* head is in first position, wrap to end */
    {
      b->head = b->size - 1;

      if (b->tail == b->head && b->size > 1)
        --(b->tail);     /* buffer is full so decrease tail */
    }
  else                   /* decrement head */
    {
      --(b->head);

      if (b->tail == b->head)
        {
          /* buffer is full so update tail */
          if (b->tail == 0)
            b->tail = b->size - 1;
          else
            --(b->tail);
        }
    }

  /* insert element */
  b->array[b->head] = x;

  return GSL_SUCCESS;
}

static int
ringbuf_pop_back(ringbuf * b)
{
  if (ringbuf_is_empty(b) || b->tail < 0)
    {
      GSL_ERROR("buffer is empty", GSL_EBADLEN);
    }
  else
    {
      if (b->head == b->tail) /* buffer has only one element */
        {
          b->head = -1;
          b->tail = -1;
        }
      else if (b->tail == 0)  /* tail is in first position, wrap to end */
        {
          b->tail = b->size - 1;
        }
      else                    /* decrement tail */
        {
          --(b->tail);
        }

      return GSL_SUCCESS;
    }
}

static ringbuf_type_t
ringbuf_peek(const int i, const ringbuf * b)
{
  if (ringbuf_is_empty(b))
    {
      GSL_ERROR("buffer is empty", GSL_EBADLEN);
    }
  else
    {
      return b->array[(b->head + i) % b->size];
    }
}

static ringbuf_type_t
ringbuf_peek_front(const ringbuf * b)
{
  if (ringbuf_is_empty(b))
    {
      GSL_ERROR("buffer is empty", GSL_EBADLEN);
    }
  else
    {
      return b->array[b->head];
    }
}

static ringbuf_type_t
ringbuf_peek_back(const ringbuf * b)
{
  if (ringbuf_is_empty(b) || b->tail < 0)
    {
      GSL_ERROR("buffer is empty", GSL_EBADLEN);
    }
  else
    {
      return b->array[b->tail];
    }
}

static size_t
ringbuf_copy(double * dest, const ringbuf * b)
{
  if (ringbuf_is_empty(b) || b->tail < 0)
    {
      return 0;
    }
  else
    {
      const int n = (b->head > b->tail) ? (b->size - b->head + b->tail + 1) : (b->tail - b->head + 1);
      int i;

      for (i = 0; i < n; ++i)
        dest[n - i - 1] = b->array[(b->head + i) % b->size];

      return (size_t) n;
    }
}

#endif /* __GSL_RINGBUF_C__ */