#include "test_utils.h"

UnittestTestResult_t* test_bitwise_and_with_vars(void) {
    UNITTEST_BEGIN_TEST("TestBitwise", "test_bitwise_and_with_vars");

    RAVA_TEST_RUN(_unittest_result,
        "public class Test {\n"
        "    public static int main() {\n"
        "        int a = 12;\n"
        "        int b = 10;\n"
        "        return a & b;\n"
        "    }\n"
        "}\n",
        "Test", "main", 8, "bitwise AND with vars 12 & 10 should return 8");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_bitwise_or_with_vars(void) {
    UNITTEST_BEGIN_TEST("TestBitwise", "test_bitwise_or_with_vars");

    RAVA_TEST_RUN(_unittest_result,
        "public class Test {\n"
        "    public static int main() {\n"
        "        int a = 12;\n"
        "        int b = 10;\n"
        "        return a | b;\n"
        "    }\n"
        "}\n",
        "Test", "main", 14, "bitwise OR with vars 12 | 10 should return 14");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_bitwise_xor(void) {
    UNITTEST_BEGIN_TEST("TestBitwise", "test_bitwise_xor");

    RAVA_TEST_RUN(_unittest_result,
        "public class Test {\n"
        "    public static int main() {\n"
        "        return 12 ^ 10;\n"
        "    }\n"
        "}\n",
        "Test", "main", 6, "bitwise XOR 12 ^ 10 should return 6");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_left_shift(void) {
    UNITTEST_BEGIN_TEST("TestBitwise", "test_left_shift");

    RAVA_TEST_RUN(_unittest_result,
        "public class Test {\n"
        "    public static int main() {\n"
        "        return 1 << 4;\n"
        "    }\n"
        "}\n",
        "Test", "main", 16, "left shift 1 << 4 should return 16");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_right_shift(void) {
    UNITTEST_BEGIN_TEST("TestBitwise", "test_right_shift");

    RAVA_TEST_RUN(_unittest_result,
        "public class Test {\n"
        "    public static int main() {\n"
        "        return 16 >> 2;\n"
        "    }\n"
        "}\n",
        "Test", "main", 4, "right shift 16 >> 2 should return 4");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_unsigned_right_shift(void) {
    UNITTEST_BEGIN_TEST("TestBitwise", "test_unsigned_right_shift");

    RAVA_TEST_RUN(_unittest_result,
        "public class Test {\n"
        "    public static int main() {\n"
        "        return 16 >>> 2;\n"
        "    }\n"
        "}\n",
        "Test", "main", 4, "unsigned right shift 16 >>> 2 should return 4");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_combined_bitwise_ops(void) {
    UNITTEST_BEGIN_TEST("TestBitwise", "test_combined_bitwise_ops");

    RAVA_TEST_RUN(_unittest_result,
        "public class Test {\n"
        "    public static int main() {\n"
        "        int a = 5;\n"
        "        int b = 3;\n"
        "        return (a & b) | (a ^ b);\n"
        "    }\n"
        "}\n",
        "Test", "main", 7, "combined bitwise ops (5 & 3) | (5 ^ 3) should return 7");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_shift_with_variable(void) {
    UNITTEST_BEGIN_TEST("TestBitwise", "test_shift_with_variable");

    RAVA_TEST_RUN(_unittest_result,
        "public class Test {\n"
        "    public static int main() {\n"
        "        int x = 2;\n"
        "        return 1 << x;\n"
        "    }\n"
        "}\n",
        "Test", "main", 4, "shift with variable 1 << 2 should return 4");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_bitwise_mask(void) {
    UNITTEST_BEGIN_TEST("TestBitwise", "test_bitwise_mask");

    RAVA_TEST_RUN(_unittest_result,
        "public class Test {\n"
        "    public static int main() {\n"
        "        int value = 255;\n"
        "        int mask = 0x0F;\n"
        "        return value & mask;\n"
        "    }\n"
        "}\n",
        "Test", "main", 15, "bitwise mask 255 & 0x0F should return 15");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_bit_toggle_with_xor(void) {
    UNITTEST_BEGIN_TEST("TestBitwise", "test_bit_toggle_with_xor");

    RAVA_TEST_RUN(_unittest_result,
        "public class Test {\n"
        "    public static int main() {\n"
        "        int flags = 5;\n"
        "        return flags ^ 1;\n"
        "    }\n"
        "}\n",
        "Test", "main", 4, "bit toggle with XOR 5 ^ 1 should return 4");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_bitwise_not_zero(void) {
    UNITTEST_BEGIN_TEST("TestBitwise", "test_bitwise_not_zero");

    RAVA_TEST_RUN(_unittest_result,
        "public class Test {\n"
        "    public static int main() {\n"
        "        int x = 0;\n"
        "        return ~x;\n"
        "    }\n"
        "}\n",
        "Test", "main", -1, "bitwise NOT ~0 should return -1");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_bitwise_not_with_value(void) {
    UNITTEST_BEGIN_TEST("TestBitwise", "test_bitwise_not_with_value");

    RAVA_TEST_RUN(_unittest_result,
        "public class Test {\n"
        "    public static int main() {\n"
        "        int x = 5;\n"
        "        return ~x;\n"
        "    }\n"
        "}\n",
        "Test", "main", -6, "bitwise NOT ~5 should return -6");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_compound_and_assign(void) {
    UNITTEST_BEGIN_TEST("TestBitwise", "test_compound_and_assign");

    RAVA_TEST_RUN(_unittest_result,
        "public class Test {\n"
        "    public static int main() {\n"
        "        int x = 15;\n"
        "        x &= 7;\n"
        "        return x;\n"
        "    }\n"
        "}\n",
        "Test", "main", 7, "compound AND assign 15 &= 7 should return 7");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_compound_or_assign(void) {
    UNITTEST_BEGIN_TEST("TestBitwise", "test_compound_or_assign");

    RAVA_TEST_RUN(_unittest_result,
        "public class Test {\n"
        "    public static int main() {\n"
        "        int x = 8;\n"
        "        x |= 3;\n"
        "        return x;\n"
        "    }\n"
        "}\n",
        "Test", "main", 11, "compound OR assign 8 |= 3 should return 11");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_compound_xor_assign(void) {
    UNITTEST_BEGIN_TEST("TestBitwise", "test_compound_xor_assign");

    RAVA_TEST_RUN(_unittest_result,
        "public class Test {\n"
        "    public static int main() {\n"
        "        int x = 12;\n"
        "        x ^= 5;\n"
        "        return x;\n"
        "    }\n"
        "}\n",
        "Test", "main", 9, "compound XOR assign 12 ^= 5 should return 9");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_compound_left_shift_assign(void) {
    UNITTEST_BEGIN_TEST("TestBitwise", "test_compound_left_shift_assign");

    RAVA_TEST_RUN(_unittest_result,
        "public class Test {\n"
        "    public static int main() {\n"
        "        int x = 1;\n"
        "        x <<= 3;\n"
        "        return x;\n"
        "    }\n"
        "}\n",
        "Test", "main", 8, "compound left shift assign 1 <<= 3 should return 8");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_compound_right_shift_assign(void) {
    UNITTEST_BEGIN_TEST("TestBitwise", "test_compound_right_shift_assign");

    RAVA_TEST_RUN(_unittest_result,
        "public class Test {\n"
        "    public static int main() {\n"
        "        int x = 16;\n"
        "        x >>= 2;\n"
        "        return x;\n"
        "    }\n"
        "}\n",
        "Test", "main", 4, "compound right shift assign 16 >>= 2 should return 4");

    UNITTEST_END_TEST();
}

int main(int argc, char **argv) {
    UnittestConfig_t *config = unittest_config_create();
    config->verbosity = 2;

    if (argc > 1 && strcmp(argv[1], "--json") == 0) {
        config->output_format = UNITTEST_FORMAT_JSON;
        config->use_colors = false;
    }

    UnittestTestSuite_t *suite = unittest_test_suite_create("Bitwise Operator Tests");

    UnittestTestCase_t *tc = unittest_test_case_create("TestBitwise");
    unittest_test_case_add_result(tc, test_bitwise_and_with_vars());
    unittest_test_case_add_result(tc, test_bitwise_or_with_vars());
    unittest_test_case_add_result(tc, test_bitwise_xor());
    unittest_test_case_add_result(tc, test_left_shift());
    unittest_test_case_add_result(tc, test_right_shift());
    unittest_test_case_add_result(tc, test_unsigned_right_shift());
    unittest_test_case_add_result(tc, test_combined_bitwise_ops());
    unittest_test_case_add_result(tc, test_shift_with_variable());
    unittest_test_case_add_result(tc, test_bitwise_mask());
    unittest_test_case_add_result(tc, test_bit_toggle_with_xor());
    unittest_test_case_add_result(tc, test_bitwise_not_zero());
    unittest_test_case_add_result(tc, test_bitwise_not_with_value());
    unittest_test_case_add_result(tc, test_compound_and_assign());
    unittest_test_case_add_result(tc, test_compound_or_assign());
    unittest_test_case_add_result(tc, test_compound_xor_assign());
    unittest_test_case_add_result(tc, test_compound_left_shift_assign());
    unittest_test_case_add_result(tc, test_compound_right_shift_assign());
    unittest_test_suite_add_test_case(suite, tc);

    unittest_generate_report(suite, config);

    int failures = suite->total_failed + suite->total_errors;
    unittest_test_suite_destroy(suite);
    unittest_config_destroy(config);

    return failures > 0 ? 1 : 0;
}