#include "uart_driver.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// Mock test framework - in a real project, we would use Unity or similar
#define TEST_ASSERT(condition) do { \
    if (!(condition)) { \
        printf("TEST FAILED: %s:%d: %s\n", __FILE__, __LINE__, #condition); \
        return 0; \
    } \
} while(0)

#define TEST_ASSERT_EQUAL(expected, actual) do { \
    if ((expected) != (actual)) { \
        printf("TEST FAILED: %s:%d: Expected %d, got %d\n", __FILE__, __LINE__, (expected), (actual)); \
        return 0; \
    } \
} while(0)

#define TEST_ASSERT_NOT_NULL(ptr) do { \
    if ((ptr) == NULL) { \
        printf("TEST FAILED: %s:%d: Expected non-NULL pointer\n", __FILE__, __LINE__); \
        return 0; \
    } \
} while(0)

#define TEST_ASSERT_NULL(ptr) do { \
    if ((ptr) != NULL) { \
        printf("TEST FAILED: %s:%d: Expected NULL pointer, got %p\n", __FILE__, __LINE__, (ptr)); \
        return 0; \
    } \
} while(0)

int test_uart_driver_init_valid_config(void) {
    uart_driver_t driver;
    uart_config_t config = {
        .tx_pin = 17,
        .rx_pin = 18,
        .baud_rate = 9600,
        .data_bits = 8,
        .parity = 0, // none
        .stop_bits = 1
    };

    TEST_ASSERT(uart_driver_init(&driver, &config));
    TEST_ASSERT(uart_driver_is_initialized(&driver));

    uart_driver_deinit(&driver);
    return 1; // Test passed
}

int test_uart_driver_init_invalid_baud_rate(void) {
    uart_driver_t driver;
    uart_config_t config = {
        .tx_pin = 17,
        .rx_pin = 18,
        .baud_rate = 0, // Invalid baud rate
        .data_bits = 8,
        .parity = 0,
        .stop_bits = 1
    };

    TEST_ASSERT(!uart_driver_init(&driver, &config));
    TEST_ASSERT(!uart_driver_is_initialized(&driver));

    return 1; // Test passed
}

int test_uart_driver_init_invalid_data_bits(void) {
    uart_driver_t driver;
    uart_config_t config = {
        .tx_pin = 17,
        .rx_pin = 18,
        .baud_rate = 9600,
        .data_bits = 9, // Invalid data bits
        .parity = 0,
        .stop_bits = 1
    };

    TEST_ASSERT(!uart_driver_init(&driver, &config));
    TEST_ASSERT(!uart_driver_is_initialized(&driver));

    return 1; // Test passed
}

int test_uart_driver_init_null_pointers(void) {
    uart_driver_t driver;
    uart_config_t config = {
        .tx_pin = 17,
        .rx_pin = 18,
        .baud_rate = 9600,
        .data_bits = 8,
        .parity = 0,
        .stop_bits = 1
    };

    // Test NULL driver pointer
    TEST_ASSERT(!uart_driver_init(NULL, &config));

    // Test NULL config pointer
    TEST_ASSERT(!uart_driver_init(&driver, NULL));

    return 1; // Test passed
}

int test_uart_driver_send_receive(void) {
    uart_driver_t driver;
    uart_config_t config = {
        .tx_pin = 17,
        .rx_pin = 18,
        .baud_rate = 9600,
        .data_bits = 8,
        .parity = 0,
        .stop_bits = 1
    };

    TEST_ASSERT(uart_driver_init(&driver, &config));
    TEST_ASSERT(uart_driver_is_initialized(&driver));

    uint8_t test_data[] = {0x01, 0x02, 0x03, 0x04, 0x05};
    size_t test_length = sizeof(test_data);

    // Test sending data
    TEST_ASSERT(uart_driver_send(&driver, test_data, test_length, 1000));

    // Test receiving data (should return 0 in our mock implementation)
    uint8_t rx_buffer[10];
    int bytes_received = uart_driver_receive(&driver, rx_buffer, sizeof(rx_buffer), 100);
    TEST_ASSERT_EQUAL(0, bytes_received); // Our mock returns 0 (no data)

    uart_driver_deinit(&driver);
    return 1; // Test passed
}

int test_uart_driver_send_null_data(void) {
    uart_driver_t driver;
    uart_config_t config = {
        .tx_pin = 17,
        .rx_pin = 18,
        .baud_rate = 9600,
        .data_bits = 8,
        .parity = 0,
        .stop_bits = 1
    };

    TEST_ASSERT(uart_driver_init(&driver, &config));

    // Test sending NULL data
    TEST_ASSERT(!uart_driver_send(&driver, NULL, 5, 1000));

    uart_driver_deinit(&driver);
    return 1; // Test passed
}

int test_uart_driver_receive_null_buffer(void) {
    uart_driver_t driver;
    uart_config_t config = {
        .tx_pin = 17,
        .rx_pin = 18,
        .baud_rate = 9600,
        .data_bits = 8,
        .parity = 0,
        .stop_bits = 1
    };

    TEST_ASSERT(uart_driver_init(&driver, &config));

    // Test receiving with NULL buffer
    TEST_ASSERT_EQUAL(-1, uart_driver_receive(&driver, NULL, 10, 100));

    uart_driver_deinit(&driver);
    return 1; // Test passed
}

int test_uart_driver_uninitialized_operations(void) {
    uart_driver_t driver = {0}; // Not initialized
    uint8_t test_data = 0x01;
    uint8_t rx_buffer[10];

    // Test operations on uninitialized driver
    TEST_ASSERT(!uart_driver_send(&driver, &test_data, 1, 1000));
    TEST_ASSERT_EQUAL(-1, uart_driver_receive(&driver, rx_buffer, sizeof(rx_buffer), 100));
    TEST_ASSERT(!uart_driver_is_initialized(&driver));

    return 1; // Test passed
}

int test_uart_driver_deinit(void) {
    uart_driver_t driver;
    uart_config_t config = {
        .tx_pin = 17,
        .rx_pin = 18,
        .baud_rate = 9600,
        .data_bits = 8,
        .parity = 0,
        .stop_bits = 1
    };

    TEST_ASSERT(uart_driver_init(&driver, &config));
    TEST_ASSERT(uart_driver_is_initialized(&driver));

    uart_driver_deinit(&driver);
    TEST_ASSERT(!uart_driver_is_initialized(&driver));

    return 1; // Test passed
}

// Test runner
int run_all_tests(void) {
    int passed = 0;
    int total = 0;

    // List of test functions
    int (*tests[])(void) = {
        test_uart_driver_init_valid_config,
        test_uart_driver_init_invalid_baud_rate,
        test_uart_driver_init_invalid_data_bits,
        test_uart_driver_init_null_pointers,
        test_uart_driver_send_receive,
        test_uart_driver_send_null_data,
        test_uart_driver_receive_null_buffer,
        test_uart_driver_uninitialized_operations,
        test_uart_driver_deinit
    };

    const char *test_names[] = {
        "test_uart_driver_init_valid_config",
        "test_uart_driver_init_invalid_baud_rate",
        "test_uart_driver_init_invalid_data_bits",
        "test_uart_driver_init_null_pointers",
        "test_uart_driver_send_receive",
        "test_uart_driver_send_null_data",
        "test_uart_driver_receive_null_buffer",
        "test_uart_driver_uninitialized_operations",
        "test_uart_driver_deinit"
    };

    for (int i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {
        total++;
        printf("Running %s...", test_names[i]);
        fflush(stdout);

        if (tests[i]()) {
            printf(" PASSED\n");
            passed++;
        } else {
            printf(" FAILED\n");
        }
    }

    printf("\nResults: %d/%d tests passed\n", passed, total);
    return (passed == total) ? 0 : 1;
}

int main(void) {
    return run_all_tests();
}