#include "c_BinarySearchST.h"
#include "c_Test.h"
#include <stdlib.h>
#include <stdio.h>

static int bst_compare_chars(const void* a, const void* b, void* args) {
    (void)args;
    char char1 = *(const char*)a;
    char char2 = *(const char*)b;
    return char1 - char2;
}

TEST_CASE(test_c_BinarySearchST_Sorted_CRUD) {
    c_BinarySearchST_t st;
    // 初始化一个仅有 2 容量的有序列，强制触发自增扩容
    c_err_t err = c_BinarySearchST_Init(&st, 2, sizeof(char), sizeof(int), bst_compare_chars, NULL, &c_DefaultAllocator);
    ASSERT_INT_EQ(C_ERR_OK, err);

    char key_M = 'M'; int val_M = 400;
    char key_B = 'B'; int val_B = 100;
    char key_R = 'R'; int val_R = 500;
    char key_G = 'G'; int val_G = 200;

    // 1. 乱序 Put 入队，内部数据平移必须能够将其安全纠正排序为严格的: B -> G -> M -> R 升序
    ASSERT_INT_EQ(C_ERR_OK, c_BinarySearchST_Put(&st, &key_M, &val_M));
    ASSERT_INT_EQ(C_ERR_OK, c_BinarySearchST_Put(&st, &key_B, &val_B));
    ASSERT_INT_EQ(C_ERR_OK, c_BinarySearchST_Put(&st, &key_R, &val_R));
    ASSERT_INT_EQ(C_ERR_OK, c_BinarySearchST_Put(&st, &key_G, &val_G));
    ASSERT_INT_EQ(4, (int)st.size);

    // 2. 验证底层有序性排列的插槽指向物理存储
    ASSERT_INT_EQ('B', st.keys[0]);
    ASSERT_INT_EQ('G', st.keys[1]);
    ASSERT_INT_EQ('M', st.keys[2]);
    ASSERT_INT_EQ('R', st.keys[3]);

    // 3. Get 二分高速检索断言
    int get_result = 0;
    ASSERT_INT_EQ(C_ERR_OK, c_BinarySearchST_Get(&st, &key_M, &get_result));
    ASSERT_INT_EQ(400, get_result);

    // 4. Overwrite 覆写测试
    int update_val_M = 8888;
    ASSERT_INT_EQ(C_ERR_OK, c_BinarySearchST_Put(&st, &key_M, &update_val_M));
    ASSERT_INT_EQ(C_ERR_OK, c_BinarySearchST_Get(&st, &key_M, &get_result));
    ASSERT_INT_EQ(8888, get_result);

    // 5. 极低值溢出核验：检索一个比全队首项还小的 Key ('A' < 'B')
    // 修复后的 Rank 在无符号数下应当将 high 收缩到 0 号位置而不是下溢到最大值爆发死循环
    char toxic_key = 'A';
    ASSERT_TRUE(!c_BinarySearchST_Contains(&st, &toxic_key));

    // 6. Delete 滑窗前移覆盖移出测试
    ASSERT_INT_EQ(C_ERR_OK, c_BinarySearchST_Delete(&st, &key_G));
    ASSERT_INT_EQ(3, (int)st.size);
    // 移出后原属于 G 的 下标 1 应该被后面的 M(keys='M') 顺理成章顶替
    ASSERT_INT_EQ('M', st.keys[1]);
    ASSERT_INT_EQ(C_ERR_NOTFOUND, c_BinarySearchST_Get(&st, &key_G, &get_result));

    c_BinarySearchST_Destroy(&st);
}

TEST_CASE(test_c_BinarySearchST_EmptyAndToxicity) {
    c_BinarySearchST_t local_st;
    c_BinarySearchST_Init(&local_st, 4, sizeof(char), sizeof(int), bst_compare_chars, NULL, NULL);

    char k = 'X';
    int v = 99;
    // 验证拦截防御
    ASSERT_INT_EQ(C_ERR_PARAM, c_BinarySearchST_Init(NULL, 4, sizeof(char), sizeof(int), bst_compare_chars, NULL, NULL));
    ASSERT_INT_EQ(C_ERR_EMPTY, c_BinarySearchST_Delete(&local_st, &k)); // 空仓删除安全抛出 C_ERR_EMPTY
    ASSERT_INT_EQ(C_ERR_EMPTY, c_BinarySearchST_Get(&local_st, &k, &v));

    c_BinarySearchST_Destroy(&local_st);
}

// ==========================================
// 5. 主集成入口
// ==========================================
int main(void) {
    TEST_START(C_BinarySearchST_UnsignedSafe_TestSuite);
    RUN_TEST(test_c_BinarySearchST_Sorted_CRUD);
    RUN_TEST(test_c_BinarySearchST_EmptyAndToxicity);
    TEST_REPORT();
    RETURN_TEST_STATUS;
}