#include <al/test.h>
#include <al/ring_buffer.h>
#include <al/atomic.h>

#define TEST_BUFFER_SIZE 32

static u8 buffer[TEST_BUFFER_SIZE];
static u8 buffer_ret[TEST_BUFFER_SIZE];
static u8 buffer_half[TEST_BUFFER_SIZE / 2] = {0};
static u8 buffer_over[TEST_BUFFER_SIZE + 16] = {0};

static bool ring_buffer_test_init(void)
{
    AL_TEST_START("ring_buffer_init");

    struct al_ring_buffer buf;
    al_ring_buffer_init(&buf, buffer, TEST_BUFFER_SIZE);

    AL_TEST_EQ(buf.start, buffer, ptr);
    AL_TEST_EQ(buf.end, buffer + TEST_BUFFER_SIZE, ptr);
    AL_TEST_EQ(al_atomic_load(void)(&buf.read, AL_ATOMIC_RELAXED), buffer, ptr);
    AL_TEST_EQ(al_atomic_load(void)(&buf.write, AL_ATOMIC_RELAXED), buffer, ptr);

    AL_TEST_END();
}

static bool ring_buffer_test_space(void)
{
    AL_TEST_START("ring_buffer_space");

    struct al_ring_buffer buf;
    al_ring_buffer_init(&buf, buffer, TEST_BUFFER_SIZE);

    AL_TEST_EQ(al_ring_buffer_space(&buf), TEST_BUFFER_SIZE - 1, size_t);

    AL_TEST_END();
}

static bool ring_buffer_test_occupied(void)
{
    AL_TEST_START("ring_buffer_occupied");

    struct al_ring_buffer buf;
    al_ring_buffer_init(&buf, buffer, TEST_BUFFER_SIZE);

    AL_TEST_EQ(al_ring_buffer_occupied(&buf), 0, size_t);

    AL_TEST_END();
}

static bool ring_buffer_test_read_and_write_chunk(void)
{
    AL_TEST_START("ring_buffer_read_and_write_chunk");

    struct al_ring_buffer buf;
    al_ring_buffer_init(&buf, buffer, TEST_BUFFER_SIZE);

    char *data = "TestTEST";
    size_t data_size = al_strlen(data) + 1;

    size_t size;
    u8 *ptr = al_ring_buffer_write_chunk(&buf, &size);

    AL_TEST_EQ(size, TEST_BUFFER_SIZE - 1, size_t);

    al_memcpy(ptr, data, data_size);
    al_ring_buffer_append(&buf, ptr, data_size);

    AL_TEST_EQ(al_ring_buffer_occupied(&buf), data_size, size_t);
    AL_TEST_EQ(al_ring_buffer_space(&buf), (TEST_BUFFER_SIZE - 1) - data_size, size_t);

    ptr = al_ring_buffer_read_chunk(&buf, &size);
    AL_TEST_EQ(size, data_size, size_t);
    AL_TEST_TRUE((strcmp((char *)ptr, data) == 0));
    al_ring_buffer_consume(&buf, ptr, size);

    AL_TEST_EQ(al_ring_buffer_occupied(&buf), 0, size_t);
    AL_TEST_EQ(al_ring_buffer_space(&buf), TEST_BUFFER_SIZE - 1, size_t);

    AL_TEST_END();
}

static bool ring_buffer_test_read_and_write(void)
{
    AL_TEST_START("ring_buffer_read_and_write");

    struct al_ring_buffer buf;
    al_ring_buffer_init(&buf, buffer, TEST_BUFFER_SIZE);

    char *data = "TestTEST";
    size_t data_size = al_strlen(data) + 1;

    al_ring_buffer_write(&buf, (u8 *)data, data_size);

    AL_TEST_EQ(al_ring_buffer_occupied(&buf), data_size, size_t);
    AL_TEST_EQ(al_ring_buffer_space(&buf), (TEST_BUFFER_SIZE - 1) - data_size, size_t);

    al_ring_buffer_read(&buf, (u8 *)buffer_ret, data_size);
    AL_TEST_TRUE((strcmp((char *)buffer_ret, data) == 0));

    AL_TEST_EQ(al_ring_buffer_occupied(&buf), 0, size_t);
    AL_TEST_EQ(al_ring_buffer_space(&buf), TEST_BUFFER_SIZE - 1, size_t);

    al_memset(buffer_half, 'd', sizeof(buffer_half));

    AL_TEST_EQ(al_ring_buffer_write(&buf, buffer_half, sizeof(buffer_half)), sizeof(buffer_half), size_t);
    AL_TEST_EQ(al_ring_buffer_occupied(&buf), sizeof(buffer_half), size_t);
    AL_TEST_EQ(al_ring_buffer_space(&buf), (TEST_BUFFER_SIZE - 1) - sizeof(buffer_half), size_t);

    AL_TEST_EQ(al_ring_buffer_read(&buf, (u8 *)buffer_ret, data_size), data_size, size_t);
    AL_TEST_TRUE(al_memcmp(buffer_ret, "ddddddddd", data_size) == 0);

    AL_TEST_EQ(al_ring_buffer_write(&buf, buffer_half, sizeof(buffer_half)), sizeof(buffer_half), size_t);
    AL_TEST_EQ(al_ring_buffer_occupied(&buf), TEST_BUFFER_SIZE - data_size, size_t);
    AL_TEST_LT(al_atomic_load(void)(&buf.write, AL_ATOMIC_RELAXED), al_atomic_load(void)(&buf.read, AL_ATOMIC_RELAXED), ptr);

    size_t space = al_ring_buffer_space(&buf);
    AL_TEST_EQ(space, data_size - 1, size_t);
    AL_TEST_EQ(al_ring_buffer_write(&buf, buffer_over, sizeof(buffer_over)), space, size_t);

    AL_TEST_EQ(al_ring_buffer_read(&buf, buffer_ret, sizeof(buffer_over)), TEST_BUFFER_SIZE - 1, size_t);

    AL_TEST_END();
}

static bool ring_buffer_test_peek(void)
{
    AL_TEST_START("ring_buffer_peek");

    struct al_ring_buffer buf;
    al_ring_buffer_init(&buf, buffer, TEST_BUFFER_SIZE);

    char *data = "abcabcabcabcabcabcabcabcabcabca";
    size_t data_size = al_strlen(data);
    AL_TEST_EQ(data_size, TEST_BUFFER_SIZE - 1, size_t);

    al_ring_buffer_write(&buf, (u8 *)data, data_size);

    al_ring_buffer_peek(&buf, buffer_ret, 0, data_size);
    AL_TEST_TRUE(al_memcmp(buffer_ret, data, data_size) == 0);

    al_ring_buffer_peek(&buf, buffer_ret, 3, data_size);
    AL_TEST_TRUE(al_memcmp(buffer_ret, data + 3, data_size - 3) == 0);

    al_ring_buffer_read(&buf, buffer_ret, 3);
    AL_TEST_TRUE(al_memcmp(buffer_ret, data, 3) == 0);
    al_ring_buffer_write(&buf, (u8 *)data, data_size);

    al_ring_buffer_peek(&buf, buffer_ret, 3, data_size);
    AL_TEST_TRUE(al_memcmp(buffer_ret, data + 6, data_size - 6) == 0);

    al_ring_buffer_peek(&buf, buffer_ret, 0, data_size);
    AL_TEST_TRUE(al_memcmp(buffer_ret, "abcabcabcabcabcabcabcabcabcaabc", data_size) == 0);

    al_ring_buffer_read(&buf, buffer_ret, (TEST_BUFFER_SIZE - 1) - 4);

    al_ring_buffer_peek(&buf, buffer_ret, 0, data_size);
    AL_TEST_TRUE(al_memcmp(buffer_ret, "aab", 3) == 0);

    AL_TEST_EQ(al_ring_buffer_peek(&buf, buffer_ret, 10, data_size), 0, size_t);
    AL_TEST_EQ(al_ring_buffer_peek(&buf, buffer_ret, 3, data_size), 1, size_t);
    AL_TEST_EQ(al_ring_buffer_peek(&buf, buffer_ret, 4, data_size), 0, size_t);

    al_ring_buffer_peek(&buf, buffer_ret, 1, data_size);
    AL_TEST_TRUE(al_memcmp(buffer_ret, "abc", 3) == 0);

    AL_TEST_EQ(al_ring_buffer_peek(&buf, buffer_ret, 2, data_size), 2, size_t);
    AL_TEST_TRUE(al_memcmp(buffer_ret, "bc", 2) == 0);

    al_ring_buffer_read(&buf, buffer_ret, 1);

    AL_TEST_EQ(al_ring_buffer_peek(&buf, buffer_ret, 0, data_size), 3, size_t);
    AL_TEST_TRUE(al_memcmp(buffer_ret, "abc", 3) == 0);

    AL_TEST_EQ(al_ring_buffer_peek(&buf, buffer_ret, 3, data_size), 0, size_t);
    AL_TEST_EQ(al_ring_buffer_peek(&buf, buffer_ret, 4, data_size), 0, size_t);

    AL_TEST_EQ(al_ring_buffer_read(&buf, buffer_ret, 4), 3, size_t);

    AL_TEST_EQ(al_ring_buffer_peek(&buf, buffer_ret, 0, data_size), 0, size_t);
    AL_TEST_EQ(al_ring_buffer_peek(&buf, buffer_ret, 1, data_size), 0, size_t);
    AL_TEST_EQ(al_ring_buffer_peek(&buf, buffer_ret, 2, data_size), 0, size_t);

    AL_TEST_END();
}

bool ring_buffer_tests_run(void)
{
    AL_TEST_START_GROUP("ring_buffer");

    AL_TEST_RUN(ring_buffer_test_init);
    AL_TEST_RUN(ring_buffer_test_space);
    AL_TEST_RUN(ring_buffer_test_occupied);
    AL_TEST_RUN(ring_buffer_test_read_and_write_chunk);
    AL_TEST_RUN(ring_buffer_test_read_and_write);
    AL_TEST_RUN(ring_buffer_test_peek);

    AL_TEST_END_GROUP();
}