#include "c_IndexMaxPQ.h"
#include "c_Test.h"

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

static int index_pq_compare_ints(const void* a, const void* b, void* args) {
    (void)args;
    int arg1 = *(const int*)a;
    int arg2 = *(const int*)b;
    if (arg1 < arg2) return -1;
    if (arg1 > arg2) return 1;
    return 0;
}

TEST_CASE(test_c_IndexMaxPQ_IncreaseKeyFlow) {
    c_IndexMaxPQ_t ipq;
    // 允许最大的顶点唯一标识范围为 0 到 9 (共10个元素上界)
    c_err_t err = c_IndexMaxPQ_Init(&ipq, 10, sizeof(int), index_pq_compare_ints, NULL, &c_DefaultAllocator);
    ASSERT_INT_EQ(C_ERR_OK, err);

    // 模拟多路连接池的最大带宽配额管理。唯一ID为索引，当前流量分数为键值
    int score_node_0 = 50;
    int score_node_1 = 12; // 此时节点 1 权重最小 (12)
    int score_node_2 = 85; // 此时节点 2 权重最大 (85)

    ASSERT_INT_EQ(C_ERR_OK, c_IndexMaxPQ_Push(&ipq, 0, &score_node_0));
    ASSERT_INT_EQ(C_ERR_OK, c_IndexMaxPQ_Push(&ipq, 1, &score_node_1));
    ASSERT_INT_EQ(C_ERR_OK, c_IndexMaxPQ_Push(&ipq, 2, &score_node_2));

    // 全局状态路由包含性验证
    ASSERT_TRUE(c_IndexMaxPQ_Contains(&ipq, 0));
    ASSERT_TRUE(c_IndexMaxPQ_Contains(&ipq, 1));
    ASSERT_TRUE(c_IndexMaxPQ_Contains(&ipq, 2));
    ASSERT_TRUE(!c_IndexMaxPQ_Contains(&ipq, 8));

    // 🌟【核心中途剧变测试】：节点 1 发生突发流量暴涨，其权重从 12 直接被中途修改飙升到 200！
    // 此时节点 1 (键值 200) 顺理成章地超越原霸主节点 2，逆袭变成本索引最大堆的绝对最高峰！
    int bursting_score_node_1 = 200;
    ASSERT_INT_EQ(C_ERR_OK, c_IndexMaxPQ_Change(&ipq, 1, &bursting_score_node_1));

    c_size_t popped_index = 999;

    // 第一次 Pop 弹出的绝对必须是飙升后全局权重最大、优先级最高的节点 1，而不是原本的节点 2！
    ASSERT_INT_EQ(C_ERR_OK, c_IndexMaxPQ_Pop(&ipq, &popped_index));
    ASSERT_INT_EQ(1, (int)popped_index);
    ASSERT_TRUE(!c_IndexMaxPQ_Contains(&ipq, 1)); // 弹出状态平滑注销

    // 第二次 Pop 弹出的应该是次高位的原节点 2 (键值 85)
    ASSERT_INT_EQ(C_ERR_OK, c_IndexMaxPQ_Pop(&ipq, &popped_index));
    ASSERT_INT_EQ(2, (int)popped_index);

    // 最后弹出节点 0 (键值 50)
    ASSERT_INT_EQ(C_ERR_OK, c_IndexMaxPQ_Pop(&ipq, &popped_index));
    ASSERT_INT_EQ(0, (int)popped_index);

    // 终极空仓防御校验
    ASSERT_INT_EQ(C_ERR_EMPTY, c_IndexMaxPQ_Pop(&ipq, &popped_index));

    c_IndexMaxPQ_Destroy(&ipq);
}

TEST_CASE(test_c_IndexMaxPQ_Constraints) {
    c_IndexMaxPQ_t local_ipq;
    int dummy = 42;
    // 验证越界输入或空参数的前置状态码强拦截线
    ASSERT_INT_EQ(C_ERR_PARAM, c_IndexMaxPQ_Init(NULL, 10, sizeof(int), index_pq_compare_ints, NULL, NULL));
    ASSERT_INT_EQ(C_ERR_OK, c_IndexMaxPQ_Init(&local_ipq, 10, sizeof(int), index_pq_compare_ints, NULL, NULL));
    ASSERT_INT_EQ(C_ERR_PARAM, c_IndexMaxPQ_Push(&local_ipq, 9999, &dummy)); // 9999 溢出上界
    c_IndexMaxPQ_Destroy(&local_ipq);
}

// ==========================================
// 5. 主集成入口
// ==========================================
int main(void) {
    TEST_START(C_IndexMaxPQ_Isolated_TestSuite);
    RUN_TEST(test_c_IndexMaxPQ_IncreaseKeyFlow);
    RUN_TEST(test_c_IndexMaxPQ_Constraints);
    TEST_REPORT();
    return (g_test_registry.failed_count > 0 ? 1 : 0);
}