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

// ==========================================
// 1. 测试框架配套：虚操作函数模拟实现
// ==========================================

// --- Key 虚操作实现：以动态独立分配内存、长度未知的“深层堆字符串指针 (char**)”作为键 ---
static uint32_t test_key_string_hash(const void* data, void* arg) {
    (void)arg;
    const char* str = *(const char* const*)data;
    uint32_t hash = 0;
    while (*str) {
        hash = 31 * hash + (unsigned char)(*str);
        str++;
    }
    return hash;
}

static void* test_key_string_cp(const void* data, void* arg) {
    (void)arg;
    const char* original = *(const char* const*)data;
    char* clone = (char*)malloc(strlen(original) + 1);
    if (clone) strcpy(clone, original);

    char** storage = (char**)malloc(sizeof(char*));
    if (storage) *storage = clone;
    return (void*)storage;
}

static void test_key_string_free(void* data, void* arg) {
    (void)arg;
    if (data) {
        char** storage = (char**)data;
        free(*storage);
        free(storage);
    }
}

static bool test_key_string_eq(const void* data1, const void* data2, void* arg) {
    (void)arg;
    const char* s1 = *(const char* const*)data1;
    const char* s2 = *(const char* const*)data2;
    return strcmp(s1, s2) == 0;
}

// --- Value 虚操作实现：以动态独立分配内存的“结构体对象指针 (Task_t**)”作为值 ---
typedef struct {
    int id;
    int payload;
} TestTask_t;

static void* test_val_task_cp(const void* data, void* arg) {
    (void)arg;
    const TestTask_t* original = *(const TestTask_t* const*)data;
    TestTask_t* clone = (TestTask_t*)malloc(sizeof(TestTask_t));
    if (clone) {
        clone->id = original->id;
        clone->payload = original->payload;
    }

    TestTask_t** storage = (TestTask_t**)malloc(sizeof(TestTask_t*));
    if (storage) *storage = clone;
    return (void*)storage;
}

static void test_val_task_free(void* data, void* arg) {
    (void)arg;
    if (data) {
        TestTask_t** storage = (TestTask_t**)data;
        free(*storage);
        free(storage);
    }
}

static bool test_val_task_eq(const void* data1, const void* data2, void* arg) {
    (void)arg;
    const TestTask_t* t1 = *(const TestTask_t* const*)data1;
    const TestTask_t* t2 = *(const TestTask_t* const*)data2;
    return (t1->id == t2->id && t1->payload == t2->payload);
}

// ==========================================
// 2. 自动化单元测试集
// ==========================================

TEST_CASE(test_c_HashST_Base_CRUD_Flow) {
    c_HashST_t map;

    // 1. 初始化多态虚操作集（Key 采用堆字符串，Value 采用堆任务结构体）
    c_HashKeyOps_t key_ops = { test_key_string_hash, test_key_string_cp, test_key_string_free, test_key_string_eq, NULL };
    c_HashValOps_t val_ops = { test_val_task_cp, test_val_task_free, test_val_task_eq, NULL };

    // 2. 初始化初始容量为 4 的哈希符号表
    c_err_t err = c_HashST_Init(&map, 4, key_ops, val_ops, &c_DefaultAllocator);
    ASSERT_INT_EQ(C_ERR_OK, err);

    // 声明待插入的临时浅数据线
    const char* k1 = "Task_Alpha";   TestTask_t t1_raw = { 101, 555 };  const TestTask_t* v1 = &t1_raw;
    const char* k2 = "Task_Beta";    TestTask_t t2_raw = { 102, 666 };  const TestTask_t* v2 = &t2_raw;
    const char* k3 = "Task_Gamma";   TestTask_t t3_raw = { 103, 777 };  const TestTask_t* v3 = &t3_raw;

    // 3. Put 添加行为断言
    ASSERT_INT_EQ(C_ERR_OK, c_HashST_Put(&map, &k1, &v1));
    ASSERT_INT_EQ(C_ERR_OK, c_HashST_Put(&map, &k2, &v2));
    ASSERT_INT_EQ(C_ERR_OK, c_HashST_Put(&map, &k3, &v3));
    ASSERT_INT_EQ(3, (int)map.size);

    // 4. Contains 包含性状态断言（使用物理地址不同的副本 Key 进行全等检索）
    const char* search_k1 = "Task_Alpha";
    const char* search_fake = "Task_Unknown";
    ASSERT_TRUE(c_HashST_Contains(&map, &search_k1));
    ASSERT_TRUE(!c_HashST_Contains(&map, &search_fake));

    // 5. Get 数据读取与物理结构体字段穿透比对
    void* get_res_ptr = c_HashST_Get(&map, &search_k1);
    ASSERT_TRUE(get_res_ptr != NULL);

    // 穿透二级指针，精确检验深拷贝出来的值的成员变量
    TestTask_t* matched_task = *(TestTask_t**)get_res_ptr;
    ASSERT_INT_EQ(101, matched_task->id);
    ASSERT_INT_EQ(555, matched_task->payload);

    // 6. Put 相同键下的覆写更新（Overwrite）语义核验
    TestTask_t t1_update_raw = { 101, 9999 }; const TestTask_t* v1_update = &t1_update_raw;
    ASSERT_INT_EQ(C_ERR_OK, c_HashST_Put(&map, &k1, &v1_update));
    ASSERT_INT_EQ(3, (int)map.size); // 覆写后，全局哈希大小必须守恒

    get_res_ptr = c_HashST_Get(&map, &search_k1);
    ASSERT_TRUE(get_res_ptr != NULL);
    ASSERT_INT_EQ(9999, (*(TestTask_t**)get_res_ptr)->payload); // 配额必须已被更新覆盖

    // 7. Remove 单路摘除断言
    ASSERT_INT_EQ(C_ERR_OK, c_HashST_Remove(&map, &search_k1));
    ASSERT_INT_EQ(2, (int)map.size); // 递减正确
    ASSERT_TRUE(c_HashST_Get(&map, &search_k1) == NULL); // 再拿应该彻底变空

    // 8. 全清理注销销毁线，多态自由解构，阻断任何残留
    c_HashST_Destroy(&map);
}

TEST_CASE(test_c_HashST_Resize_And_Collision) {
    c_HashST_t map;
    c_HashKeyOps_t key_ops = { test_key_string_hash, test_key_string_cp, test_key_string_free, test_key_string_eq, NULL };
    c_HashValOps_t val_ops = { test_val_task_cp, test_val_task_free, test_val_task_eq, NULL };

    // 1. 初始化一个极小容量的哈希表（故意设为 1，强迫后面插入的所有节点落入同一个桶中，构成 100% 碰撞拉链链条）
    c_err_t err = c_HashST_Init(&map, 1, key_ops, val_ops, &c_DefaultAllocator);
    ASSERT_INT_EQ(C_ERR_OK, err);

    const char* k1 = "Key_Coll_1"; TestTask_t t1 = { 1, 10 }; const TestTask_t* v1 = &t1;
    const char* k2 = "Key_Coll_2"; TestTask_t t2 = { 2, 20 }; const TestTask_t* v2 = &t2;
    const char* k3 = "Key_Coll_3"; TestTask_t t3 = { 3, 30 }; const TestTask_t* v3 = &t3;

    ASSERT_INT_EQ(C_ERR_OK, c_HashST_Put(&map, &k1, &v1));
    ASSERT_INT_EQ(C_ERR_OK, c_HashST_Put(&map, &k2, &v2));
    ASSERT_INT_EQ(C_ERR_OK, c_HashST_Put(&map, &k3, &v3));

    // 2. NumCol 碰撞指标验证：在容量为 1 且塞入 3 个数据时，产生的物理碰撞线数必然为 2 次
    ASSERT_INT_EQ(2, (int)c_HashST_NumCol(&map));

    // 3. 核心压测：触发大跨度扩容变轨（容量从 1 直接倍增重塑至 16）
    // 扩容后，原先挤在 0 号桶拉链中的 3 个冲突节点必须被重新洗牌、散列分流到各个新桶中
    ASSERT_INT_EQ(C_ERR_OK, c_HashST_Resize(&map, 16));
    ASSERT_INT_EQ(16, (int)map.capacity);
    ASSERT_INT_EQ(3, (int)map.size); // 全局大小守恒不变

    // 4. 扩容分流后的碰撞指标必须自适应下降（通常随机散列到 16 个桶中后，碰撞数会锐减为 0）
    ASSERT_TRUE(c_HashST_NumCol(&map) < 2);

    // 5. 扩容变轨后，再次使用 Get 穿透读取，验证多态路由未丢失
    const char* search_k3 = "Key_Coll_3";
    void* get_res_ptr = c_HashST_Get(&map, &search_k3);
    ASSERT_TRUE(get_res_ptr != NULL);
    ASSERT_INT_EQ(30, (*(TestTask_t**)get_res_ptr)->payload);

    c_HashST_Destroy(&map);
}

TEST_CASE(test_c_HashST_Empty_And_Toxicity_Defenses) {
    c_HashST_t map;
    c_HashKeyOps_t key_ops = { test_key_string_hash, test_key_string_cp, test_key_string_free, test_key_string_eq, NULL };
    c_HashValOps_t val_ops = { test_val_task_cp, test_val_task_free, test_val_task_eq, NULL };

    c_HashST_Init(&map, 4, key_ops, val_ops, NULL); // 降级测试

    const char* k = "Toxic_Key";

    // 1. 空仓返回与毒入参前置拦截防御
    ASSERT_TRUE(c_HashST_Get(&map, &k) == NULL);
    ASSERT_TRUE(!c_HashST_Contains(&map, &k));
    ASSERT_INT_EQ(C_ERR_NOTFOUND, c_HashST_Remove(&map, &k));
    ASSERT_INT_EQ(0, (int)c_HashST_NumCol(&map));

    ASSERT_INT_EQ(C_ERR_PARAM, c_HashST_Init(NULL, 4, key_ops, val_ops, NULL));

    c_HashST_Destroy(&map);
}

// ==========================================
// 3. 独立测试运行入口
// ==========================================
int main(void) {
    TEST_START(C_HashST_PolymorphicObject_TestSuite);

    // 顺序调度高级多态哈希表的各项极限业务场景
    RUN_TEST(test_c_HashST_Base_CRUD_Flow);
    RUN_TEST(test_c_HashST_Resize_And_Collision);
    RUN_TEST(test_c_HashST_Empty_And_Toxicity_Defenses);

    TEST_REPORT();

    RETURN_TEST_STATUS;
}