#include <it2s-asn/etsi-its-v2/cpm/EI2_CollectivePerceptionMessage.h>
#include <order.h>
#include <unity.h>

void setUp(void) {
    // set stuff up here
}

void tearDown(void) {
    // clean stuff up here
}

void test_ldm_order_new(void) {
    EI2_OrderTuple_t *tuple1 = calloc(1, sizeof(*tuple1));
    OCTET_STRING_fromBuf(&tuple1->attribute, "referenceTime", -1);
    tuple1->orderingDirection = EI2_OrderingDirection_ascending;

    EI2_Order_t *asn_order = calloc(1, sizeof(*asn_order));
    ASN_SEQUENCE_ADD(&asn_order->list, tuple1);

    // asn_fprint(stdout, &asn_DEF_EI2_Order, asn_order);

    ldm_order_t *order = ldm_order_new(asn_order, ldm_data_type_CPM);
    TEST_ASSERT_MESSAGE(order != NULL, "New order should not return NULL when type is CPM and order is valid");

    EI2_CollectivePerceptionMessage_t **cpm_arr = calloc(10, sizeof(*cpm_arr));

    for (int i = 0; i < 10; ++i) {
        cpm_arr[i] = calloc(1, sizeof(*cpm_arr[i]));
        asn_uint642INTEGER(&cpm_arr[i]->payload.managementContainer.referenceTime, 1000 - i);
    }

    ldm_order_apply(order, (void **)cpm_arr, 10);

    for (int i = 0; i < 10; ++i) {
        uint64_t ref_time;
        asn_INTEGER2uint64(&cpm_arr[i]->payload.managementContainer.referenceTime, &ref_time);

        TEST_ASSERT_MESSAGE(ref_time == (uint64_t)(1000 - 9 + i), "Order should sort the array by referenceTime in ascending order");
    }

    ldm_order_release(order);

    // change ordering direction

    tuple1->orderingDirection = EI2_OrderingDirection_descending;

    order = ldm_order_new(asn_order, ldm_data_type_CPM);
    TEST_ASSERT_MESSAGE(order != NULL, "New order should not return NULL when type is CPM and order is valid");

    ldm_order_apply(order, (void **)cpm_arr, 10);

    for (int i = 0; i < 10; ++i) {
        uint64_t ref_time;
        asn_INTEGER2uint64(&cpm_arr[i]->payload.managementContainer.referenceTime, &ref_time);

        TEST_ASSERT_MESSAGE(ref_time == (uint64_t)(1000 - i), "Order should sort the array by referenceTime in descending order");
    }

    ldm_order_release(order);

    // two tuples in the order (only one is apply due to not having tiebreakers)

    EI2_OrderTuple_t *tuple2 = calloc(1, sizeof(*tuple1));
    OCTET_STRING_fromBuf(&tuple2->attribute, "referenceTime", -1);
    tuple2->orderingDirection = EI2_OrderingDirection_ascending;
    ASN_SEQUENCE_ADD(&asn_order->list, tuple2);

    order = ldm_order_new(asn_order, ldm_data_type_CPM);
    TEST_ASSERT_MESSAGE(order != NULL, "New order should not return NULL when type is CPM and order is valid");

    ldm_order_apply(order, (void **)cpm_arr, 10);

    for (int i = 0; i < 10; ++i) {
        uint64_t ref_time;
        asn_INTEGER2uint64(&cpm_arr[i]->payload.managementContainer.referenceTime, &ref_time);

        TEST_ASSERT_MESSAGE(ref_time == (uint64_t)(1000 - i), "Order should sort the array by referenceTime in descending order");
        ASN_STRUCT_FREE(asn_DEF_EI2_CollectivePerceptionMessage, cpm_arr[i]);
    }

    ldm_order_release(order);
    ASN_STRUCT_FREE(asn_DEF_EI2_Order, asn_order);
    free(cpm_arr);
}

void test_ldm_order_multiple(void) {
    EI2_OrderTuple_t *tuple1 = calloc(1, sizeof(*tuple1));
    OCTET_STRING_fromBuf(&tuple1->attribute, "referenceTime", -1);
    tuple1->orderingDirection = EI2_OrderingDirection_ascending;

    EI2_OrderTuple_t *tuple2 = calloc(1, sizeof(*tuple2));
    OCTET_STRING_fromBuf(&tuple2->attribute, "altitude", -1);
    tuple2->orderingDirection = EI2_OrderingDirection_descending;

    EI2_OrderTuple_t *tuple3 = calloc(1, sizeof(*tuple3));
    OCTET_STRING_fromBuf(&tuple3->attribute, "latitude", -1);
    tuple3->orderingDirection = EI2_OrderingDirection_descending;

    EI2_Order_t *asn_order = calloc(1, sizeof(*asn_order));
    ASN_SEQUENCE_ADD(&asn_order->list, tuple1);
    ASN_SEQUENCE_ADD(&asn_order->list, tuple2);
    ASN_SEQUENCE_ADD(&asn_order->list, tuple3);

    ldm_order_t *order = ldm_order_new(asn_order, ldm_data_type_CPM);
    TEST_ASSERT_MESSAGE(order != NULL, "New order should not return NULL when type is CPM and order is valid");

    EI2_CollectivePerceptionMessage_t **cpm_arr = calloc(100, sizeof(*cpm_arr));
    for (int i = 0; i < 100; ++i) {
        cpm_arr[i] = calloc(1, sizeof(*cpm_arr[i]));
        asn_uint642INTEGER(&cpm_arr[i]->payload.managementContainer.referenceTime, rand() % 1000000);
        cpm_arr[i]->payload.managementContainer.referencePosition.altitude.altitudeValue = rand() % 1000;
        cpm_arr[i]->payload.managementContainer.referencePosition.latitude = rand() % 1000000;
    }
    uint64_t ref_val;
    asn_INTEGER2uint64(&cpm_arr[0]->payload.managementContainer.referenceTime, &ref_val);
    for (int i = 1; i <= 20; ++i) {
        asn_uint642INTEGER(&cpm_arr[i * 3]->payload.managementContainer.referenceTime, ref_val);
    }
    for (int i = 1; i <= 10; ++i) {
        cpm_arr[i * 6]->payload.managementContainer.referencePosition.altitude.altitudeValue =
            cpm_arr[0]->payload.managementContainer.referencePosition.altitude.altitudeValue;
    }
    for (int i = 1; i <= 5; ++i) {
        cpm_arr[i * 9]->payload.managementContainer.referencePosition.latitude =
            cpm_arr[0]->payload.managementContainer.referencePosition.latitude;
    }

    ldm_order_apply(order, (void **)cpm_arr, 100);

    for (int i = 0; i < 100; ++i) {
        uint64_t ref_time;
        asn_INTEGER2uint64(&cpm_arr[i]->payload.managementContainer.referenceTime, &ref_time);
        int32_t alt = cpm_arr[i]->payload.managementContainer.referencePosition.altitude.altitudeValue;
        int32_t lat = cpm_arr[i]->payload.managementContainer.referencePosition.latitude;
        if (i > 0) {
            uint64_t prev_ref_time;
            asn_INTEGER2uint64(&cpm_arr[i - 1]->payload.managementContainer.referenceTime, &prev_ref_time);
            TEST_ASSERT_MESSAGE(ref_time >= prev_ref_time, "Order should sort the array by referenceTime in ascending order");
            if (ref_time == prev_ref_time) {
                TEST_ASSERT_MESSAGE(alt <= cpm_arr[i - 1]->payload.managementContainer.referencePosition.altitude.altitudeValue,
                                    "Order should sort the array by altitude in descending order when referenceTime is equal");
                if (alt == cpm_arr[i - 1]->payload.managementContainer.referencePosition.altitude.altitudeValue) {
                    TEST_ASSERT_MESSAGE(lat <= cpm_arr[i - 1]->payload.managementContainer.referencePosition.latitude,
                                        "Order should sort the array by latitude in descending order when altitude is equal");
                }
            }
        }
    }
    for (int i = 0; i < 100; ++i) {
        ASN_STRUCT_FREE(asn_DEF_EI2_CollectivePerceptionMessage, cpm_arr[i]);
    }

    ldm_order_release(order);
    ASN_STRUCT_FREE(asn_DEF_EI2_Order, asn_order);
    free(cpm_arr);
}

int main(void) {
    UNITY_BEGIN();
    RUN_TEST(test_ldm_order_new);
    RUN_TEST(test_ldm_order_multiple);
    return UNITY_END();
}