#include <entity.h>
#include <unity.h>

// static ldm_entity_storage_t entities;

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

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

static void testEntityInit(void) {
    static ldm_entity_storage_t entities;
    ldm_entity_storage_init(&entities);

    for (int i = 0; i < ldm_entity_storage_map_size; ++i) {
        TEST_ASSERT_NULL_MESSAGE(entities.providers[i], "entities.providers[i] should be NULL");
        TEST_ASSERT_NULL_MESSAGE(entities.consumers[i], "entities.consumers[i] should be NULL");
    }
}

static void testEntityAddDeleteSingle(void) {
    int rv = 0;
    static ldm_entity_storage_t entities;
    ldm_entity_storage_init(&entities);

    // provider configuration
    ldm_its_aid_t prov_its_aid = 10;
    ldm_permissions_t prov_perm;
    for (int i = 0; i < ldm_data_type_total; ++i) {
        prov_perm.list[i] = false;
        if (i == ldm_data_type_CAM) {
            prov_perm.list[i] = true;
        }
    }
    uint64_t prov_def_val = 1000;  // ms

    // add a provider
    rv = ldm_entity_storage_add_provider(&entities, prov_its_aid, prov_perm, prov_def_val);
    TEST_ASSERT_MESSAGE(rv == 0, "Provider was not added to entities");
    rv = ldm_entity_storage_get_permission_provider(&entities, prov_its_aid, ldm_data_type_CAM);
    TEST_ASSERT_MESSAGE(rv == 1, "Provider was not verified correctly");
    TEST_ASSERT_MESSAGE(ldm_entity_storage_get_default_validity_provider(&entities, prov_its_aid) == prov_def_val,
                        "Provider default validity is not correct");
    rv = ldm_entity_storage_revoke(&entities, prov_its_aid);
    TEST_ASSERT_MESSAGE(rv == 0, "Provider was not revoked from entities");
    rv = ldm_entity_storage_get_permission_provider(&entities, prov_its_aid, ldm_data_type_CAM);
    TEST_ASSERT_MESSAGE(rv == 1, "Provider was not verified correctly");
    rv = ldm_entity_storage_get_revoked_provider(&entities, prov_its_aid);
    TEST_ASSERT_MESSAGE(rv == 1, "Provider was not revoked correctly");

    // delete a provider
    rv = ldm_entity_storage_delete_provider(&entities, prov_its_aid);
    TEST_ASSERT_MESSAGE(rv == 0, "Provider was not deleted from entities");
    for (int i = 0; i < ldm_entity_storage_map_size; ++i) {
        TEST_ASSERT_NULL_MESSAGE(entities.providers[i], "entities.providers[i] should be NULL");
        TEST_ASSERT_NULL_MESSAGE(entities.consumers[i], "entities.consumers[i] should be NULL");
    }
    rv = ldm_entity_storage_get_permission_provider(&entities, prov_its_aid, ldm_data_type_CAM);
    TEST_ASSERT_MESSAGE(rv == 0, "Provider was not deleted correctly");
    rv = ldm_entity_storage_revoke(&entities, prov_its_aid);
    TEST_ASSERT_MESSAGE(rv == 1, "Provider was not deleted correctly");

    // consumer configuration
    ldm_its_aid_t cons_its_aid = 20;
    ldm_permissions_t cons_perm;
    for (int i = 0; i < ldm_data_type_total; ++i) {
        cons_perm.list[i] = false;
        if (i == ldm_data_type_CPM) {
            cons_perm.list[i] = true;
        }
    }
    ldm_area_t cons_aoi;
    cons_aoi.type = ldm_area_type_circle;
    cons_aoi.shape.circle.radius = 10000;  // 1000.0m

    // add a consumer
    rv = ldm_entity_storage_add_consumer(&entities, cons_its_aid, cons_perm, cons_aoi);
    TEST_ASSERT_MESSAGE(rv == 0, "Consumer was not added to entities");
    rv = ldm_entity_storage_get_permission_consumer(&entities, cons_its_aid, ldm_data_type_CPM);
    TEST_ASSERT_MESSAGE(rv == 1, "Consumer was not verified correctly");
    rv = ldm_entity_storage_revoke(&entities, cons_its_aid);
    TEST_ASSERT_MESSAGE(rv == 0, "Consumer was not revoked from entities");
    rv = ldm_entity_storage_get_permission_consumer(&entities, cons_its_aid, ldm_data_type_CPM);
    TEST_ASSERT_MESSAGE(rv == 1, "Consumer was not verified correctly");
    rv = ldm_entity_storage_get_revoked_consumer(&entities, cons_its_aid);
    TEST_ASSERT_MESSAGE(rv == 1, "Consumer was not revoked correctly");

    // delete a consumer
    rv = ldm_entity_storage_delete_consumer(&entities, cons_its_aid);
    TEST_ASSERT_MESSAGE(rv == 0, "Consumer was not deleted from entities");
    for (int i = 0; i < ldm_entity_storage_map_size; ++i) {
        TEST_ASSERT_NULL_MESSAGE(entities.providers[i], "entities.providers[i] should be NULL");
        TEST_ASSERT_NULL_MESSAGE(entities.consumers[i], "entities.consumers[i] should be NULL");
    }
    rv = ldm_entity_storage_get_permission_consumer(&entities, cons_its_aid, ldm_data_type_CPM);
    TEST_ASSERT_MESSAGE(rv == 0, "Consumer was not deleted correctly");
    rv = ldm_entity_storage_revoke(&entities, cons_its_aid);
    TEST_ASSERT_MESSAGE(rv == 1, "Consumer was not deleted correctly");
}

static void testEntityAddDeleteMultiple(void) {
    int rv = 0;
    ldm_entity_storage_t entities;
    ldm_entity_storage_init(&entities);

    // provider configuration
    ldm_its_aid_t prov_its_aid = 10;
    ldm_permissions_t prov_perm;
    for (int i = 0; i < ldm_data_type_total; ++i) {
        prov_perm.list[i] = false;
        if (i == ldm_data_type_CAM) {
            prov_perm.list[i] = true;
        }
    }
    uint64_t prov_def_val = 1000;  // ms

    // consumer configuration
    ldm_its_aid_t cons_its_aid = 20;
    ldm_permissions_t cons_perm;
    for (int i = 0; i < ldm_data_type_total; ++i) {
        cons_perm.list[i] = false;
        if (i == ldm_data_type_CPM) {
            cons_perm.list[i] = true;
        }
    }
    ldm_area_t cons_aoi;
    cons_aoi.type = ldm_area_type_circle;
    cons_aoi.shape.circle.radius = 10000;  // 1000.0m

    // add multiple providers and consumers
    for (int i = 0; i < ldm_entity_storage_map_size * 3; ++i) {
        if (i == ldm_entity_storage_map_size * 2 + 1) {  // change permissions
            prov_perm.list[ldm_data_type_DENM] = true;
            cons_perm.list[ldm_data_type_CAM] = true;
            prov_def_val = 2000;
        }

        rv = ldm_entity_storage_add_provider(&entities, i, prov_perm, prov_def_val);
        TEST_ASSERT_MESSAGE(rv == 0, "Provider was not added to entities");

        rv = ldm_entity_storage_add_consumer(&entities, i, cons_perm, cons_aoi);
        TEST_ASSERT_MESSAGE(rv == 0, "Consumer was not added to entities");
    }

    // verify provider permissions
    rv = ldm_entity_storage_get_permission_provider(&entities, ldm_entity_storage_map_size * 2, ldm_data_type_CAM);
    TEST_ASSERT_MESSAGE(rv == 1, "Provider permission was not verified correctly");
    rv = ldm_entity_storage_get_permission_provider(&entities, ldm_entity_storage_map_size * 2, ldm_data_type_DENM);
    TEST_ASSERT_MESSAGE(rv == 0, "Provider permission was not verified correctly");
    rv = ldm_entity_storage_get_permission_provider(&entities, ldm_entity_storage_map_size * 2 + 1, ldm_data_type_CAM);
    TEST_ASSERT_MESSAGE(rv == 1, "Provider permission was not verified correctly");
    rv = ldm_entity_storage_get_permission_provider(&entities, ldm_entity_storage_map_size * 2 + 1, ldm_data_type_DENM);
    TEST_ASSERT_MESSAGE(rv == 1, "Provider permission was not verified correctly");

    // check provider default validity
    uint64_t val = ldm_entity_storage_get_default_validity_provider(&entities, ldm_entity_storage_map_size * 2);
    TEST_ASSERT_EQUAL_MESSAGE(val, 1000, "Provider default validity was not retrieved correctly");
    val = ldm_entity_storage_get_default_validity_provider(&entities, ldm_entity_storage_map_size * 2 + 1);
    TEST_ASSERT_EQUAL_MESSAGE(val, 2000, "Provider default validity was not retrieved correctly");

    // verify consumer permissions
    rv = ldm_entity_storage_get_permission_consumer(&entities, ldm_entity_storage_map_size * 2, ldm_data_type_CPM);
    TEST_ASSERT_MESSAGE(rv == 1, "Consumer permission was not verified correctly");
    rv = ldm_entity_storage_get_permission_consumer(&entities, ldm_entity_storage_map_size * 2, ldm_data_type_CAM);
    TEST_ASSERT_MESSAGE(rv == 0, "Consumer permission was not verified correctly");
    rv = ldm_entity_storage_get_permission_consumer(&entities, ldm_entity_storage_map_size * 2 + 1, ldm_data_type_CPM);
    TEST_ASSERT_MESSAGE(rv == 1, "Consumer permission was not verified correctly");
    rv = ldm_entity_storage_get_permission_consumer(&entities, ldm_entity_storage_map_size * 2 + 1, ldm_data_type_CAM);
    TEST_ASSERT_MESSAGE(rv == 1, "Consumer permission was not verified correctly");

    // check entity revocation (occurs for the same its-aid for both providers and consumers)
    rv = ldm_entity_storage_revoke(&entities, ldm_entity_storage_map_size * 2 + 1);
    TEST_ASSERT_MESSAGE(rv == 0, "Consumer was not revoked from entities");
    rv = ldm_entity_storage_get_permission_provider(&entities, ldm_entity_storage_map_size * 2 + 1, ldm_data_type_CPM);
    TEST_ASSERT_MESSAGE(rv == 0, "Provider was not revoked correctly");
    rv = ldm_entity_storage_get_revoked_provider(&entities, ldm_entity_storage_map_size * 2 + 1);
    TEST_ASSERT_MESSAGE(rv == 1, "Provider was not revoked correctly");
    rv = ldm_entity_storage_get_permission_consumer(&entities, ldm_entity_storage_map_size * 2 + 1, ldm_data_type_CPM);
    TEST_ASSERT_MESSAGE(rv == 1, "Consumer was not revoked correctly");
    rv = ldm_entity_storage_get_revoked_consumer(&entities, ldm_entity_storage_map_size * 2 + 1);
    TEST_ASSERT_MESSAGE(rv == 1, "Consumer was not revoked correctly");

    // delete multiple providers and consumers
    rv = ldm_entity_storage_delete_provider(&entities, ldm_entity_storage_map_size * 2 + 1);
    TEST_ASSERT_MESSAGE(rv == 0, "Defined provider was not deleted from entities");
    rv = ldm_entity_storage_delete_consumer(&entities, ldm_entity_storage_map_size * 2 + 1);
    TEST_ASSERT_MESSAGE(rv == 0, "Defined consumer was not deleted from entities");
    for (int i = 0; i < ldm_entity_storage_map_size * 3; ++i) {
        rv = ldm_entity_storage_delete_provider(&entities, i);
        if (i == ldm_entity_storage_map_size * 2 + 1) {
            TEST_ASSERT_MESSAGE(rv == 1, "Previously deleted provider was deleted again (not possible) from entities");
        } else {
            TEST_ASSERT_MESSAGE(rv == 0, "Provider was not deleted from entities");
        }

        rv = ldm_entity_storage_delete_consumer(&entities, i);
        if (i == ldm_entity_storage_map_size * 2 + 1) {
            TEST_ASSERT_MESSAGE(rv == 1, "Previously deleted consumer was deleted again (not possible) from entities");
        } else {
            TEST_ASSERT_MESSAGE(rv == 0, "Consumer was not deleted from entities");
        }
    }

    // verify entities is empty
    for (int i = 0; i < ldm_entity_storage_map_size; ++i) {
        TEST_ASSERT_NULL_MESSAGE(entities.providers[i], "entities.providers[i] should be NULL");
        TEST_ASSERT_NULL_MESSAGE(entities.consumers[i], "entities.consumers[i] should be NULL");
    }
}

static void testEntityAddAfterRevoke(void) {
    int rv = 0;
    ldm_entity_storage_t entities;
    ldm_entity_storage_init(&entities);

    // provider configuration
    ldm_its_aid_t its_aid = 10;
    ldm_permissions_t permissions;
    for (int i = 0; i < ldm_data_type_total; ++i) {
        permissions.list[i] = false;
        if (i == ldm_data_type_CAM) {
            permissions.list[i] = true;
        }
    }
    uint64_t default_validity = 1000;  // ms

    rv = ldm_entity_storage_add_provider(&entities, its_aid, permissions, default_validity);
    TEST_ASSERT_MESSAGE(rv == 0, "Provider was not added to entities");

    // retry after add
    rv = ldm_entity_storage_add_provider(&entities, its_aid, permissions, default_validity);
    TEST_ASSERT_MESSAGE(rv == 1, "Provider was not added to entities");

    rv = ldm_entity_storage_revoke(&entities, its_aid);
    TEST_ASSERT_MESSAGE(rv == 0, "Provider was not revoked from entities");

    rv = ldm_entity_storage_get_permission_provider(&entities, its_aid, ldm_data_type_CAM);
    TEST_ASSERT_MESSAGE(rv == 1, "Provider permission was not verified correctly");
    rv = ldm_entity_storage_get_revoked_provider(&entities, its_aid);
    TEST_ASSERT_MESSAGE(rv == 1, "Provider was not revoked correctly");

    rv = ldm_entity_storage_add_provider(&entities, its_aid, permissions, default_validity);
    TEST_ASSERT_MESSAGE(rv == 0, "Provider was not added to entities after being revoked");

    rv = ldm_entity_storage_delete_provider(&entities, its_aid);
    TEST_ASSERT_MESSAGE(rv == 0, "Provider was not deleted from entities");

    // retry after deletion
    rv = ldm_entity_storage_delete_provider(&entities, its_aid);
    TEST_ASSERT_MESSAGE(rv == 1, "Provider was not deleted from entities");

    // rety revoke after deletion
    rv = ldm_entity_storage_revoke(&entities, its_aid);
    TEST_ASSERT_MESSAGE(rv == 1, "Provider was not revoked from entities");
}
int main(void) {
    UNITY_BEGIN();
    RUN_TEST(testEntityInit);
    RUN_TEST(testEntityAddDeleteSingle);
    RUN_TEST(testEntityAddDeleteMultiple);
    RUN_TEST(testEntityAddAfterRevoke);
    return UNITY_END();
}