// test_lexer.c
#include <lexer.h>
#include <string.h>
#include <utest/acutest.h>

// 测试辅助函数
static inline void test_lexer_string(const char *input,
                                     scc_tok_type_t expected_type) {
    scc_lexer_t lexer;
    scc_lexer_tok_t token;
    scc_mem_probe_stream_t stream;

    scc_lexer_init(&lexer, scc_mem_probe_stream_init(&stream, input,
                                                     strlen(input), false));
    scc_lexer_get_token(&lexer, &token);

    TEST_CHECK(token.type == expected_type);
    TEST_MSG("Expected: %s", scc_get_tok_name(expected_type));
    TEST_MSG("Got: %s", scc_get_tok_name(token.type));
}

// 基础运算符测试
void test_operators() {
    TEST_CASE("Arithmetic operators");
    {
        test_lexer_string("+", SCC_TOK_ADD);
        test_lexer_string("++", SCC_TOK_ADD_ADD);
        test_lexer_string("+=", SCC_TOK_ASSIGN_ADD);
        test_lexer_string("-", SCC_TOK_SUB);
        test_lexer_string("--", SCC_TOK_SUB_SUB);
        test_lexer_string("-=", SCC_TOK_ASSIGN_SUB);
        test_lexer_string("*", SCC_TOK_MUL);
        test_lexer_string("*=", SCC_TOK_ASSIGN_MUL);
        test_lexer_string("/", SCC_TOK_DIV);
        test_lexer_string("/=", SCC_TOK_ASSIGN_DIV);
        test_lexer_string("%", SCC_TOK_MOD);
        test_lexer_string("%=", SCC_TOK_ASSIGN_MOD);
    }

    TEST_CASE("Bitwise operators");
    {
        test_lexer_string("&", SCC_TOK_AND);
        test_lexer_string("&&", SCC_TOK_AND_AND);
        test_lexer_string("&=", SCC_TOK_ASSIGN_AND);
        test_lexer_string("|", SCC_TOK_OR);
        test_lexer_string("||", SCC_TOK_OR_OR);
        test_lexer_string("|=", SCC_TOK_ASSIGN_OR);
        test_lexer_string("^", SCC_TOK_XOR);
        test_lexer_string("^=", SCC_TOK_ASSIGN_XOR);
        test_lexer_string("~", SCC_TOK_BIT_NOT);
        test_lexer_string("<<", SCC_TOK_L_SH);
        test_lexer_string("<<=", SCC_TOK_ASSIGN_L_SH);
        test_lexer_string(">>", SCC_TOK_R_SH);
        test_lexer_string(">>=", SCC_TOK_ASSIGN_R_SH);
    }

    TEST_CASE("Comparison operators");
    {
        test_lexer_string("==", SCC_TOK_EQ);
        test_lexer_string("!=", SCC_TOK_NEQ);
        test_lexer_string("<", SCC_TOK_LT);
        test_lexer_string("<=", SCC_TOK_LE);
        test_lexer_string(">", SCC_TOK_GT);
        test_lexer_string(">=", SCC_TOK_GE);
    }

    TEST_CASE("Special symbols");
    {
        test_lexer_string("(", SCC_TOK_L_PAREN);
        test_lexer_string(")", SCC_TOK_R_PAREN);
        test_lexer_string("[", SCC_TOK_L_BRACKET);
        test_lexer_string("]", SCC_TOK_R_BRACKET);
        test_lexer_string("{", SCC_TOK_L_BRACE);
        test_lexer_string("}", SCC_TOK_R_BRACE);
        test_lexer_string(";", SCC_TOK_SEMICOLON);
        test_lexer_string(",", SCC_TOK_COMMA);
        test_lexer_string(":", SCC_TOK_COLON);
        test_lexer_string(".", SCC_TOK_DOT);
        test_lexer_string("...", SCC_TOK_ELLIPSIS);
        test_lexer_string("->", SCC_TOK_DEREF);
        test_lexer_string("?", SCC_TOK_COND);
    }
}

// 关键字测试
void test_keywords() {
    TEST_CASE("C89 keywords");
    test_lexer_string("while", SCC_TOK_WHILE);
    test_lexer_string("sizeof", SCC_TOK_SIZEOF);

    TEST_CASE("C99 keywords");
    test_lexer_string("restrict", SCC_TOK_RESTRICT);
    // test_lexer_string("_Bool",  SCC_TOK_INT); // 需确认你的类型定义
}

// 字面量测试
void test_literals() {
    TEST_CASE("Integer literals");
    {
        // 十进制
        test_lexer_string("0", SCC_TOK_INT_LITERAL);
        test_lexer_string("123", SCC_TOK_INT_LITERAL);
        test_lexer_string("2147483647", SCC_TOK_INT_LITERAL);

        // 十六进制
        test_lexer_string("0x0", SCC_TOK_INT_LITERAL);
        test_lexer_string("0x1A3F", SCC_TOK_INT_LITERAL);
        test_lexer_string("0XABCDEF", SCC_TOK_INT_LITERAL);

        // 八进制
        test_lexer_string("0123", SCC_TOK_INT_LITERAL);
        test_lexer_string("0777", SCC_TOK_INT_LITERAL);

        // 边界值测试
        test_lexer_string("2147483647", SCC_TOK_INT_LITERAL); // INT_MAX
        test_lexer_string("4294967295", SCC_TOK_INT_LITERAL); // UINT_MAX
    }

    TEST_CASE("Character literals");
    {
        test_lexer_string("'a'", SCC_TOK_CHAR_LITERAL);
        test_lexer_string("'\\n'", SCC_TOK_CHAR_LITERAL);
        test_lexer_string("'\\t'", SCC_TOK_CHAR_LITERAL);
        test_lexer_string("'\\\\'", SCC_TOK_CHAR_LITERAL);
        test_lexer_string("'\\0'", SCC_TOK_CHAR_LITERAL);
    }

    TEST_CASE("String literals");
    {
        test_lexer_string("\"hello\"", SCC_TOK_STRING_LITERAL);
        test_lexer_string("\"multi-line\\nstring\"", SCC_TOK_STRING_LITERAL);
        test_lexer_string("\"escape\\\"quote\"", SCC_TOK_STRING_LITERAL);
    }

    // TEST_CASE("Floating literals");
    // test_lexer_string("3.14e-5",  SCC_TOK_FLOAT_LITERAL);
}

// 边界测试
void test_edge_cases() {
    // TEST_CASE("Long identifiers");
    // char long_id[LEXER_MAX_ SCC_TOK_SIZE+2] = {0};
    // memset(long_id, 'a', LEXER_MAX_ SCC_TOK_SIZE+1);
    // test_lexer_string(long_id,  SCC_TOK_IDENT);

    // TEST_CASE("Buffer boundary");
    // char boundary[LEXER_BUFFER_SIZE*2] = {0};
    // memset(boundary, '+', LEXER_BUFFER_SIZE*2-1);
    // test_lexer_string(boundary,  SCC_TOK_ADD);
}

// 错误处理测试
// void test_error_handling() {
//     TEST_CASE("Invalid characters");
//     cc_lexer_t lexer;
//     tok_t token;

//     init_lexer(&lexer, "test.c", NULL, test_read);
//     get_valid_token(&lexer, &token);

//     TEST_CHECK(token.type ==  SCC_TOK_EOF); // 应触发错误处理
// }

// 测试列表
TEST_LIST = {{"operators", test_operators},
             {"keywords", test_keywords},
             {"literals", test_literals},
             {"edge_cases", test_edge_cases},
             //  {"error_handling", test_error_handling},
             {NULL, NULL}};