/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/

#include "signal/src/circular_buffer.h"

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

#define ASSERT assert

namespace tflite {
namespace tflm_signal {
// TODO(b/286250473): remove namespace once de-duped libraries above
void CircularBufferReset(tflm_signal::CircularBuffer* cb) {
  cb->read = 0;
  cb->write = 0;
  cb->empty = 1;
  cb->buffer = (int16_t*)(cb + 1);
  memset(cb->buffer, 0, sizeof(cb->buffer[0]) * cb->buffer_size);
}

size_t CircularBufferGetNeededMemory(size_t capacity) {
  return sizeof(CircularBuffer) + sizeof(int16_t) * 2 * capacity;
}

CircularBuffer* CircularBufferInit(size_t capacity, void* state,
                                   size_t state_size) {
  ASSERT(CircularBufferGetNeededMemory(capacity) >= state_size);
  CircularBuffer* cb = (CircularBuffer*)state;
  cb->buffer_size = 2 * capacity;
  cb->capacity = capacity;
  CircularBufferReset(cb);
  return cb;
}

size_t CircularBufferCapacity(const tflm_signal::CircularBuffer* cb) {
  return cb->capacity;
}

bool CircularBufferFull(const tflm_signal::CircularBuffer* cb) {
  return cb->read == cb->write && cb->empty == 0;
}

bool CircularBufferEmpty(const tflm_signal::CircularBuffer* cb) {
  return cb->empty == 1;
}

size_t CircularBufferAvailable(const tflm_signal::CircularBuffer* cb) {
  const int32_t diff = cb->write - cb->read;
  if (diff > 0) {
    return diff;
  } else if (diff < 0) {
    return cb->capacity + diff;
  } else if (cb->empty == 1) {
    return 0;
  } else {
    return cb->capacity;
  }
}

size_t CircularBufferCanWrite(const tflm_signal::CircularBuffer* cb) {
  return cb->capacity - CircularBufferAvailable(cb);
}

void CircularBufferAdd(tflm_signal::CircularBuffer* cb, int16_t value) {
  ASSERT(!CircularBufferFull(cb));
  cb->buffer[cb->write] = value;
  cb->buffer[cb->write + cb->capacity] = value;
  if (++cb->write == cb->capacity) {
    cb->write = 0;
  }
  cb->empty = 0;
}

void CircularBufferWrite(tflm_signal::CircularBuffer* cb, const int16_t* values,
                         size_t n) {
  if (n > 0) {
    ASSERT(CircularBufferCanWrite(cb) >= n);
    size_t write = cb->write;
    int16_t* buffer = cb->buffer;
    const size_t capacity = cb->capacity;
    const size_t end = write + n;

    memcpy(buffer + write, values, n * sizeof(int16_t));
    if (end < capacity) {
      memcpy(buffer + capacity + write, values, n * sizeof(int16_t));
      write += n;
    } else {
      const size_t n1 = capacity - write;
      const size_t nbytes1 = n1 * sizeof(int16_t);
      memcpy(buffer + capacity + write, values, nbytes1);
      const size_t n2 = end - capacity;
      if (n2 > 0) {
        const size_t nbytes2 = n2 * sizeof(int16_t);
        memcpy(buffer, values + n1, nbytes2);
      }
      write = n2;
    }
    cb->write = write;
    cb->empty = 0;
  }
}

void CircularBufferWriteZeros(tflm_signal::CircularBuffer* cb, size_t n) {
  if (n > 0) {
    ASSERT(CircularBufferCanWrite(cb) >= n);
    size_t write = cb->write;
    int16_t* buffer = cb->buffer;
    const size_t capacity = cb->capacity;
    const size_t end = write + n;

    memset(buffer + write, 0, n * sizeof(int16_t));
    if (end < capacity) {
      memset(buffer + capacity + write, 0, n * sizeof(int16_t));
      write += n;
    } else {
      const size_t n1 = capacity - write;
      const size_t nbytes1 = n1 * sizeof(int16_t);
      memset(buffer + capacity + write, 0, nbytes1);
      const size_t n2 = end - capacity;
      if (n2 > 0) {
        const size_t nbytes2 = n2 * sizeof(int16_t);
        memset(buffer, 0, nbytes2);
      }
      write = n2;
    }
    cb->write = write;
    cb->empty = 0;
  }
}

int16_t* CircularBufferReserveForWrite(tflm_signal::CircularBuffer* cb,
                                       size_t n) {
  ASSERT(cb->write + n <= cb->capacity);
  int16_t* write_ptr = cb->buffer + cb->write;
  cb->write += n;
  if (cb->write == cb->capacity) {
    cb->write = 0;
  }
  cb->empty = cb->empty && n == 0;
  return write_ptr;
}

void CircularBufferExtend(tflm_signal::CircularBuffer* cb, size_t count,
                          int32_t n) {
  if (n > 0 && count > 0) {
    ASSERT(CircularBufferCanWrite(cb) >= count * n);
    ASSERT(CircularBufferAvailable(cb) >= count);
    const size_t capacity = cb->capacity;
    // start pos of region to copy
    const size_t start =
        (count > cb->write) ? cb->write + capacity - count : cb->write - count;
    const size_t end = start + count;
    int i;
    if (end <= capacity) {
      // the source elements are contiguous
      for (i = 0; i < n; ++i) {
        CircularBufferWrite(cb, cb->buffer + start, count);
      }
    } else {
      // the source elements wrap around the end of the buffer
      for (i = 0; i < n; ++i) {
        const size_t n1 = capacity - start;
        const size_t n2 = count - n1;
        CircularBufferWrite(cb, cb->buffer + start, n1);
        CircularBufferWrite(cb, cb->buffer, n2);
      }
    }
  }
  // Note: no need to update empty flag
}

int16_t CircularBufferRemove(tflm_signal::CircularBuffer* cb) {
  ASSERT(!CircularBufferEmpty(cb));
  const int16_t result = cb->buffer[cb->read];
  if (++cb->read == cb->capacity) {
    cb->read = 0;
  }
  if (cb->read == cb->write) {
    cb->empty = 1;
  }
  return result;
}

int16_t CircularBufferPeek(const tflm_signal::CircularBuffer* cb,
                           size_t index) {
  ASSERT(CircularBufferAvailable(cb) > index);
  size_t target = cb->read + index;
  while (target >= cb->capacity) {
    target -= cb->capacity;
  }
  return cb->buffer[target];
}

void CircularBufferRewind(tflm_signal::CircularBuffer* cb, size_t n) {
  ASSERT(n <= CircularBufferCanWrite(cb));
  if (n > cb->read) {
    // Must add before subtracting because types are unsigned.
    cb->read = (cb->read + cb->capacity) - n;
  } else {
    cb->read -= n;
  }
  if (n > 0) cb->empty = 0;
}

const int16_t* CircularBufferPeekDirect(const tflm_signal::CircularBuffer* cb,
                                        size_t index) {
  ASSERT(CircularBufferAvailable(cb) > index);
  size_t target = cb->read + index;
  while (target >= cb->capacity) {
    target -= cb->capacity;
  }
  return cb->buffer + target;
}

const int16_t* CircularBufferPeekMax(const tflm_signal::CircularBuffer* cb,
                                     size_t* n) {
  if (CircularBufferAvailable(cb) > 0) {
    *n = (cb->write <= cb->read) ? cb->capacity - cb->read
                                 : cb->write - cb->read;
    return cb->buffer + cb->read;
  } else {
    *n = 0;
    return NULL;
  }
}

void CircularBufferGet(tflm_signal::CircularBuffer* cb, size_t n,
                       int16_t* values) {
  ASSERT(CircularBufferAvailable(cb) >= n);
  const int16_t* buffer = cb->buffer;
  const size_t read = cb->read;
  const size_t end = read + n;
  const size_t capacity = cb->capacity;
  if (end <= capacity) {
    memcpy(values, buffer + read, n * sizeof(int16_t));
  } else {
    const size_t n1 = capacity - read;
    const size_t n2 = end - capacity;
    const size_t nbytes1 = n1 * sizeof(int16_t);
    const size_t nbytes2 = n2 * sizeof(int16_t);
    memcpy(values, buffer + read, nbytes1);
    memcpy(values + n1, buffer, nbytes2);
  }
}

void CircularBufferDiscard(tflm_signal::CircularBuffer* cb, size_t n) {
  ASSERT(n > 0);
  ASSERT(CircularBufferAvailable(cb) >= n);
  cb->read += n;
  if (cb->read >= cb->capacity) {
    cb->read -= cb->capacity;
  }
  if (cb->read == cb->write) {
    cb->empty = 1;
  }
}

void CircularBufferShift(tflm_signal::CircularBuffer* cb, int n) {
  if (n < 0) {
    ASSERT(-n <= (int)cb->capacity);
    if ((int)cb->read < -n) {
      // First add then subtract to ensure positivity as types are unsigned.
      cb->read += cb->capacity;
    }
    cb->read += n;
  } else {
    ASSERT(n <= (int)cb->capacity);
    cb->read += n;
    if (cb->read >= cb->capacity) {
      cb->read -= cb->capacity;
    }
  }
}

}  // namespace tflm_signal
}  // namespace tflite