#include "test.h"


static int test_iriref()
{
    char *uri1_data = "http://example.org/term#12345";
    char *uri2_data = "ns1:12345";
    char *uri3_data = "ns2:12345";

    VOLK_nsmap_add ("ns1", "http://example.org/term#");
    VOLK_nsmap_add ("ns2", "http://example.org/term#");

    VOLK_Term *uri1 = VOLK_iriref_new (uri1_data);
    ASSERT (uri1, "IRI is NULL!");
    char *pfx = VOLK_iriref_prefix (uri1);
    char *path = VOLK_iriref_path (uri1);
    char *frag = VOLK_iriref_frag (uri1);
    EXPECT_STR_EQ (pfx, "http://example.org");
    EXPECT_STR_EQ (path, "/term#12345");
    EXPECT_STR_EQ (frag, "12345");
    free (pfx);
    free (path);
    free (frag);

    VOLK_Term *uri2 = VOLK_iriref_new_ns (uri2_data);
    ASSERT (uri2, "IRI is NULL!");

    VOLK_Term *uri3 = VOLK_iriref_new_ns (uri3_data);
    ASSERT (uri3, "IRI is NULL!");

    VOLK_Term *uri4 = VOLK_iriref_new (NULL);
    ASSERT (uri4, "IRI is NULL!");

    VOLK_Term *uri5 = VOLK_iriref_new (NULL);
    ASSERT (uri5, "IRI is NULL!");

    EXPECT_INT_EQ (uri1->type, VOLK_TERM_IRIREF);
    EXPECT_INT_EQ (uri2->type, VOLK_TERM_IRIREF);
    EXPECT_INT_EQ (uri3->type, VOLK_TERM_IRIREF);
    EXPECT_INT_EQ (uri4->type, VOLK_TERM_IRIREF);
    EXPECT_INT_EQ (uri5->type, VOLK_TERM_IRIREF);

    ASSERT (VOLK_term_equals (uri1, uri2), "IRIs don't match!");
    ASSERT (VOLK_term_equals (uri2, uri3), "IRIs don't match!");
    ASSERT (!VOLK_term_equals (uri3, uri4), "IRIs shouldn't match!");
    ASSERT (!VOLK_term_equals (uri4, uri5), "IRIs shouldn't match!");

    VOLK_term_free (uri1);
    VOLK_term_free (uri2);
    VOLK_term_free (uri3);
    VOLK_term_free (uri4);
    VOLK_term_free (uri5);

    return 0;
}


static int test_iriref_parts()
{
    char *data[18][4] = {
        {"http://example.org", "http://example.org", "", ""},
        {"http://example.org/", "http://example.org", "/", ""},
        {"http://example.org?option", "http://example.org", "?option", ""},
        {"http://example.org/?option", "http://example.org", "/?option", ""},
        {
                "http://example.org#anchor",
                "http://example.org", "#anchor", "anchor"},
        {
                "http://example.org/#anchor",
                "http://example.org", "/#anchor", "anchor"},
        {
                "http://example.org/?option#anchor",
                "http://example.org", "/?option#anchor", "anchor"},
        {
                "http://example.org?option#anchor",
                "http://example.org", "?option#anchor", "anchor"},
        {
                "http://hanzi.edu/漢魏六朝隋碑誌索引/53?option#anchor",
                "http://hanzi.edu", "/漢魏六朝隋碑誌索引/53?option#anchor",
                "anchor"},
        {"ftp:///", "ftp://", "/", ""},
        {
                "file:///usr/local/lib/libvolksdata.so",
                "file://", "/usr/local/lib/libvolksdata.so", ""},
        {"/", "", "/", ""},
        {"/tmp", "", "/tmp", ""},
        {"./tmp", "", "./tmp", ""},
        {"tmp/test.nt", "", "tmp/test.nt", ""},
        {"", "", "", ""},
        {"#hello", "", "#hello", "hello"},
        {
                "urn:uuid:950404b6-0e4f-4e21-8267-c8c00e83563b",
                "urn:", "uuid:950404b6-0e4f-4e21-8267-c8c00e83563b", ""}
    };

    for (size_t i = 0; i < 18; i++) {
        VOLK_Term *iri = VOLK_iriref_new(data[i][0]);
        char
            *pfx = VOLK_iriref_prefix (iri),
            *path = VOLK_iriref_path (iri),
            *frag = VOLK_iriref_frag (iri);

        EXPECT_STR_EQ (pfx, data[i][1]);
        EXPECT_STR_EQ (path, data[i][2]);
        EXPECT_STR_EQ (frag, data[i][3]);

        free (pfx);
        free (path);
        free (frag);
        VOLK_term_free (iri);
    }

    return 0;
}

static int test_iriref_abs_rel()
{
    EXPECT_PASS (VOLK_nsmap_add ("ns1", "http://example.org/res/"));

    VOLK_Term *root1 = VOLK_iriref_new ("http://example.org/res/");
    VOLK_Term *root2 = VOLK_iriref_new ("urn:id:");

    VOLK_Term *rel_iri1 = VOLK_iriref_new ("http://anotherex.net/res/25");
    VOLK_Term *rel_iri2 = VOLK_iriref_new ("/admin/32");
    VOLK_Term *rel_iri3 = VOLK_iriref_new ("45/678");

    VOLK_Term *abs_iri1 = VOLK_iriref_new_abs (root1, rel_iri1);
    VOLK_Term *abs_iri2 = VOLK_iriref_new_abs (root1, rel_iri2);
    VOLK_Term *abs_iri3 = VOLK_iriref_new_abs (root1, rel_iri3);

    EXPECT_STR_EQ (abs_iri1->data, rel_iri1->data);
    EXPECT_STR_EQ (abs_iri2->data, "http://example.org/admin/32");
    EXPECT_STR_EQ (abs_iri3->data, "http://example.org/res/45/678");

    VOLK_Term *rel_iri1a = VOLK_iriref_new_rel (root1, abs_iri1);
    VOLK_Term *rel_iri2a = VOLK_iriref_new_rel (root1, abs_iri2);
    VOLK_Term *rel_iri3a = VOLK_iriref_new_rel (root1, abs_iri3);

    EXPECT_STR_EQ (rel_iri1a->data, rel_iri1->data);
    EXPECT_STR_EQ (rel_iri2a->data, abs_iri2->data);
    EXPECT_STR_EQ (rel_iri3a->data, "45/678");

    VOLK_term_free (root1);
    VOLK_term_free (root2);
    VOLK_term_free (rel_iri1);
    VOLK_term_free (rel_iri2);
    VOLK_term_free (rel_iri3);
    VOLK_term_free (abs_iri1);
    VOLK_term_free (abs_iri2);
    VOLK_term_free (abs_iri3);
    VOLK_term_free (rel_iri1a);
    VOLK_term_free (rel_iri2a);
    VOLK_term_free (rel_iri3a);

    return 0;
}


static int test_literal()
{
    char *data = "hello";
    char *datatype = "urn:my:datatype";
    char *lang = "en-US";

    VOLK_Term *lit1 = VOLK_literal_new (data, VOLK_iriref_new (datatype));
    EXPECT_INT_EQ (lit1->type, VOLK_TERM_LITERAL);
    EXPECT_STR_EQ (lit1->data, data);
    EXPECT_STR_EQ (lit1->datatype->data, datatype);

    VOLK_Term *lit2 = VOLK_literal_new (data, VOLK_default_datatype);
    EXPECT_INT_EQ (lit2->type, VOLK_TERM_LITERAL);
    EXPECT_STR_EQ (lit2->data, data);
    EXPECT_STR_EQ (lit2->datatype->data, DEFAULT_DTYPE);

    VOLK_Term *lit3 = VOLK_literal_new (data, NULL);
    EXPECT_INT_EQ (lit3->type, VOLK_TERM_LITERAL);
    EXPECT_STR_EQ (lit3->data, data);
    EXPECT_STR_EQ (lit3->datatype->data, DEFAULT_DTYPE);

    ASSERT (lit1->datatype != lit2->datatype, "Wrong data type match!");
    ASSERT (lit2->datatype == lit3->datatype, "Data type mismatch!");

    ASSERT (!VOLK_term_equals (lit1, lit2), "Wrong term match!");
    ASSERT (VOLK_term_equals (lit2, lit3), "Term mismatch!");

    VOLK_Term *lt_lit1 = VOLK_lt_literal_new (data, lang);
    EXPECT_INT_EQ (lt_lit1->type, VOLK_TERM_LT_LITERAL);
    EXPECT_STR_EQ (lt_lit1->data, data);
    EXPECT_STR_EQ (lt_lit1->lang, lang);

    // LT-literal without lang is a normal string literal.
    VOLK_Term *lt_lit2 = VOLK_lt_literal_new (data, NULL);
    EXPECT_INT_EQ (lt_lit2->type, VOLK_TERM_LITERAL);
    EXPECT_STR_EQ (lt_lit2->data, data);

    ASSERT (VOLK_term_equals (lt_lit2, lit2), "Term mismatch!");
    EXPECT_STR_EQ (lt_lit2->datatype->data, DEFAULT_DTYPE);

    VOLK_term_free (lit1);
    VOLK_term_free (lit2);
    VOLK_term_free (lit3);
    VOLK_term_free (lt_lit1);
    VOLK_term_free (lt_lit2);

    return 0;
}

static int test_undefined()
{
    VOLK_Term *undef1 = VOLK_term_new (VOLK_TERM_UNDEFINED, NULL, NULL);
    ASSERT (undef1 != NULL, "Error creating undefined term without data!");

    char *data = "bogus";
    VOLK_Term *undef2 = VOLK_term_new (VOLK_TERM_UNDEFINED, data, NULL);
    ASSERT (undef2 != NULL, "Error creating undefined term with data!");
    EXPECT_STR_EQ (undef2->data, data);

    VOLK_term_free (undef1);
    VOLK_term_free (undef2);

    return 0;
}

static int test_term_copy()
{
    VOLK_Term *uri1 = VOLK_iriref_new ("http://hello.org");
    VOLK_Term *lit1 = VOLK_literal_new ("hello", NULL);
    VOLK_Term *tlit1 = VOLK_literal_new (
            "hello", VOLK_iriref_new ("urn:mydatatype:string"));
    VOLK_Term *llit1 = VOLK_lt_literal_new ("hello", "en-US");

    VOLK_Term *uri2 = VOLK_term_copy (uri1);
    VOLK_Term *lit2 = VOLK_term_copy (lit1);
    VOLK_Term *tlit2 = VOLK_term_copy (tlit1);
    VOLK_Term *llit2 = VOLK_term_copy (llit1);

    ASSERT (VOLK_term_equals (uri1, uri2), "Term mismatch!");
    ASSERT (VOLK_term_equals (lit1, lit2), "Term mismatch!");
    ASSERT (VOLK_term_equals (tlit1, tlit2), "Term mismatch!");
    ASSERT (VOLK_term_equals (llit1, llit2), "Term mismatch!");

    VOLK_term_free (uri1);
    VOLK_term_free (uri2);
    VOLK_term_free (lit1);
    VOLK_term_free (lit2);
    VOLK_term_free (tlit1);
    VOLK_term_free (tlit2);
    VOLK_term_free (llit1);
    VOLK_term_free (llit2);

    return 0;
}

static int test_term_serialize_deserialize()
{
    VOLK_Term *uri = VOLK_iriref_new ("http://hello.org");
    VOLK_Term *lit = VOLK_literal_new ("hello", NULL);
    VOLK_Term *tlit = VOLK_literal_new (
            "hello", VOLK_iriref_new ("urn:mydatatype:string"));
    VOLK_Term *llit = VOLK_lt_literal_new ("hello", "en-US");

    VOLK_Buffer *sterm;
    VOLK_Term *dsterm;

    sterm = VOLK_term_serialize (uri);
    ASSERT (sterm != NULL, "Error serializing term!");
    //log_info ("%s", "Serialized URI: ");
    //VOLK_buffer_print (sterm);
    //log_info ("%s", "\n");
    dsterm = VOLK_term_new_from_buffer (sterm);
    ASSERT (dsterm != NULL, "Error deserializing term!");
    ASSERT (VOLK_term_equals (dsterm, uri), "URI serialization error!");
    VOLK_term_free (uri);
    VOLK_buffer_free (sterm);
    VOLK_term_free (dsterm);

    sterm = VOLK_term_serialize (lit);
    ASSERT (sterm != NULL, "Error serializing term!");
    //log_info ("%s", "Serialized literal: ");
    //VOLK_buffer_print (sterm);
    //log_info ("%s", "\n");
    dsterm = VOLK_term_new_from_buffer (sterm);
    ASSERT (dsterm != NULL, "Error deserializing term!");
    ASSERT (VOLK_term_equals (dsterm, lit), "lit serialization error!");
    VOLK_term_free (lit);
    VOLK_buffer_free (sterm);
    VOLK_term_free (dsterm);

    sterm = VOLK_term_serialize (tlit);
    ASSERT (sterm != NULL, "Error serializing term!");
    //log_info ("%s", "Serialized typed literal: ");
    //VOLK_buffer_print (sterm);
    //log_info ("%s", "\n");
    dsterm = VOLK_term_new_from_buffer (sterm);
    ASSERT (dsterm != NULL, "Error deserializing term!");
    ASSERT (VOLK_term_equals (dsterm, tlit), "tlit serialization error!");
    VOLK_term_free (tlit);
    VOLK_buffer_free (sterm);
    VOLK_term_free (dsterm);

    sterm = VOLK_term_serialize (llit);
    ASSERT (sterm != NULL, "Error serializing term!");
    //log_info ("%s", "Serialized typed and language-tagged URI: ");
    //VOLK_buffer_print (sterm);
    //log_info ("%s", "\n");
    dsterm = VOLK_term_new_from_buffer (sterm);
    ASSERT (dsterm != NULL, "Error deserializing term!");
    ASSERT (VOLK_term_equals (dsterm, llit), "URI serialization error!");
    VOLK_term_free (llit);
    VOLK_buffer_free (sterm);
    VOLK_term_free (dsterm);

    return 0;
}


static int test_term_to_key()
{
    VOLK_nsmap_add ("ns1", "http://hello.org/term#");

    VOLK_Term *uri1 = VOLK_iriref_new ("http://hello.org/term#bye");
    VOLK_Term *uri2 = VOLK_iriref_new_ns ("ns1:bye");
    VOLK_Term *lit = VOLK_literal_new ("hello", NULL);
    VOLK_Term *tlit = VOLK_literal_new ("hello", VOLK_default_datatype);
    VOLK_Term *llit1 = VOLK_lt_literal_new ("hello", "en-US");
    VOLK_Term *llit2 = VOLK_lt_literal_new ("hello", "en-GB");
    VOLK_Term *llit3 = VOLK_lt_literal_new ("hello", NULL);

    VOLK_Key uri1_key = VOLK_term_hash (uri1);
    VOLK_Key uri2_key = VOLK_term_hash (uri2);
    VOLK_Key lit_key = VOLK_term_hash (lit);
    VOLK_Key tlit_key = VOLK_term_hash (tlit);
    VOLK_Key llit1_key = VOLK_term_hash (llit1);
    VOLK_Key llit2_key = VOLK_term_hash (llit2);
    VOLK_Key llit3_key = VOLK_term_hash (llit3);

    ASSERT (uri1_key == uri2_key, "URI keys differ!");
    ASSERT (uri1_key != lit_key, "URI key conflict!");
    ASSERT (lit_key == tlit_key, "URI keys differ!");
    ASSERT (lit_key != llit1_key, "URI key conflict!");
    ASSERT (tlit_key != llit1_key, "URI key conflict!");
    ASSERT (llit1_key != llit2_key, "URI key conflict!");
    ASSERT (tlit_key == llit3_key, "URI keys differ!");

    VOLK_term_free (uri1);
    VOLK_term_free (uri2);
    VOLK_term_free (lit);
    VOLK_term_free (tlit);
    VOLK_term_free (llit1);
    VOLK_term_free (llit2);
    VOLK_term_free (llit3);

    return 0;
}


int term_tests() {
    RUN (test_iriref);
    RUN (test_iriref_parts);
    RUN (test_iriref_abs_rel);
    RUN (test_literal);
    RUN (test_undefined);
    RUN (test_term_copy);
    RUN (test_term_serialize_deserialize);
    RUN (test_term_to_key);

    return 0;
}