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

static int sort_compare_ints_with_args(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;
}

typedef struct {
    char label;
    int primary;
    int secondary;
} LogMeta_t;

// 复合结构体双级比对器：优先按 primary 升序，相同时按 secondary 降序
static int sort_compare_logs(const void* a, const void* b, void* args) {
    (void)args;
    const LogMeta_t* l1 = (const LogMeta_t*)a;
    const LogMeta_t* l2 = (const LogMeta_t*)b;
    if (l1->primary != l2->primary) {
        return l1->primary - l2->primary;
    }
    return l2->secondary - l1->secondary;
}

TEST_CASE(test_c_HeapSort_BasicInts) {
    // 准备一组带有高频大量重复项的恶劣随机分布整型集合，验证单调非减
    int arr[] = { 45, 12, 85, 45, 5, 67, 12, 90, 45, 1 };
    c_size_t num = sizeof(arr) / sizeof(arr[0]);

    c_HeapSort(arr, num, sizeof(int), sort_compare_ints_with_args, NULL);

    // 验证全区间无损单调递增性
    for (c_size_t i = 0; i < num - 1; i++) {
        if (arr[i] > arr[i + 1]) {
            // 利用您已有的精确断言对数值冲突点实施高精确报错打印
            ASSERT_INT_EQ(arr[i + 1], arr[i]);
            return;
        }
    }
    ASSERT_INT_EQ(1, arr[0]);
    ASSERT_INT_EQ(5, arr[1]);
    ASSERT_INT_EQ(45, arr[4]); // 重复项完美挤压归位
    ASSERT_INT_EQ(90, arr[num - 1]); // 尾部必须收拢为最大值 90
}

TEST_CASE(test_c_HeapSort_StructArray) {
    // 复杂业务多主键对象的就地堆排序搬运测试
    LogMeta_t logs[] = {
        { 'A', 50, 100 },
        { 'B', 20, 300 },
        { 'C', 50, 400 }, // primary 键同为 50，但 secondary 次键 400 应当在 100 前面（降序）
        { 'D', 10, 200 }
    };
    c_size_t num = sizeof(logs) / sizeof(logs[0]);

    c_HeapSort(logs, num, sizeof(LogMeta_t), sort_compare_logs, NULL);

    // 预期就地堆排序后的精确物理排布顺序: D(10/200) -> B(20/300) -> C(50/400) -> A(50/100)
    // 严格引入了正确的数组下标位置，杜绝了前几轮的数组名称未加下标引用笔误
    ASSERT_INT_EQ(10, logs[0].primary);
    ASSERT_TRUE(logs[0].label == 'D');

    ASSERT_INT_EQ(20, logs[1].primary);
    ASSERT_TRUE(logs[1].label == 'B');

    ASSERT_INT_EQ(50, logs[2].primary);
    ASSERT_INT_EQ(400, logs[2].secondary); // 降序次键优先被堆顶下沉挪移到左侧插槽
    ASSERT_TRUE(logs[2].label == 'C');

    ASSERT_INT_EQ(50, logs[3].primary);
    ASSERT_INT_EQ(100, logs[3].secondary);
    ASSERT_TRUE(logs[3].label == 'A');
}

TEST_CASE(test_c_HeapSort_ExtremeEdges) {
    // 压测完全有序和完全逆序序列，全方位高强度检验 `num >> 1` 自底向上建堆边界的拦截安全性
    int rev_arr[] = { 5, 4, 3, 2, 1 };
    c_size_t num = sizeof(rev_arr) / sizeof(rev_arr[0]);

    c_HeapSort(rev_arr, num, sizeof(int), sort_compare_ints_with_args, NULL);
    for (c_size_t i = 0; i < num - 1; i++) {
        ASSERT_TRUE(rev_arr[i] < rev_arr[i + 1]);
    }

    // 极端输入空边界及单元素优雅退出拦截断言
    int single_arr[] = { 66666 };
    c_HeapSort(single_arr, 1, sizeof(int), sort_compare_ints_with_args, NULL);
    c_HeapSort(NULL, 0, sizeof(int), sort_compare_ints_with_args, NULL);
    ASSERT_INT_EQ(66666, single_arr[0]);
}

// ==========================================
// 5. 独立集成主入口点
// ==========================================
int main(void) {
    TEST_START(C_HeapSort_Isolated_TestSuite);

    // 顺序触发堆排序专线的全景自动化验证
    RUN_TEST(test_c_HeapSort_BasicInts);
    RUN_TEST(test_c_HeapSort_StructArray);
    RUN_TEST(test_c_HeapSort_ExtremeEdges);

    TEST_REPORT();
    RETURN_TEST_STATUS;
}