#include "c_StringView.h"
#include "c_Test.h"

#include <stdlib.h>
#include <stdio.h>

TEST_CASE(test_c_StringView_Creation) {
    c_StringView_t sv1 = c_StringView_FromCStr("FrameworkTest");
    ASSERT_INT_EQ(13, sv1.size);
    ASSERT_TRUE(memcmp(sv1.str, "FrameworkTest", 13) == 0);

    c_StringView_t sv2 = c_StringView_FromCStr(NULL);
    ASSERT_INT_EQ(0, sv2.size);
    ASSERT_TRUE(sv2.str == NULL);

    c_StringView_t sv3 = c_StringView_FromParts("Data\0Payload", 12);
    ASSERT_INT_EQ(12, sv3.size);
}

TEST_CASE(test_c_StringView_Sub) {
    c_StringView_t base = c_StringView_FromCStr("Container");

    c_StringView_t sub1 = c_StringView_Sub(&base, 3, 4);
    ASSERT_INT_EQ(4, sub1.size);
    ASSERT_TRUE(memcmp(sub1.str, "tain", 4) == 0);

    c_StringView_t sub2 = c_StringView_Sub(&base, 5, 20);
    ASSERT_INT_EQ(4, sub2.size);
    ASSERT_TRUE(memcmp(sub2.str, "iner", 4) == 0);

    c_StringView_t sub3 = c_StringView_Sub(&base, 100, 2);
    ASSERT_INT_EQ(0, sub3.size);
}

TEST_CASE(test_c_StringView_RemovePrefix) {
    c_StringView_t base = c_StringView_FromCStr("lib_api_call");

    c_StringView_t res1 = c_StringView_RemovePrefix(&base, 4);
    ASSERT_INT_EQ(8, res1.size);
    ASSERT_TRUE(memcmp(res1.str, "api_call", 8) == 0);

    c_StringView_t res2 = c_StringView_RemovePrefix(&base, 50);
    ASSERT_INT_EQ(0, res2.size);
}

TEST_CASE(test_c_StringView_Trim) {
    c_StringView_t base1 = c_StringView_FromCStr(" \r\n\t Hello StringView \t ");
    c_StringView_t trimmed1 = c_StringView_Trim(&base1);
    ASSERT_INT_EQ(16, trimmed1.size);
    ASSERT_TRUE(memcmp(trimmed1.str, "Hello StringView", 16) == 0);

    c_StringView_t base2 = c_StringView_FromCStr("   \t  \n ");
    c_StringView_t trimmed2 = c_StringView_Trim(&base2);
    ASSERT_INT_EQ(0, trimmed2.size);
}

TEST_CASE(test_c_StringView_Cmp_and_IsEq) {
    c_StringView_t sv1 = c_StringView_FromCStr("alpha");
    c_StringView_t sv2 = c_StringView_FromCStr("alpha");
    c_StringView_t sv3 = c_StringView_FromCStr("beta");
    c_StringView_t sv4 = c_StringView_FromCStr("alp");

    ASSERT_TRUE(c_StringView_IsEq(&sv1, &sv2));
    ASSERT_TRUE(!c_StringView_IsEq(&sv1, &sv3));

    ASSERT_INT_EQ(0, c_StringView_Cmp(&sv1, &sv2));
    ASSERT_TRUE(c_StringView_Cmp(&sv1, &sv3) < 0);
    ASSERT_TRUE(c_StringView_Cmp(&sv1, &sv4) > 0);
}

TEST_CASE(test_c_StringView_Fixes) {
    c_StringView_t main_sv = c_StringView_FromCStr("sys_config.json");
    c_StringView_t pfx = c_StringView_FromCStr("sys_");
    c_StringView_t sfx = c_StringView_FromCStr(".json");
    c_StringView_t wrong = c_StringView_FromCStr("config");

    ASSERT_TRUE(c_StringView_HasPrefix(&main_sv, &pfx));
    ASSERT_TRUE(!c_StringView_HasPrefix(&main_sv, &wrong));
    ASSERT_TRUE(c_StringView_HasSuffix(&main_sv, &sfx));
    ASSERT_TRUE(!c_StringView_HasSuffix(&main_sv, &wrong));
}

TEST_CASE(test_c_StringView_FindChar) {
    c_StringView_t sv = c_StringView_FromCStr("position_test");

    ASSERT_LL_EQ(0, c_StringView_FindChar(&sv, 0, 'p'));
    ASSERT_LL_EQ(4, c_StringView_FindChar(&sv, 3, 't'));
    ASSERT_LL_EQ(-1, c_StringView_FindChar(&sv, 10, 'p'));
    ASSERT_LL_EQ(-1, c_StringView_FindChar(&sv, 99, 'e'));
}

TEST_CASE(test_c_StringView_Split) {
    c_StringView_t target = c_StringView_FromCStr("config_key=config_value");
    c_StringView_t left, right;

    bool is_split = c_StringView_Split(&target, '=', &left, &right);
    ASSERT_TRUE(is_split);
    ASSERT_INT_EQ(10, left.size);
    ASSERT_TRUE(memcmp(left.str, "config_key", 10) == 0);
    ASSERT_INT_EQ(12, right.size);
    ASSERT_TRUE(memcmp(right.str, "config_value", 12) == 0);
}

TEST_CASE(test_c_StringView_ToCStr_Buf_Basic) {
    c_StringView_t sv = c_StringView_FromCStr("HelloView");
    char buffer[32];

    // 1. 缓冲区足够大时的正常转换
    char* result = c_StringView_ToCStr(&sv, buffer, sizeof(buffer));
    ASSERT_PTR_NOT_NULL(result);
    ASSERT_TRUE(result == buffer); // 返回值必须是传入的 buf 指针
    ASSERT_INT_EQ(9, (int)strlen(buffer));
    ASSERT_TRUE(strcmp(buffer, "HelloView") == 0);
}

TEST_CASE(test_c_StringView_ToCStr_Buf_Truncate) {
    c_StringView_t sv = c_StringView_FromCStr("BufferTruncationTest");
    char small_buffer[7]; // 只能容纳 5 个字符 + 1 个 '\0'

    // 2. 空间不足时的安全截断测试
    char* result = c_StringView_ToCStr(&sv, small_buffer, sizeof(small_buffer));
    ASSERT_PTR_NOT_NULL(result);
    ASSERT_INT_EQ(6, (int)strlen(small_buffer));
    ASSERT_TRUE(strcmp(small_buffer, "Buffer") == 0); // 确保被安全截断且含有 '\0'
    ASSERT_INT_EQ('\0', small_buffer[6]);
}

TEST_CASE(test_c_StringView_ToCStr_Buf_NoNullTerminatorView) {
    // 3. 核心测试：针对长字符串切片出的无 \0 结束符视图进行导出
    c_StringView_t raw = c_StringView_FromCStr("protocol://host:port");
    c_StringView_t sub = c_StringView_Sub(&raw, 11, 4); // 截取 "host" -> 注意原串后面紧跟冒号 ':'
    char buffer[16];

    char* result = c_StringView_ToCStr(&sub, buffer, sizeof(buffer));
    ASSERT_PTR_NOT_NULL(result);
    ASSERT_TRUE(strcmp(buffer, "host") == 0); // 确保没有多读后面的 ':'
}

TEST_CASE(test_c_StringView_ToCStr_Buf_Invalid) {
    c_StringView_t sv = c_StringView_FromCStr("ValidData");
    char buffer[16];

    // 4. 空参数或空大小的防御测试
    ASSERT_TRUE(c_StringView_ToCStr(&sv, NULL, 16) == NULL);
    ASSERT_TRUE(c_StringView_ToCStr(&sv, buffer, 0) == NULL);

    // 5. 空视图对象的安全输出测试
    c_StringView_t empty_sv = c_StringView_FromCStr("");
    char* result = c_StringView_ToCStr(&empty_sv, buffer, sizeof(buffer));
    ASSERT_PTR_NOT_NULL(result);
    ASSERT_INT_EQ(0, (int)strlen(buffer));
    ASSERT_INT_EQ('\0', buffer[0]);
}

TEST_CASE(test_c_StringView_ToUL_Basic) {
    // 1. 标准10进制转换
    c_StringView_t sv1 = c_StringView_FromCStr("12345");
    const char* end1 = NULL;
    unsigned long val1 = c_StringView_ToUL(&sv1, &end1, 10);
    ASSERT_INT_EQ(12345, (int)val1);
    ASSERT_TRUE(end1 == sv1.str + 5);

    // 2. 带前导空格与正号
    c_StringView_t sv2 = c_StringView_FromCStr("   +999 ");
    const char* end2 = NULL;
    unsigned long val2 = c_StringView_ToUL(&sv2, &end2, 10);
    ASSERT_INT_EQ(999, (int)val2);
    ASSERT_TRUE(end2 == sv2.str + 7); // 停在末尾空格前
}

TEST_CASE(test_c_StringView_ToUL_Bases) {
    // 1. 16进制转换 (显式指定)
    c_StringView_t sv1 = c_StringView_FromCStr("0xabcdef");
    unsigned long val1 = c_StringView_ToUL(&sv1, NULL, 16);
    ASSERT_TRUE(val1 == 0xABCDEF);

    // 2. 自动进制识别 (Base = 0)
    c_StringView_t sv2 = c_StringView_FromCStr("0x1a");
    unsigned long val2 = c_StringView_ToUL(&sv2, NULL, 0);
    ASSERT_INT_EQ(26, (int)val2);

    c_StringView_t sv3 = c_StringView_FromCStr("010"); // 八进制的 8
    unsigned long val3 = c_StringView_ToUL(&sv3, NULL, 0);
    ASSERT_INT_EQ(8, (int)val3);

    // 3. 2进制转换
    c_StringView_t sv4 = c_StringView_FromCStr("1101");
    unsigned long val4 = c_StringView_ToUL(&sv4, NULL, 2);
    ASSERT_INT_EQ(13, (int)val4);
}

TEST_CASE(test_c_StringView_ToUL_Bounds) {
    // 1. 利用子串功能测试没有 \0 结尾的情况 (重要！)
    c_StringView_t raw = c_StringView_FromCStr("value=4567888,status=ok");
    c_StringView_t sub = c_StringView_Sub(&raw, 6, 5); // 截取 "45678" -> 注意后面紧跟 '8'，如果没有边界控制会多读

    const char* end = NULL;
    unsigned long val = c_StringView_ToUL(&sub, &end, 10);
    ASSERT_INT_EQ(45678, (int)val);
    ASSERT_TRUE(end == sub.str + 5); // 刚好安全停在 view 的死边界

    // 2. 溢出边界测试
    c_StringView_t ovf = c_StringView_FromCStr("999999999999999999999999999999");
    unsigned long val_ovf = c_StringView_ToUL(&ovf, NULL, 10);
    ASSERT_TRUE(val_ovf == ULONG_MAX);
}

TEST_CASE(test_c_StringView_ToUL_Invalid) {
    // 非法输入测试
    c_StringView_t sv1 = c_StringView_FromCStr("not_a_number");
    const char* end1 = NULL;
    unsigned long val1 = c_StringView_ToUL(&sv1, &end1, 10);
    ASSERT_INT_EQ(0, (int)val1);
    ASSERT_TRUE(end1 == sv1.str); // 无法解析，endptr 指回起点

    // 空视图测试
    c_StringView_t sv2 = c_StringView_FromCStr("");
    unsigned long val2 = c_StringView_ToUL(&sv2, NULL, 10);
    ASSERT_INT_EQ(0, (int)val2);
}

TEST_CASE(test_c_StringView_ToDouble_Basic) {
    // 1. 标准整数与浮点数转换
    c_StringView_t sv1 = c_StringView_FromCStr("3.1415926");
    const char* end1 = NULL;
    double val1 = c_StringView_ToDouble(&sv1, &end1);
    ASSERT_DOUBLE_EQ_MSG(3.1415926, val1, "Standard pi float parse failed");
    ASSERT_TRUE(end1 == sv1.str + 9);

    // 2. 带前导空格与正负号
    c_StringView_t sv2 = c_StringView_FromCStr("   -0.005 ");
    const char* end2 = NULL;
    double val2 = c_StringView_ToDouble(&sv2, &end2);
    ASSERT_DOUBLE_EQ_MSG(-0.005, val2, "Negative float parse failed");
    ASSERT_TRUE(end2 == sv2.str + 9); // 停在末尾空格前
}

TEST_CASE(test_c_StringView_ToDouble_Scientific) {
    // 1. 科学计数法支持 (大写 E)
    c_StringView_t sv1 = c_StringView_FromCStr("1.23E4");
    double val1 = c_StringView_ToDouble(&sv1, NULL);
    ASSERT_DOUBLE_EQ_MSG(12300.0, val1, "Scientific notation E+ failed");

    // 2. 科学计数法支持 (小写 e 负指数)
    c_StringView_t sv2 = c_StringView_FromCStr("5.5e-2");
    double val2 = c_StringView_ToDouble(&sv2, NULL);
    ASSERT_DOUBLE_EQ_MSG(0.055, val2, "Scientific notation e- failed");
}

TEST_CASE(test_c_StringView_ToDouble_Bounds) {
    // 1. 关键测试：没有 \0 结尾的子串切片（测试多读防护）
    c_StringView_t raw = c_StringView_FromCStr("pi=3.14159,e=2.718");
    c_StringView_t sub = c_StringView_Sub(&raw, 3, 7); // 精确截取 "3.14159" -> 紧跟逗号

    const char* end = NULL;
    double val = c_StringView_ToDouble(&sub, &end);
    ASSERT_DOUBLE_EQ_MSG(3.14159, val, "No null-terminator view parse failed");
    ASSERT_TRUE(end == sub.str + 7); // 必须精准停在 View 的终止边界，不被后面的字符干扰

    // 2. 特殊浮点值测试 (不区分大小写)
    c_StringView_t inf_sv = c_StringView_FromCStr("infinity");
    double val_inf = c_StringView_ToDouble(&inf_sv, NULL);
    ASSERT_TRUE(isinf(val_inf));
}

TEST_CASE(test_c_StringView_ToDouble_Invalid) {
    // 1. 完全无法解析的非数字内容
    c_StringView_t sv1 = c_StringView_FromCStr("abc");
    const char* end1 = NULL;
    double val1 = c_StringView_ToDouble(&sv1, &end1);
    ASSERT_DOUBLE_EQ_MSG(0.0, val1, "Invalid string should yield 0.0");
    ASSERT_TRUE(end1 == sv1.str); // 无法解析时，endptr 应该退回到起点

    // 2. 空视图边界安全
    c_StringView_t sv2 = c_StringView_FromCStr("");
    double val2 = c_StringView_ToDouble(&sv2, NULL);
    ASSERT_DOUBLE_EQ_MSG(0.0, val2, "Empty view should yield 0.0");
}
TEST_CASE(test_c_StringView_FindStr_Basic) {
    c_StringView_t main_sv = c_StringView_FromCStr("hello_world_test");
    c_StringView_t needle1 = c_StringView_FromCStr("world");
    c_StringView_t needle2 = c_StringView_FromCStr("test");

    // 1. 标准从头查找
    c_index_t idx1 = c_StringView_FindStr(&main_sv, 0, &needle1);
    ASSERT_LL_EQ(6, idx1);

    // 2. 查找位于末尾的子串
    c_index_t idx2 = c_StringView_FindStr(&main_sv, 0, &needle2);
    ASSERT_LL_EQ(12, idx2);
}

TEST_CASE(test_c_StringView_FindStr_Positions) {
    c_StringView_t main_sv = c_StringView_FromCStr("abacaba_abacaba");
    c_StringView_t needle = c_StringView_FromCStr("abacaba");

    // 1. 指定起始位置偏移量，避开第一个匹配项去寻找第二个匹配项
    c_index_t idx1 = c_StringView_FindStr(&main_sv, 0, &needle);
    ASSERT_LL_EQ(0, idx1);

    c_index_t idx2 = c_StringView_FindStr(&main_sv, 1, &needle);
    ASSERT_LL_EQ(8, idx2); // 成功跳过第一个，定位到后方的匹配
}

TEST_CASE(test_c_StringView_FindStr_NoNullTerminator) {
    // 3. 核心测试：主串与子串两端均没有 \0 结束符（测试死边界控制）
    c_StringView_t raw_haystack = c_StringView_FromCStr("GET /api/v1/user HTTP/1.1");
    c_StringView_t raw_needle   = c_StringView_FromCStr("prefix_v1_suffix");

    // 切片分离出没有 \0 的主串和子串
    c_StringView_t haystack_sv = c_StringView_Sub(&raw_haystack, 4, 12); // "/api/v1/user" -> 后面紧跟 " HTTP"
    c_StringView_t needle_sv   = c_StringView_Sub(&raw_needle, 7, 2);    // "v1" -> 后面紧跟 "_suffix"

    c_index_t idx = c_StringView_FindStr(&haystack_sv, 0, &needle_sv);
    ASSERT_LL_EQ(5, idx); // 必须在截取的相对视图中精确定位到偏移位置 5
}

TEST_CASE(test_c_StringView_FindStr_EdgeAndInvalid) {
    c_StringView_t main_sv = c_StringView_FromCStr("short");
    c_StringView_t long_needle = c_StringView_FromCStr("longer_than_main");
    c_StringView_t empty_needle = c_StringView_FromCStr("");

    // 1. 子串长于主串，直接返回 -1
    ASSERT_LL_EQ(-1, c_StringView_FindStr(&main_sv, 0, &long_needle));

    // 2. 查找空子串，返回当前传入的检索起始点
    ASSERT_LL_EQ(2, c_StringView_FindStr(&main_sv, 2, &empty_needle));

    // 3. 起始检索点越界，返回 -1
    ASSERT_LL_EQ(-1, c_StringView_FindStr(&main_sv, 99, &empty_needle));

    // 4. 完全没有匹配项的情况
    c_StringView_t target = c_StringView_FromCStr("missing");
    ASSERT_LL_EQ(-1, c_StringView_FindStr(&main_sv, 0, &target));
}


int main(int argc, char** argv){
    TEST_START(c_StringView_t_TestSuite);
    RUN_TEST(test_c_StringView_Creation);
    RUN_TEST(test_c_StringView_Sub);
    RUN_TEST(test_c_StringView_RemovePrefix);
    RUN_TEST(test_c_StringView_Trim);
    RUN_TEST(test_c_StringView_Cmp_and_IsEq);
    RUN_TEST(test_c_StringView_Fixes);
    RUN_TEST(test_c_StringView_FindChar);
    RUN_TEST(test_c_StringView_Split);
    RUN_TEST(test_c_StringView_ToUL_Basic);
    RUN_TEST(test_c_StringView_ToUL_Bases);
    RUN_TEST(test_c_StringView_ToUL_Bounds);
    RUN_TEST(test_c_StringView_ToUL_Invalid);
    RUN_TEST(test_c_StringView_ToDouble_Basic);
    RUN_TEST(test_c_StringView_ToDouble_Scientific);
    RUN_TEST(test_c_StringView_ToDouble_Bounds);
    RUN_TEST(test_c_StringView_ToDouble_Invalid);
    RUN_TEST(test_c_StringView_ToCStr_Buf_Basic);
    RUN_TEST(test_c_StringView_ToCStr_Buf_Truncate);
    RUN_TEST(test_c_StringView_ToCStr_Buf_NoNullTerminatorView);
    RUN_TEST(test_c_StringView_ToCStr_Buf_Invalid);
    RUN_TEST(test_c_StringView_FindStr_Basic);
    RUN_TEST(test_c_StringView_FindStr_Positions);
    RUN_TEST(test_c_StringView_FindStr_NoNullTerminator);
    RUN_TEST(test_c_StringView_FindStr_EdgeAndInvalid);
    TEST_REPORT();
    RETURN_TEST_STATUS;
}