/* 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.
==============================================================================*/

#ifndef SIGNAL_SRC_CIRCULAR_BUFFER_H_
#define SIGNAL_SRC_CIRCULAR_BUFFER_H_

#include <stddef.h>
#include <stdint.h>

namespace tflite {
namespace tflm_signal {
// TODO(b/286250473): remove namespace once de-duped libraries above
struct CircularBuffer {
  // Max number of elements, value passed-in to CircularBufferAlloc.
  size_t capacity;
  // Next position to read.
  size_t read;
  // Next position to write.
  size_t write;
  // Flag to indicate emptiness.
  int32_t empty;
  // Auto-generated size variable
  int32_t buffer_size;
  // Array of the circular buffer elements (integers).
  int16_t* buffer;
};

// Returns the size of the memory that the circular buffer needs
// in order to hold `capacity` items.
size_t CircularBufferGetNeededMemory(size_t capacity);

// Initialize an instance of the circular buffer that holds `capacity` items.
// `state` points to a memory allocation of size `state_size`. The size
//  should be greater or equal to the value returned by
//  CircularBufferGetNeededMemory(capacity). Fails if it isn't.
//  On success, returns a pointer to the circular buffer's object.
CircularBuffer* CircularBufferInit(size_t capacity, void* state,
                                   size_t state_size);

// Reset a circular buffer to its initial empty state
void CircularBufferReset(CircularBuffer* cb);

size_t CircularBufferCapacity(const CircularBuffer* cb);

bool CircularBufferFull(const CircularBuffer* cb);

bool CircularBufferEmpty(const CircularBuffer* cb);

// Returns the number of elements ready to read
size_t CircularBufferAvailable(const CircularBuffer* cb);

// Returns the number of elements available to write.
size_t CircularBufferCanWrite(const CircularBuffer* cb);

// Adds a single `value` to the buffer and advances the write pointer.
void CircularBufferAdd(CircularBuffer* cb, int16_t value);

// Writes `n` `values` into the buffer and advances the write pointer.
void CircularBufferWrite(CircularBuffer* cb, const int16_t* values, size_t n);

// Writes `n` zeros into the buffer and advances the write pointer.
void CircularBufferWriteZeros(CircularBuffer* cb, size_t n);

// Returns a pointer to a buffer where elements can be written, and
// advances the write pointer as though they have already been written.
// Fails if `n` elements are not available contiguously at the current
// write position.
int16_t* CircularBufferReserveForWrite(CircularBuffer* cb, size_t n);

// Copies the final region (`count` elements) of the buffer `n` times, to
// the end of the buffer.
void CircularBufferExtend(CircularBuffer* cb, size_t count, int32_t n);

// Reads a single value from the buffer and advances the read pointer
int16_t CircularBufferRemove(CircularBuffer* cb);

// Reads the value at the given `index`, does not modify the read pointer.
int16_t CircularBufferPeek(const CircularBuffer* cb, size_t index);

// Rewinds to restore the previous `n` values read
void CircularBufferRewind(CircularBuffer* cb, size_t n);

// Returns a pointer directly into the circular buffer at the given `index`.
// Caller is responsible for not reading past the end.
const int16_t* CircularBufferPeekDirect(const CircularBuffer* cb, size_t index);

// Returns a pointer into the circular buffer at the current read pointer,
// setting `n` to the number of values available to be read from here.
const int16_t* CircularBufferPeekMax(const CircularBuffer* cb, size_t* n);

// Copies `n` `values` from the buffer and does not advance the read
// pointer and does not update the empty flag.
void CircularBufferGet(CircularBuffer* cb, size_t n, int16_t* values);

// Discards the next `n` values by advancing the read index.
// Valid for n > 0.
void CircularBufferDiscard(CircularBuffer* cb, size_t n);

// Shifts the buffer with `n` values (`n` can be negative) by moving
// the read index.
void CircularBufferShift(CircularBuffer* cb, int n);

}  // namespace tflm_signal
}  // namespace tflite

#endif  // SIGNAL_SRC_CIRCULAR_BUFFER_H_