#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include "lib/url.h"

#define FAIL(...) do { printf("FAIL: "); printf(__VA_ARGS__); printf("\n"); return -1; } while (0)

struct url_schema

    basic_http = { 1, { "http" } },

    svn_ssh = { 2, { "svn", "ssh" } },

    schema_unix = { 1, { "unix" } }

    ;

struct url_opts

    opts_single = { 1, { { "key0", "val0" } } },

    opts_multi = { 2, { { "key0", "val0" }, { "key1", "val1" } } },

    opts_nullval = { 1, { { "keyN", NULL } } }

    ;

struct url_test {

    const char *url;

    const struct url expected;

} url_tests[] = {

    {   "localhost:http",   {

        NULL, NULL, NULL, "localhost", "http", NULL, NULL

    } },

    {   "http://example.com/path",  {

        &basic_http, NULL, NULL, "example.com", NULL, "path", NULL 

    } },

    {   "svn+ssh://user:passwd@someplace:someport/something",   {

        &svn_ssh, "user", "passwd", "someplace", "someport", "something"

    } },

    {   "user@:service/",   {

        NULL, "user", NULL, NULL, "service", NULL

    } },

    {   "unix:////tmp/foo.sock",    {

        &schema_unix, NULL, NULL, NULL, NULL, "/tmp/foo.sock"

    } },

    {   "unix:///tmp/foo.sock", {

        &schema_unix, NULL, NULL, NULL, NULL, "tmp/foo.sock"

    } },

    {   "/tmp/foo.sock",    {

        NULL, NULL, NULL, NULL, NULL, "tmp/foo.sock"

    } },

    {   "?key0=val0",   {

        NULL, NULL, NULL, NULL, NULL, NULL, &opts_single

    } },

    {   "http://foo.com/index.php?key0=val0&key1=val1",  {

        &basic_http, NULL, NULL, "foo.com", NULL, "index.php", &opts_multi

    } },

    {   "example.org:81/?keyN", {

        NULL, NULL, NULL, "example.org", "81", NULL, &opts_nullval

    } },

    {   NULL,               {   } },

};

int cmp_url_str (const char *field, const char *test, const char *real) {

    if (!test) {

        if (real)

            FAIL("%s shouldn't be present", field);

    } else if (!real) {

        FAIL("%s is missing", field);

    } else {

        if (strcmp(test, real) != 0)

            FAIL("%s differs: %s -> %s", field, test, real);

    }

    // ok

    return 0;

}

int cmp_url (const struct url *test, const struct url *real) {

    int i;

    // test schema

    if (!test->schema) {

        if (real->schema)

            FAIL("test has no schema, but real does");

    } else if (!real->schema) {

        FAIL("test has a schema, but real doesn't");

    } else {

        if (test->schema->count != test->schema->count)

            FAIL("inconsistent scheme count");

        for (i = 0; i < test->schema->count; i++) {

            if (strcmp(test->schema->list[i], real->schema->list[i]) != 0)

                FAIL("differing scheme #%d", i);

        }

    }

    // test username

    if (cmp_url_str("username", test->username, real->username))

        goto error;

    // test password

    if (cmp_url_str("password", test->password, real->password))

        goto error;

    // test hostname

    if (cmp_url_str("hostname", test->hostname, real->hostname))

        goto error;

    // test service

    if (cmp_url_str("service", test->service, real->service))

        goto error;

    // test path

    if (cmp_url_str("path", test->path, real->path))

        goto error;

    // test query

    if (!test->opts) {

        if (real->opts)

            FAIL("test has no opts, but real does");

    } else if (!real->opts) {

        FAIL("test has opts, but real doesn't");

    } else {

        if (test->opts->count != test->opts->count)

            FAIL("inconsistent opts count");

        for (i = 0; i < test->opts->count; i++) {

            if (cmp_url_str("opt key", test->opts->list[i].key, real->opts->list[i].key))

                FAIL("differing opt key #%d", i);

            if (cmp_url_str("opt value", test->opts->list[i].value, real->opts->list[i].value))

                FAIL("differing opt value #%d", i);

        }

    }

    // ok

    return 0;

error:

    return -1;

}

void usage (const char *exec_name) {

    printf("Usage: %s\n\n\tNo arguments are accepted\n", exec_name);

    exit(EXIT_FAILURE);

}

int main (int argc, char **argv) {

    const struct url_test *test;

    struct url url;

    if (argc > 1)

        usage(argv[0]);

    // run the tests

    for (test = url_tests; test->url; test++) {

        // first output the URL we are handling...

        printf("%-80s - ", test->url);

        fflush(stdout);

        // parse the URL

        memset(&url, 0, sizeof(url));

        if (url_parse(&url, test->url)) {

            printf("FATAL: url_parse failed\n");

            return EXIT_FAILURE;

        }

        // compare it

        if (cmp_url(&test->expected, &url)) {

            printf("\texpected: ");

            url_dump(&test->expected, stdout);

            printf("\tresult:   ");

            url_dump(&url, stdout);

        } else {

            printf("OK\n\t");

            url_dump(&url, stdout);

        }

        printf("\n");

    }

}