#define    IBUF_LENGTH        (32)
#define    IBUF_MASK        (IBUF_LENGTH-1)

#define    OBUF_LENGTH        (32)
#define    OBUF_MASK        (OBUF_LENGTH-1)

uint32_t ibus_start, ibuf_end, obuf_start, obuf_end;

char    BufOut[OBUF_LENGTH];
char    BufIn[IBUF_LENGTH];

void obuf_init()
{
    obuf_start = obuf_end = 0;
}

void ibuf_init()
{
    ibuf_start = ibuf_end = 0;
}

void put(char c)
{
    while((ibuf_start+IBUF_LENGTH) == ibuf_end);
    BufIn[ibuf_end++ & IBUF_MASK] = c;
}

char get(void)
{
    while(obuf_end == obuf_start);
    return BufOut[obuf_start++ & OBUF_MASK];
}

uint32_t LOGGER_SaveData(uint32_t data)
{
    uint32_t low_byte, high_byte;
    low_byte =  data & 0xFF;
    high_byte =  data >> 8;
    SPIEEPROM_WriteByte(current_address, low_byte);
    SPIEEPROM_WriteByte(current_address+1, high_byte);
    current_address += 2;
    if(current_address>=EEPROM_SIZE)
        current_address = 0;

    return current_address;
}

uint32_t LOGGER_GetData(uint32_t address)
{
    uint32_t low_byte, high_byte;
    low_byte = SPIEEPROM_ReadByte(address);
    high_byte = SPIEEPROM_ReadByte(address+1);
    return (high_byte << 8) | low_byte;
}

typedef struct struct_cBuffer
{
    unsigned char *dataptr;            ///< the physical memory address where the buffer is stored
    unsigned short size;            ///< the allocated size of the buffer
    unsigned short datalength;        ///< the length of the data currently in the buffer
    unsigned short dataindex;        ///< the index into the buffer where the data starts
} cBuffer;

void bufferInit(cBuffer* buffer, unsigned char *start, unsigned short size)
{
    // begin critical section
    CRITICAL_SECTION_START;
    // set start pointer of the buffer
    buffer->dataptr = start;
    buffer->size = size;
    // initialize index and length
    buffer->dataindex = 0;
    buffer->datalength = 0;
    // end critical section
    CRITICAL_SECTION_END;
}

// access routines
unsigned char  bufferGetFromFront(cBuffer* buffer)
{
    unsigned char data = 0;
    // begin critical section
    CRITICAL_SECTION_START;
    // check to see if there's data in the buffer
    if(buffer->datalength)
    {
        // get the first character from buffer
        data = buffer->dataptr[buffer->dataindex];
        // move index down and decrement length
        buffer->dataindex++;
        if(buffer->dataindex >= buffer->size)
        {
            buffer->dataindex -= buffer->size;
        }
        buffer->datalength--;
    }
    // end critical section
    CRITICAL_SECTION_END;
    // return
    return data;
}

void bufferDumpFromFront(cBuffer* buffer, unsigned short numbytes)
{
    // begin critical section
    CRITICAL_SECTION_START;
    // dump numbytes from the front of the buffer
    // are we dumping less than the entire buffer?
    if(numbytes < buffer->datalength)
    {
        // move index down by numbytes and decrement length by numbytes
        buffer->dataindex += numbytes;
        if(buffer->dataindex >= buffer->size)
        {
            buffer->dataindex -= buffer->size;
        }
        buffer->datalength -= numbytes;
    }
    else
    {
        // flush the whole buffer
        buffer->datalength = 0;
    }
    // end critical section
    CRITICAL_SECTION_END;
}

unsigned char bufferGetAtIndex(cBuffer* buffer, unsigned short index)
{
    // begin critical section
    CRITICAL_SECTION_START;
    // return character at index in buffer
    unsigned char data = buffer->dataptr[(buffer->dataindex+index)%(buffer->size)];
    // end critical section
    CRITICAL_SECTION_END;
    return data;
}

unsigned char bufferAddToEnd(cBuffer* buffer, unsigned char data)
{
    // begin critical section
    CRITICAL_SECTION_START;
    // make sure the buffer has room
    if(buffer->datalength < buffer->size)
    {
        // save data byte at end of buffer
        buffer->dataptr[(buffer->dataindex + buffer->datalength) % buffer->size] = data;
        // increment the length
        buffer->datalength++;
        // end critical section
        CRITICAL_SECTION_END;
        // return success
        return -1;
    }
    // end critical section
    CRITICAL_SECTION_END;
    // return failure
    return 0;
}

unsigned short bufferIsNotFull(cBuffer* buffer)
{
    // begin critical section
    CRITICAL_SECTION_START;
    // check to see if the buffer has room
    // return true if there is room
    unsigned short bytesleft = (buffer->size - buffer->datalength);
    // end critical section
    CRITICAL_SECTION_END;
    return bytesleft;
}

void bufferFlush(cBuffer* buffer)
{
    // begin critical section
    CRITICAL_SECTION_START;
    // flush contents of the buffer
    buffer->datalength = 0;
    // end critical section
    CRITICAL_SECTION_END;
}