#include "circle_buffer.h"
#include <string.h>

// 初始化环形缓冲区
void circle_buffer_init(circle_buffer_t *cb, u8 *buffer, u16 capacity) {
    cb->buffer = buffer;
    cb->capacity = capacity;
    cb->head = 0;
    cb->tail = 0;
    cb->size = 0;
}

// 向环形缓冲区写入数据
u16 circle_buffer_write(circle_buffer_t *cb, const u8 *data, u16 length) {
    if (length > circle_buffer_get_free_space(cb)) {
        // 如果剩余空间不足，则只写入能放下的部分
        length = circle_buffer_get_free_space(cb);
    }

    if (length == 0) {
        return 0;
    }

    // 检查是否需要回环
    if (cb->head + length > cb->capacity) {
        u16 part1_len = cb->capacity - cb->head;
        u16 part2_len = length - part1_len;
        memcpy(cb->buffer + cb->head, data, part1_len);
        memcpy(cb->buffer, data + part1_len, part2_len);
        cb->head = part2_len;
    } else {
        memcpy(cb->buffer + cb->head, data, length);
        cb->head += length;
        if (cb->head == cb->capacity) {
            cb->head = 0;
        }
    }

    cb->size += length;
    return length;
}

// 从环形缓冲区读取数据
u16 circle_buffer_read(circle_buffer_t *cb, u8 *data, u16 length) {
    if (length > cb->size) {
        // 如果要读取的长度超过了已有的数据，则只读取已有的部分
        length = cb->size;
    }

    if (length == 0) {
        return 0;
    }

    // 检查是否需要回环
    if (cb->tail + length > cb->capacity) {
        u16 part1_len = cb->capacity - cb->tail;
        u16 part2_len = length - part1_len;
        memcpy(data, cb->buffer + cb->tail, part1_len);
        memcpy(data + part1_len, cb->buffer, part2_len);
        cb->tail = part2_len;
    } else {
        memcpy(data, cb->buffer + cb->tail, length);
        cb->tail += length;
        if (cb->tail == cb->capacity) {
            cb->tail = 0;
        }
    }

    cb->size -= length;
    return length;
}

// 获取已用空间的大小
u16 circle_buffer_get_size(circle_buffer_t *cb) {
    return cb->size;
}

// 获取剩余空间的大小
u16 circle_buffer_get_free_space(circle_buffer_t *cb) {
    return cb->capacity - cb->size;
}