#include <stdio.h>
#include <assert.h>
#include <math.h>
#include "../runtime/nanbox.h"

static int tests_passed = 0;
static int tests_failed = 0;

#define TEST(name) static void test_##name(void)
#define RUN_TEST(name) do { \
    printf("Running %s... ", #name); \
    test_##name(); \
    printf("PASSED\n"); \
    tests_passed++; \
} while(0)

TEST(int_basic) {
    RavaNanboxValue_t val = rava_nanbox_int(42);
    assert(rava_nanbox_is_int(val));
    assert(!rava_nanbox_is_bool(val));
    assert(!rava_nanbox_is_null(val));
    assert(rava_nanbox_as_int(val) == 42);
}

TEST(int_negative) {
    RavaNanboxValue_t val = rava_nanbox_int(-100);
    assert(rava_nanbox_is_int(val));
    assert(rava_nanbox_as_int(val) == -100);
}

TEST(int_zero) {
    RavaNanboxValue_t val = rava_nanbox_int(0);
    assert(rava_nanbox_is_int(val));
    assert(rava_nanbox_as_int(val) == 0);
}

TEST(long_basic) {
    RavaNanboxValue_t val = rava_nanbox_long(1000000000000LL);
    assert(rava_nanbox_is_long(val));
    int64_t result = rava_nanbox_as_long(val);
    (void)result;
}

TEST(bool_true) {
    RavaNanboxValue_t val = rava_nanbox_bool(true);
    assert(rava_nanbox_is_bool(val));
    assert(rava_nanbox_as_bool(val) == true);
}

TEST(bool_false) {
    RavaNanboxValue_t val = rava_nanbox_bool(false);
    assert(rava_nanbox_is_bool(val));
    assert(rava_nanbox_as_bool(val) == false);
}

TEST(null) {
    RavaNanboxValue_t val = rava_nanbox_null();
    assert(rava_nanbox_is_null(val));
    assert(!rava_nanbox_is_int(val));
    assert(!rava_nanbox_is_bool(val));
}

TEST(double_basic) {
    RavaNanboxValue_t val = rava_nanbox_double(3.14159);
    assert(rava_nanbox_is_double(val));
    double d = rava_nanbox_as_double(val);
    assert(fabs(d - 3.14159) < 0.0001);
}

TEST(double_negative) {
    RavaNanboxValue_t val = rava_nanbox_double(-123.456);
    assert(rava_nanbox_is_double(val));
    double d = rava_nanbox_as_double(val);
    assert(fabs(d - (-123.456)) < 0.0001);
}

TEST(conversion_int_to_long) {
    RavaNanboxValue_t val = rava_nanbox_int(42);
    assert(rava_nanbox_to_long(val) == 42);
}

TEST(conversion_int_to_double) {
    RavaNanboxValue_t val = rava_nanbox_int(10);
    assert(fabs(rava_nanbox_to_double(val) - 10.0) < 0.0001);
}

TEST(conversion_bool_to_int) {
    RavaNanboxValue_t t = rava_nanbox_bool(true);
    RavaNanboxValue_t f = rava_nanbox_bool(false);
    assert(rava_nanbox_to_int(t) == 1);
    assert(rava_nanbox_to_int(f) == 0);
}

TEST(to_bool) {
    assert(rava_nanbox_to_bool(rava_nanbox_null()) == false);
    assert(rava_nanbox_to_bool(rava_nanbox_bool(true)) == true);
    assert(rava_nanbox_to_bool(rava_nanbox_bool(false)) == false);
    assert(rava_nanbox_to_bool(rava_nanbox_int(0)) == false);
    assert(rava_nanbox_to_bool(rava_nanbox_int(1)) == true);
    assert(rava_nanbox_to_bool(rava_nanbox_int(-1)) == true);
}

TEST(object_pointer) {
    int dummy = 42;
    RavaNanboxValue_t val = rava_nanbox_object(&dummy);
    assert(rava_nanbox_is_object(val));
    assert(rava_nanbox_as_object(val) == &dummy);
}

TEST(string_pointer) {
    const char* str = "hello";
    RavaNanboxValue_t val = rava_nanbox_string(str);
    assert(rava_nanbox_is_string(val));
    assert(rava_nanbox_as_string(val) == str);
}

TEST(array_pointer) {
    int arr[10];
    RavaNanboxValue_t val = rava_nanbox_array(arr);
    assert(rava_nanbox_is_array(val));
    assert(rava_nanbox_as_array(val) == arr);
}

int main(void) {
    printf("=== NaN Boxing Unit Tests ===\n\n");

    RUN_TEST(int_basic);
    RUN_TEST(int_negative);
    RUN_TEST(int_zero);
    RUN_TEST(long_basic);
    RUN_TEST(bool_true);
    RUN_TEST(bool_false);
    RUN_TEST(null);
    RUN_TEST(double_basic);
    RUN_TEST(double_negative);
    RUN_TEST(conversion_int_to_long);
    RUN_TEST(conversion_int_to_double);
    RUN_TEST(conversion_bool_to_int);
    RUN_TEST(to_bool);
    RUN_TEST(object_pointer);
    RUN_TEST(string_pointer);
    RUN_TEST(array_pointer);

    printf("\n=== Results: %d passed, %d failed ===\n", tests_passed, tests_failed);
    return tests_failed > 0 ? 1 : 0;
}