#include <PCircularBuffer.h>

// Error handler used for debugging only
#ifdef PB_CB_DEBUG
#include <stdio.h>
static void handle_status(const char* func, PB_CB_STATUS status_code)
{
    if(status_code != PB_CB_GOOD)
    {
        printf("%s failed: error code: %d\r\n", func, status_code);
    }
}
#endif

// Circular Buffer Prototypes -- uint8_t
#if PB_CB_U8
static PB_CB_STATUS p_cb_u8_push(p_cb_double* cbuffer, uint8_t value);
static PB_CB_STATUS p_cb_u8_empty(p_cb_double* cbuffer);
static PB_CB_STATUS p_cb_u8_is_full(p_cb_double* cbuffer);
static PB_CB_STATUS p_cb_u8_is_empty(p_cb_double* cbuffer);
#endif

// Circular Buffer Prototypes -- uint16_t
#if PB_CB_U16
static PB_CB_STATUS p_cb_u16_push(p_cb_double* cbuffer, uint16_t value);
static PB_CB_STATUS p_cb_u16_empty(p_cb_double* cbuffer);
static PB_CB_STATUS p_cb_u16_is_full(p_cb_double* cbuffer);
static PB_CB_STATUS p_cb_u16_is_empty(p_cb_double* cbuffer);
#endif

// Circular Buffer Prototypes -- uint32_t
#if PB_CB_U32
static PB_CB_STATUS p_cb_u32_push(p_cb_double* cbuffer, uint32_t value);
static PB_CB_STATUS p_cb_u32_empty(p_cb_double* cbuffer);
static PB_CB_STATUS p_cb_u32_is_full(p_cb_double* cbuffer);
static PB_CB_STATUS p_cb_u32_is_empty(p_cb_double* cbuffer);
#endif

// Circular Buffer Prototypes -- uint64_t
#if PB_CB_U64
static PB_CB_STATUS p_cb_u64_push(p_cb_double* cbuffer, uint64_t value);
static PB_CB_STATUS p_cb_u64_empty(p_cb_double* cbuffer);
static PB_CB_STATUS p_cb_u64_is_full(p_cb_double* cbuffer);
static PB_CB_STATUS p_cb_u64_is_empty(p_cb_double* cbuffer);
#endif

// Circular Buffer Prototypes -- int8_t
#if PB_CB_I8 
static PB_CB_STATUS p_cb_i8_push(p_cb_double* cbuffer, int8_t value);
static PB_CB_STATUS p_cb_i8_empty(p_cb_double* cbuffer);
static PB_CB_STATUS p_cb_i8_is_full(p_cb_double* cbuffer);
static PB_CB_STATUS p_cb_i8_is_empty(p_cb_double* cbuffer);
#endif

// Circular Buffer Prototypes -- int16_t
#if PB_CB_I16
static PB_CB_STATUS p_cb_i16_push(p_cb_double* cbuffer, int16_t value);
static PB_CB_STATUS p_cb_i16_empty(p_cb_double* cbuffer);
static PB_CB_STATUS p_cb_i16_is_full(p_cb_double* cbuffer);
static PB_CB_STATUS p_cb_i16_is_empty(p_cb_double* cbuffer);
#endif

// Circular Buffer Prototypes -- int32_t
#if PB_CB_I32
static PB_CB_STATUS p_cb_i32_push(p_cb_double* cbuffer, int32_t value);
static PB_CB_STATUS p_cb_i32_empty(p_cb_double* cbuffer);
static PB_CB_STATUS p_cb_i32_is_full(p_cb_double* cbuffer);
static PB_CB_STATUS p_cb_i32_is_empty(p_cb_double* cbuffer);
#endif

// Circular Buffer Prototypes -- int64_t
#if PB_CB_I64
static PB_CB_STATUS p_cb_i64_push(p_cb_double* cbuffer, int64_t value);
static PB_CB_STATUS p_cb_i64_empty(p_cb_double* cbuffer);
static PB_CB_STATUS p_cb_i64_is_full(p_cb_double* cbuffer);
static PB_CB_STATUS p_cb_i64_is_empty(p_cb_double* cbuffer);
#endif

// Circular Buffer Prototypes -- Float
#if PB_CB_FLOAT
static PB_CB_STATUS p_cb_float_push(p_cb_double* cbuffer, float value);
static PB_CB_STATUS p_cb_float_empty(p_cb_double* cbuffer);
static PB_CB_STATUS p_cb_float_is_full(p_cb_double* cbuffer);
static PB_CB_STATUS p_cb_float_is_empty(p_cb_double* cbuffer);
#endif

// Circular Buffer Prototypes -- Double
#if PB_CB_DOUBLE
static PB_CB_STATUS p_cb_double_push(p_cb_double* cbuffer, double value);
static PB_CB_STATUS p_cb_double_empty(p_cb_double* cbuffer);
static PB_CB_STATUS p_cb_double_is_full(p_cb_double* cbuffer);
static PB_CB_STATUS p_cb_double_is_empty(p_cb_double* cbuffer);
#endif

// Circular Buffer Definitions -- uint8_t
#if PB_CB_U8
PB_CB_STATUS p_cb_u8_init(p_cb_u8* circ_buffer, uint8_t* buff, uint32_t max_length)
{
    PB_CB_STATUS ret = PB_CB_GOOD;
    do
    {
        // Make sure the buffer isn't bad (null)
        if(!buff)
        {
            ret = PB_CB_NULL_BUFFER;
            break;
        }

        // Make sure the max buffer is a useable size
        if(max_length > PB_CB_MAX_BUFFER_SIZE || max_length <= 0)
        {
            ret = PB_CB_BAD_BUFFER_SIZE;
            break;
        }
    } while (0);

    // Debugging
    #ifdef PB_CB_DEBUG
    handle_status(__func__, ret);
    #endif

    return ret;
}

PB_CB_STATUS p_cb_u8_push(p_cb_double* cbuffer, uint8_t value)
{

}
PB_CB_STATUS p_cb_u8_empty(p_cb_double* cbuffer)
{

}
#endif
// Circular Buffer Definitions -- uint16_t
#if PB_CB_U16
PB_CB_STATUS p_cb_u16_init(p_cb_u16* circ_buffer, uint16_t* buff, uint32_t max_length)
{
    PB_CB_STATUS ret = PB_CB_GOOD;
    do
    {
        // Make sure the buffer isn't bad (null)
        if(!buff)
        {
            ret = PB_CB_NULL_BUFFER;
            break;
        }

        // Make sure the max buffer is a useable size
        if(max_length > PB_CB_MAX_BUFFER_SIZE || max_length <= 0)
        {
            ret = PB_CB_BAD_BUFFER_SIZE;
            break;
        }
    } while (0);

    // Debugging
    #ifdef PB_CB_DEBUG
    handle_status(__func__, ret);
    #endif

    return ret;
}
PB_CB_STATUS p_cb_u16_push(p_cb_double* cbuffer, uint16_t value)
{
    PB_CB_STATUS ret = PB_CB_GOOD;
    // Debugging
    #ifdef PB_CB_DEBUG
    handle_status(__func__, ret);
    #endif

    return ret;
}
PB_CB_STATUS p_cb_u16_empty(p_cb_double* cbuffer)
{
    PB_CB_STATUS ret = PB_CB_GOOD;
    // Debugging
    #ifdef PB_CB_DEBUG
    handle_status(__func__, ret);
    #endif

    return ret;
}
#endif

// Circular Buffer Definitions -- uint32_t
#if PB_CB_U32
PB_CB_STATUS p_cb_u32_init(p_cb_u32* circ_buffer, uint32_t* buff, uint32_t max_length)
{
    PB_CB_STATUS ret = PB_CB_GOOD;
    do
    {
        // Make sure the buffer isn't bad (null)
        if(!buff)
        {
            ret = PB_CB_NULL_BUFFER;
            break;
        }

        // Make sure the max buffer is a useable size
        if(max_length > PB_CB_MAX_BUFFER_SIZE || max_length <= 0)
        {
            ret = PB_CB_BAD_BUFFER_SIZE;
            break;
        }
    } while (0);

    // Debugging
    #ifdef PB_CB_DEBUG
    handle_status(__func__, ret);
    #endif

    return ret;
}
PB_CB_STATUS p_cb_u32_push(p_cb_double* cbuffer, uint32_t value)
{
    PB_CB_STATUS ret = PB_CB_GOOD;
    // Debugging
    #ifdef PB_CB_DEBUG
    handle_status(__func__, ret);
    #endif

    return ret;
}
PB_CB_STATUS p_cb_u32_empty(p_cb_double* cbuffer)
{
    PB_CB_STATUS ret = PB_CB_GOOD;
    // Debugging
    #ifdef PB_CB_DEBUG
    handle_status(__func__, ret);
    #endif

    return ret;
}
#endif

// Circular Buffer Definitions -- uint64_t
#if PB_CB_U64
PB_CB_STATUS p_cb_u64_init(p_cb_u64* circ_buffer, uint64_t* buff, uint32_t max_length)
{
    PB_CB_STATUS ret = PB_CB_GOOD;
    do
    {
        // Make sure the buffer isn't bad (null)
        if(!buff)
        {
            ret = PB_CB_NULL_BUFFER;
            break;
        }

        // Make sure the max buffer is a useable size
        if(max_length > PB_CB_MAX_BUFFER_SIZE || max_length <= 0)
        {
            ret = PB_CB_BAD_BUFFER_SIZE;
            break;
        }
    } while (0);

    // Debugging
    #ifdef PB_CB_DEBUG
    handle_status(__func__, ret);
    #endif

    return ret;
}
PB_CB_STATUS p_cb_u64_push(p_cb_double* cbuffer, uint64_t value)
{
    PB_CB_STATUS ret = PB_CB_GOOD;
    // Debugging
    #ifdef PB_CB_DEBUG
    handle_status(__func__, ret);
    #endif

    return ret;
}
PB_CB_STATUS p_cb_u64_empty(p_cb_double* cbuffer)
{
    PB_CB_STATUS ret = PB_CB_GOOD;
    // Debugging
    #ifdef PB_CB_DEBUG
    handle_status(__func__, ret);
    #endif

    return ret;
}
#endif

#if PB_CB_FLOAT
PB_CB_STATUS p_cb_float_init(p_cb_float* circ_buffer, float* buff, uint32_t max_length)
{
    PB_CB_STATUS ret = PB_CB_GOOD;
    do
    {
        // Make sure the buffer isn't bad (null)
        if(!buff)
        {
            ret = PB_CB_NULL_BUFFER;
            break;
        }

        // Make sure the max buffer is a useable size
        if(max_length > PB_CB_MAX_BUFFER_SIZE || max_length <= 0)
        {
            ret = PB_CB_BAD_BUFFER_SIZE;
            break;
        }
    } while (0);

    // Debugging
    #ifdef PB_CB_DEBUG
    handle_status(__func__, ret);
    #endif

    return ret;
}
PB_CB_STATUS p_cb_float_push(p_cb_double* cbuffer, float value)
{
    PB_CB_STATUS ret = PB_CB_GOOD;
    // Debugging
    #ifdef PB_CB_DEBUG
    handle_status(__func__, ret);
    #endif

    return ret;
}
PB_CB_STATUS p_cb_float_empty(p_cb_double* cbuffer)
{
    PB_CB_STATUS ret = PB_CB_GOOD;
    // Debugging
    #ifdef PB_CB_DEBUG
    handle_status(__func__, ret);
    #endif

    return ret;
}
#endif

// Circular Buffer Definitions -- double
#if PB_CB_DOUBLE
PB_CB_STATUS p_cb_double_init(p_cb_double* circ_buffer, double* buff, uint32_t max_length)
{
    PB_CB_STATUS ret = PB_CB_GOOD;
    do
    {
        // Make sure the buffer isn't bad (null)
        if(!buff)
        {
            ret = PB_CB_NULL_BUFFER;
            break;
        }

        // Make sure the max buffer is a useable size
        if(max_length > PB_CB_MAX_BUFFER_SIZE || max_length <= 0)
        {
            ret = PB_CB_BAD_BUFFER_SIZE;
            break;
        }
        circ_buffer->max_len = max_length;
        circ_buffer->push = p_cb_double_push;
        circ_buffer->empty = p_cb_double_empty;
        circ_buffer->empty(circ_buffer);
    } while (0);

    // Debugging
    #ifdef PB_CB_DEBUG
    handle_status(__func__, ret);
    #endif


    return ret;
}

PB_CB_STATUS p_cb_double_push(p_cb_double* cbuffer, double value)
{
    PB_CB_STATUS ret = PB_CB_GOOD;

    if(!cbuffer)
    {
        ret = PB_CB_NULL_CBUFFER;
    }
    else
    {
        cbuffer->buffer[cbuffer->head] = value;
        cbuffer->head = (cbuffer->head + 1) % cbuffer->max_len;
        printf("head: %d\r\n", cbuffer->max_len);
    }

    // Debugging
    #ifdef PB_CB_DEBUG
    handle_status(__func__, ret);
    #endif

    return ret;
}
PB_CB_STATUS p_cb_double_empty(p_cb_double* cbuffer)
{
    PB_CB_STATUS ret = PB_CB_GOOD;

    do
    {
        if(!cbuffer)
        {
            ret = PB_CB_NULL_CBUFFER;
            break;
        }

        if(!cbuffer->buffer)
        {
            ret = PB_CB_NULL_BUFFER;
            break;
        }
        for(int ind = 0; ind < cbuffer->max_len; ind++)
        {
            cbuffer->buffer[ind] = 0.0;
        }
        cbuffer->head = 0;
        cbuffer->b_empty = true;
        cbuffer->b_filled = false;
    } while (0);
    
    // Debugging
    #ifdef PB_CB_DEBUG
    handle_status(__func__, ret);
    #endif

    return ret;
}
#endif