/**
 * @file test_queue.c
 * @brief Unit tests for message queue
 */

#include "unity.h"
#include "kernel.h"
#include "queue.h"
#include <string.h>

/* Test queue */
static Queue_t test_queue;
static uint8_t queue_buffer[256];

/* Test data */
typedef struct {
    uint32_t id;
    uint8_t data[8];
} TestMessage_t;

/* Setup */
void setUp(void) {
    kernel_init();
    queue_create(&test_queue, queue_buffer, sizeof(TestMessage_t), 10);
}

/* Teardown */
void tearDown(void) {
    kernel_stop();
    queue_delete(&test_queue);
}

/* ============================================================================
 * Test Cases
 * ============================================================================ */

/**
 * @brief Test queue creation
 */
void test_queue_create(void) {
    TEST_ASSERT_EQUAL(0, queue_get_count(&test_queue));
}

/**
 * @brief Test queue send and receive
 */
void test_queue_send_receive(void) {
    TestMessage_t send_msg = {
        .id = 1,
        .data = {1, 2, 3, 4, 5, 6, 7, 8}
    };

    TestMessage_t recv_msg;

    /* Send message */
    TEST_ASSERT_EQUAL(KERNEL_OK, queue_send(&test_queue, &send_msg, 100));
    TEST_ASSERT_EQUAL(1, queue_get_count(&test_queue));

    /* Receive message */
    TEST_ASSERT_EQUAL(KERNEL_OK, queue_receive(&test_queue, &recv_msg, 100));
    TEST_ASSERT_EQUAL(0, queue_get_count(&test_queue));

    /* Verify data */
    TEST_ASSERT_EQUAL(send_msg.id, recv_msg.id);
    TEST_ASSERT_EQUAL_MEMORY(send_msg.data, recv_msg.data, 8);
}

/**
 * @brief Test queue full condition
 */
void test_queue_full(void) {
    TestMessage_t msg = {0};

    /* Fill queue */
    for (int i = 0; i < 10; i++) {
        msg.id = i;
        TEST_ASSERT_EQUAL(KERNEL_OK, queue_send(&test_queue, &msg, 0));
    }

    TEST_ASSERT_EQUAL(10, queue_get_count(&test_queue));

    /* Try to send when full */
    TEST_ASSERT_EQUAL(KERNEL_TIMEOUT, queue_send(&test_queue, &msg, 0));
}

/**
 * @brief Test queue empty condition
 */
void test_queue_empty(void) {
    TestMessage_t msg;

    /* Try to receive from empty queue */
    TEST_ASSERT_EQUAL(KERNEL_TIMEOUT, queue_receive(&test_queue, &msg, 0));
}

/**
 * @brief Test FIFO ordering
 */
void test_queue_fifo(void) {
    TestMessage_t send_msg;
    TestMessage_t recv_msg;

    /* Send multiple messages */
    for (int i = 0; i < 5; i++) {
        send_msg.id = i;
        TEST_ASSERT_EQUAL(KERNEL_OK, queue_send(&test_queue, &send_msg, 100));
    }

    /* Receive in order */
    for (int i = 0; i < 5; i++) {
        TEST_ASSERT_EQUAL(KERNEL_OK, queue_receive(&test_queue, &recv_msg, 100));
        TEST_ASSERT_EQUAL(i, recv_msg.id);
    }
}

/* ============================================================================
 * Test Runner
 * ============================================================================ */
int main(void) {
    UNITY_BEGIN();

    RUN_TEST(test_queue_create);
    RUN_TEST(test_queue_send_receive);
    RUN_TEST(test_queue_full);
    RUN_TEST(test_queue_empty);
    RUN_TEST(test_queue_fifo);

    return UNITY_END();
}