#ifndef INCLUDED_FIFO_H
#define INCLUDED_FIFO_H

#ifndef INCLUDED_OS_TYPES_H
#include <os_types.h>
#endif /*INCLUDED_OS_TYPES_H*/

#ifndef INCLUDED_OS_COMPILER_H
#include <os_compiler.h>
#endif /*INCLUDED_OS_COMPILER_H*/

#ifndef INCLUDED_OS_MACROS_H
#include <os_macros.h>
#endif /*INCLUDED_OS_MACROS_H*/



/* ==================================================================================================== */
/* 类型 */


typedef struct fifo_t{
    uint8_t* buffer;
    os_size_t buffer_size;
    os_size_t write_idx;
    os_size_t read_idx;
}fifo_t;

/* ==================================================================================================== */
/* 接口 */

OS_STATIC_FORCE_INLINE
void fifo_init(fifo_t* self, uint8_t* buffer, os_size_t buffer_size){
    OS_ASSERT(self);
    OS_ASSERT(buffer);
    OS_ASSERT(buffer_size>1);

    self->buffer = buffer;
    self->buffer_size = buffer_size;
    self->write_idx = 0;
    self->read_idx = 0;
}

OS_STATIC_FORCE_INLINE
void fifo_clear(fifo_t* self){
    self->read_idx = self->write_idx = 0;
}

OS_STATIC_FORCE_INLINE
os_bool_t fifo_is_empty(fifo_t* self){
    return (self->write_idx==self->read_idx);
}

// 容量,实际可以存放的字节数
OS_STATIC_FORCE_INLINE
os_size_t fifo_capacity(fifo_t* self){
    return self->buffer_size-1;
}

OS_STATIC_FORCE_INLINE
os_bool_t fifo_is_full(fifo_t* self){
    os_size_t next_write_idx = self->write_idx + 1;
    if(next_write_idx>=self->buffer_size){
        next_write_idx = 0;
    }
    return (next_write_idx==self->read_idx)?OS_TRUE:OS_FALSE;
}

// 数量, 当前buffer里已经有的数据量
OS_STATIC_FORCE_INLINE
os_size_t fifo_count(fifo_t* self){
    if(self->write_idx >= self->read_idx){
        return (self->write_idx - self->read_idx);
    }else{
        return (self->buffer_size - self->read_idx) + self->write_idx;
    }
}

// 空间, 还可以写入多少字节数据
OS_STATIC_FORCE_INLINE
os_size_t fifo_space(fifo_t* self){
    os_size_t count = 0;
    if(self->write_idx >= self->read_idx){
        count = (self->write_idx - self->read_idx);
    }else{
        count = (self->buffer_size - self->read_idx) + self->write_idx;
    }
    return self->buffer_size - 1 - count;
}

OS_STATIC_FORCE_INLINE
os_err_t fifo_skip(fifo_t* self, os_size_t offset){
    os_size_t data_sz = fifo_count(self);
    if(offset > data_sz){
        return OS_ERR_FULL;
    }

    os_size_t read_idx = self->read_idx;
    self->read_idx = (read_idx + offset) % self->buffer_size;

    return OS_ERR_OK;
}

OS_STATIC_FORCE_INLINE
os_bool_t fifo_offset_is(fifo_t* self, os_size_t offset, uint8_t data){
    OS_ASSERT(offset <  fifo_count(self));
    os_size_t read_idx = (self->read_idx + offset) % self->buffer_size;
    return (data == self->buffer[read_idx])?OS_TRUE:OS_FALSE;
}


/* ------------------------------------------------------------------------------------------------------------------ */
/*  */


// 在尾部写入数据
os_err_t fifo_put(fifo_t* self, uint8_t data);

// 从头部获取数据
os_err_t fifo_get(fifo_t* self, uint8_t* data);

// 批量写入数据
os_size_t fifo_write(fifo_t* self, uint8_t* data, os_size_t size);

// 批量读取数据
os_size_t fifo_read(fifo_t* self, uint8_t* buf, os_size_t size);

os_size_t fifo_write_fast(fifo_t* rb, const uint8_t * data, os_size_t len);

os_size_t fifo_read_fast(fifo_t* rb, uint8_t * data, os_size_t len);

int fifo_memcmp(fifo_t *rb, os_size_t offset, const void *ptr, os_size_t len);

os_size_t fifo_peek_bulk(fifo_t* rb, os_size_t offset, uint8_t* data, os_size_t len);

os_err_t fifo_peek_at(fifo_t* self, os_size_t offset, uint8_t * data);

os_size_t fifo_find(fifo_t *rb, os_size_t offset, const void *pattern, os_size_t pattern_len);

unsigned long fifo_strtoul(fifo_t* self, os_size_t* endptr /*从哪里开始转换, 可以为空*/, int base /*0, 8, 10, 16 进制*/);

#endif /*INCLUDED_FIFO_H*/