#include "maxminddb_test_helper.h"

void test_entry_data(MMDB_s *mmdb, MMDB_entry_s *entry, uint32_t node_number,
                     char * node_record)
{
    MMDB_entry_data_s entry_data;
    int status =
        MMDB_get_value(entry, &entry_data, "ip",
                       NULL);
    cmp_ok(status, "==", MMDB_SUCCESS,
           "successful data lookup for node");
    cmp_ok(
        entry_data.type, "==", MMDB_DATA_TYPE_UTF8_STRING,
        "returned entry type is UTF8_STRING for %s record of node %i",
        node_record, node_number);
}

void run_read_node_tests(MMDB_s *mmdb, const uint32_t tests[][5],
                         int test_count,
                         uint8_t record_size)
{
    for (int i = 0; i < test_count; i++) {
        uint32_t node_number = tests[i][0];
        MMDB_search_node_s node;
        int status = MMDB_read_node(mmdb, node_number, &node);
        if (MMDB_SUCCESS == status) {
            cmp_ok(node.left_record, "==", tests[i][1],
                   "left record for node %i is %i - %i bit DB",
                   node_number, tests[i][1], record_size);
            cmp_ok(node.left_record_type, "==", tests[i][2],
                   "left record type for node %i is %i", node_number,
                   tests[i][2]);
            if (node.left_record_type == MMDB_RECORD_TYPE_DATA) {
                test_entry_data(mmdb, &node.left_record_entry, node_number,
                                "left");
            }

            cmp_ok(node.right_record, "==", tests[i][3],
                   "right record for node %i is %i - %i bit DB",
                   node_number, tests[i][3], record_size);
            cmp_ok(node.right_record_type, "==", tests[i][4],
                   "right record type for node %i is %i", node_number,
                   tests[i][4]);

            if (node.right_record_type == MMDB_RECORD_TYPE_DATA) {
                test_entry_data(mmdb, &node.right_record_entry, node_number,
                                "right");
            }
        } else {
            diag("call to MMDB_read_node for node %i failed - %i bit DB",
                 node_number,
                 record_size);
        }
    }
}

void run_24_bit_record_tests(int mode, const char *mode_desc)
{
    const char *filename = "MaxMind-DB-test-mixed-24.mmdb";
    const char *path = test_database_path(filename);
    MMDB_s *mmdb = open_ok(path, mode, mode_desc);
    free((void *)path);

    const uint32_t tests[7][5] = {
        { 0,   1,   MMDB_RECORD_TYPE_SEARCH_NODE, 242,
          MMDB_RECORD_TYPE_EMPTY },
        { 80,  81,  MMDB_RECORD_TYPE_SEARCH_NODE, 197,
          MMDB_RECORD_TYPE_SEARCH_NODE, },
        { 96,  97,  MMDB_RECORD_TYPE_SEARCH_NODE, 242,
          MMDB_RECORD_TYPE_EMPTY, },
        { 103, 242, MMDB_RECORD_TYPE_EMPTY,       104,
          MMDB_RECORD_TYPE_SEARCH_NODE, },
        { 127, 242, MMDB_RECORD_TYPE_EMPTY,       315,
          MMDB_RECORD_TYPE_DATA, },
        { 132, 329, MMDB_RECORD_TYPE_DATA,        242,
          MMDB_RECORD_TYPE_EMPTY, },
        { 241, 96,  MMDB_RECORD_TYPE_SEARCH_NODE, 242,
          MMDB_RECORD_TYPE_EMPTY, }
    };
    run_read_node_tests(mmdb, tests, 7, 24);

    MMDB_close(mmdb);
    free(mmdb);
}

void run_28_bit_record_tests(int mode, const char *mode_desc)
{
    const char *filename = "MaxMind-DB-test-mixed-28.mmdb";
    const char *path = test_database_path(filename);
    MMDB_s *mmdb = open_ok(path, mode, mode_desc);
    free((void *)path);

    const uint32_t tests[7][5] = {
        { 0,   1,   MMDB_RECORD_TYPE_SEARCH_NODE, 242,
          MMDB_RECORD_TYPE_EMPTY },
        { 80,  81,  MMDB_RECORD_TYPE_SEARCH_NODE, 197,
          MMDB_RECORD_TYPE_SEARCH_NODE, },
        { 96,  97,  MMDB_RECORD_TYPE_SEARCH_NODE, 242,
          MMDB_RECORD_TYPE_EMPTY, },
        { 103, 242, MMDB_RECORD_TYPE_EMPTY,       104,
          MMDB_RECORD_TYPE_SEARCH_NODE, },
        { 127, 242, MMDB_RECORD_TYPE_EMPTY,       315,
          MMDB_RECORD_TYPE_DATA, },
        { 132, 329, MMDB_RECORD_TYPE_DATA,        242,
          MMDB_RECORD_TYPE_EMPTY, },
        { 241, 96,  MMDB_RECORD_TYPE_SEARCH_NODE, 242,
          MMDB_RECORD_TYPE_EMPTY, }
    };
    run_read_node_tests(mmdb, tests, 7, 28);

    MMDB_close(mmdb);
    free(mmdb);
}

void run_32_bit_record_tests(int mode, const char *mode_desc)
{
    const char *filename = "MaxMind-DB-test-mixed-32.mmdb";
    const char *path = test_database_path(filename);
    MMDB_s *mmdb = open_ok(path, mode, mode_desc);
    free((void *)path);

    const uint32_t tests[7][5] = {
        { 0,   1,   MMDB_RECORD_TYPE_SEARCH_NODE, 242,
          MMDB_RECORD_TYPE_EMPTY },
        { 80,  81,  MMDB_RECORD_TYPE_SEARCH_NODE, 197,
          MMDB_RECORD_TYPE_SEARCH_NODE, },
        { 96,  97,  MMDB_RECORD_TYPE_SEARCH_NODE, 242,
          MMDB_RECORD_TYPE_EMPTY, },
        { 103, 242, MMDB_RECORD_TYPE_EMPTY,       104,
          MMDB_RECORD_TYPE_SEARCH_NODE, },
        { 127, 242, MMDB_RECORD_TYPE_EMPTY,       315,
          MMDB_RECORD_TYPE_DATA, },
        { 132, 329, MMDB_RECORD_TYPE_DATA,        242,
          MMDB_RECORD_TYPE_EMPTY, },
        { 241, 96,  MMDB_RECORD_TYPE_SEARCH_NODE, 242,
          MMDB_RECORD_TYPE_EMPTY, }
    };

    run_read_node_tests(mmdb, tests, 7, 32);

    MMDB_close(mmdb);
    free(mmdb);
}

void run_tests(int mode, const char *mode_desc)
{
    run_24_bit_record_tests(mode, mode_desc);
    run_28_bit_record_tests(mode, mode_desc);
    run_32_bit_record_tests(mode, mode_desc);
}

int main(void)
{
    plan(NO_PLAN);
    for_all_modes(&run_tests);
    done_testing();
}