/** @file uart_circular.c
 *
 *  @brief Single-producer, single-consumer UART circular buffer
 *
 *  The producer can drain bytes from a hardware FIFO in an interrupt context;
 *  the consumer can process buffered spans from a task context. One slot is
 *  reserved to distinguish a full buffer from an empty buffer.
 *
 */

#include "uart_circular.h"


#include <stddef.h>

/* PUBLIC FUNCTION DEFINITIONS */

bool uart_circular_init(uart_circular_buffer *buffer, uint8_t *storage, uint32_t capacity)
{
    if ((buffer == NULL) || (storage == NULL) || (capacity < 2U))
    {
        return false;
    }

    buffer->storage = storage;
    buffer->capacity = capacity;
    buffer->producer_index = 0U;
    buffer->consumer_index = 0U;

    return true;
}

uint32_t uart_circular_drain_fifo(uart_circular_buffer *buffer,
                                  uart_circular_fifo_read_fn read_byte, void *context)
{
    uint32_t drained = 0U;
    uint32_t producer;
    uint32_t consumer;

    if ((buffer == NULL) || (buffer->storage == NULL) || (read_byte == NULL) ||
        (buffer->capacity < 2U))
    {
        return 0U;
    }

    producer = buffer->producer_index;
    consumer = buffer->consumer_index;

    while (true)
    {
        uint32_t next_producer = producer + 1U;
        uint8_t byte;

        if (next_producer == buffer->capacity)
        {
            next_producer = 0U;
        }

        if (next_producer == consumer)
        {
            break;
        }

        if (!read_byte(context, &byte))
        {
            break;
        }

        buffer->storage[producer] = byte;
        producer = next_producer;
        buffer->producer_index = producer;
        drained++;
    }

    return drained;
}

void uart_circular_isr(void *args)
{
    uart_circular_isr_params *params = (uart_circular_isr_params *)args;
    bool service_pending = true;

    if ((params == NULL) || (params->buffer == NULL) || (params->get_interrupt_status == NULL) ||
        (params->read_byte == NULL) || (params->fifo_has_data == NULL) ||
        (params->rx_interrupt_mask == 0U))
    {
        return;
    }

    while (service_pending)
    {
        uint32_t interrupt_type = params->get_interrupt_status(params->context);

        if ((interrupt_type & params->rx_interrupt_mask) == params->rx_interrupt_mask)
        {
            if ((params->rx_line_error_mask != 0U) &&
                ((interrupt_type & params->rx_line_error_mask) == params->rx_line_error_mask))
            {
                if (params->on_rx_line_error != NULL)
                {
                    params->on_rx_line_error(params->context);
                }
            }
            else
            {
                if ((params->rx_timeout_mask != 0U) &&
                    ((interrupt_type & params->rx_timeout_mask) == params->rx_timeout_mask) &&
                    !params->fifo_has_data(params->context) &&
                    (params->on_rx_timeout_empty != NULL))
                {
                    params->on_rx_timeout_empty(params->context);
                }

                uint32_t drained =
                    uart_circular_drain_fifo(params->buffer, params->read_byte, params->context);

                if ((drained != 0U) && (params->on_rx_bytes_drained != NULL))
                {
                    params->on_rx_bytes_drained(params->context, drained);
                }

                if (uart_circular_is_full(params->buffer) && (params->on_rx_buffer_full != NULL))
                {
                    params->on_rx_buffer_full(params->context);
                }
            }
        }
        else if ((params->tx_interrupt_mask != 0U) &&
                 ((interrupt_type & params->tx_interrupt_mask) == params->tx_interrupt_mask))
        {
            if (params->on_tx_threshold != NULL)
            {
                params->on_tx_threshold(params->context);
            }
        }
        else
        {
            service_pending = false;
        }
    }
}

uint32_t uart_circular_process(uart_circular_buffer *buffer, uint32_t max_length,
                               uart_circular_data_fn process_data, void *context)
{
    uint32_t producer;
    uint32_t consumer;
    uint32_t remaining;
    uint32_t processed = 0U;

    if ((buffer == NULL) || (buffer->storage == NULL) || (process_data == NULL) ||
        (buffer->capacity < 2U) || (max_length == 0U))
    {
        return 0U;
    }

    producer = buffer->producer_index;
    consumer = buffer->consumer_index;
    remaining =
        (producer >= consumer) ? (producer - consumer) : (buffer->capacity - (consumer - producer));

    if (remaining > max_length)
    {
        remaining = max_length;
    }

    while (remaining != 0U)
    {
        uint32_t contiguous =
            (producer > consumer) ? (producer - consumer) : (buffer->capacity - consumer);
        uint32_t length = (contiguous < remaining) ? contiguous : remaining;

        process_data(context, &buffer->storage[consumer], length);

        consumer += length;
        if (consumer == buffer->capacity)
        {
            consumer = 0U;
        }
        buffer->consumer_index = consumer;
        remaining -= length;
        processed += length;
    }

    return processed;
}

uint32_t uart_circular_get_producer(const uart_circular_buffer *buffer)
{
    return (buffer != NULL) ? buffer->producer_index : 0U;
}

uint32_t uart_circular_get_consumer(const uart_circular_buffer *buffer)
{
    return (buffer != NULL) ? buffer->consumer_index : 0U;
}

uint32_t uart_circular_get_occupancy(const uart_circular_buffer *buffer)
{
    uint32_t producer;
    uint32_t consumer;

    if ((buffer == NULL) || (buffer->capacity < 2U))
    {
        return 0U;
    }

    producer = buffer->producer_index;
    consumer = buffer->consumer_index;

    return (producer >= consumer) ? (producer - consumer)
                                  : (buffer->capacity - (consumer - producer));
}

bool uart_circular_is_full(const uart_circular_buffer *buffer)
{
    uint32_t next_producer;

    if ((buffer == NULL) || (buffer->capacity < 2U))
    {
        return false;
    }

    next_producer = buffer->producer_index + 1U;
    if (next_producer == buffer->capacity)
    {
        next_producer = 0U;
    }

    return next_producer == buffer->consumer_index;
}
