#include "prof_cmocka.h"
#include <stdlib.h>

#include "xmpp/jid.h"

void
jid_create__returns__null_from_null(void** state)
{
    Jid* result = jid_create(NULL);
    assert_null(result);
}

void
jid_create__returns__null_from_empty_string(void** state)
{
    Jid* result = jid_create("");
    assert_null(result);
}

void
jid_create__returns__full_from_full(void** state)
{
    Jid* result = jid_create("myuser@mydomain/laptop");
    assert_string_equal("myuser@mydomain/laptop", result->fulljid);
    jid_destroy(result);
}

void
jid_create__returns__bare_from_full(void** state)
{
    Jid* result = jid_create("myuser@mydomain/laptop");
    assert_string_equal("myuser@mydomain", result->barejid);
    jid_destroy(result);
}

void
jid_create__returns__resourcepart_from_full(void** state)
{
    Jid* result = jid_create("myuser@mydomain/laptop");
    assert_string_equal("laptop", result->resourcepart);
    jid_destroy(result);
}

void
jid_create__returns__localpart_from_full(void** state)
{
    Jid* result = jid_create("myuser@mydomain/laptop");
    assert_string_equal("myuser", result->localpart);
    jid_destroy(result);
}

void
jid_create__returns__domainpart_from_full(void** state)
{
    Jid* result = jid_create("myuser@mydomain/laptop");
    assert_string_equal("mydomain", result->domainpart);
    jid_destroy(result);
}

void
jid_create__returns__full_from_full_nolocal(void** state)
{
    Jid* result = jid_create("mydomain/laptop");
    assert_string_equal("mydomain/laptop", result->fulljid);
    jid_destroy(result);
}

void
jid_create__returns__bare_from_full_nolocal(void** state)
{
    Jid* result = jid_create("mydomain/laptop");
    assert_string_equal("mydomain", result->barejid);
    jid_destroy(result);
}

void
jid_create__returns__resourcepart_from_full_nolocal(void** state)
{
    Jid* result = jid_create("mydomain/laptop");
    assert_string_equal("laptop", result->resourcepart);
    jid_destroy(result);
}

void
jid_create__returns__domainpart_from_full_nolocal(void** state)
{
    Jid* result = jid_create("mydomain/laptop");
    assert_string_equal("mydomain", result->domainpart);
    jid_destroy(result);
}

void
jid_create__returns__null_localpart_from_full_nolocal(void** state)
{
    Jid* result = jid_create("mydomain/laptop");
    assert_null(result->localpart);
    jid_destroy(result);
}

void
jid_create__returns__null_full_from_bare(void** state)
{
    Jid* result = jid_create("myuser@mydomain");
    assert_null(result->fulljid);
    jid_destroy(result);
}

void
jid_create__returns__null_resource_from_bare(void** state)
{
    Jid* result = jid_create("myuser@mydomain");
    assert_null(result->resourcepart);
    jid_destroy(result);
}

void
jid_create__returns__bare_from_bare(void** state)
{
    Jid* result = jid_create("myuser@mydomain");
    assert_string_equal("myuser@mydomain", result->barejid);
    jid_destroy(result);
}

void
jid_create__returns__localpart_from_bare(void** state)
{
    Jid* result = jid_create("myuser@mydomain");
    assert_string_equal("myuser", result->localpart);
    jid_destroy(result);
}

void
jid_create__returns__domainpart_from_bare(void** state)
{
    Jid* result = jid_create("myuser@mydomain");
    assert_string_equal("mydomain", result->domainpart);
    jid_destroy(result);
}

void
jid_create_from_bare_and_resource__returns__room(void** state)
{
    Jid* result = jid_create_from_bare_and_resource("room@conference.domain.org", "myname");

    assert_string_equal("room@conference.domain.org", result->barejid);
    jid_destroy(result);
}

void
jid_create_from_bare_and_resource__returns__nick(void** state)
{
    Jid* result = jid_create_from_bare_and_resource("room@conference.domain.org", "myname");

    assert_string_equal("myname", result->resourcepart);
    jid_destroy(result);
}

void
jid_create__returns__correct_parts_with_slash_in_resource(void** state)
{
    Jid* result = jid_create("room@conference.domain.org/my/nick");

    assert_string_equal("room", result->localpart);
    assert_string_equal("conference.domain.org", result->domainpart);
    assert_string_equal("my/nick", result->resourcepart);
    assert_string_equal("room@conference.domain.org", result->barejid);
    assert_string_equal("room@conference.domain.org/my/nick", result->fulljid);

    jid_destroy(result);
}

void
jid_create__returns__correct_parts_with_at_in_resource(void** state)
{
    Jid* result = jid_create("room@conference.domain.org/my@nick");

    assert_string_equal("room", result->localpart);
    assert_string_equal("conference.domain.org", result->domainpart);
    assert_string_equal("my@nick", result->resourcepart);
    assert_string_equal("room@conference.domain.org", result->barejid);
    assert_string_equal("room@conference.domain.org/my@nick", result->fulljid);

    jid_destroy(result);
}

void
jid_create__returns__correct_parts_with_at_and_slash_in_resource(void** state)
{
    Jid* result = jid_create("room@conference.domain.org/my@nick/something");

    assert_string_equal("room", result->localpart);
    assert_string_equal("conference.domain.org", result->domainpart);
    assert_string_equal("my@nick/something", result->resourcepart);
    assert_string_equal("room@conference.domain.org", result->barejid);
    assert_string_equal("room@conference.domain.org/my@nick/something", result->fulljid);

    jid_destroy(result);
}

void
jid_create__returns__correct_parts_with_trailing_slash(void** state)
{
    Jid* result = jid_create("room@conference.domain.org/nick/");

    assert_string_equal("room", result->localpart);
    assert_string_equal("conference.domain.org", result->domainpart);
    assert_string_equal("nick/", result->resourcepart);
    assert_string_equal("room@conference.domain.org", result->barejid);
    assert_string_equal("room@conference.domain.org/nick/", result->fulljid);

    jid_destroy(result);
}

void
jid_fulljid_or_barejid__returns__fulljid_when_exists(void** state)
{
    Jid* jid = jid_create("localpart@domainpart/resourcepart");

    const gchar* result = jid_fulljid_or_barejid(jid);

    assert_string_equal("localpart@domainpart/resourcepart", result);

    jid_destroy(jid);
}

void
jid_fulljid_or_barejid__returns__barejid_when_fulljid_not_exists(void** state)
{
    Jid* jid = jid_create("localpart@domainpart");

    const gchar* result = jid_fulljid_or_barejid(jid);

    assert_string_equal("localpart@domainpart", result);

    jid_destroy(jid);
}

void
jid_create__returns__bare_from_trailing_slash(void** state)
{
    Jid* result = jid_create("myuser@mydomain/");
    assert_non_null(result);
    assert_string_equal("myuser@mydomain", result->barejid);
    assert_null(result->resourcepart);
    jid_destroy(result);
}

void
jid_create__returns__null_from_invalid_localpart_chars(void** state)
{
    // Space
    Jid* result = jid_create("user name@domain.com");
    assert_null(result);

    // Double quote
    result = jid_create("user\"name@domain.com");
    assert_null(result);

    // Ampersand
    result = jid_create("user&name@domain.com");
    assert_null(result);

    // Single quote
    result = jid_create("user'name@domain.com");
    assert_null(result);

    // Colon
    result = jid_create("user:name@domain.com");
    assert_null(result);

    // Less than
    result = jid_create("user<name@domain.com");
    assert_null(result);

    // Greater than
    result = jid_create("user>name@domain.com");
    assert_null(result);
}

void
jid_create__returns__null_from_empty_parts(void** state)
{
    // Empty local
    Jid* result = jid_create("@domain.com");
    assert_null(result);

    // Empty domain (trailing @)
    result = jid_create("user@");
    assert_null(result);

    // Empty domain in full jid
    result = jid_create("user@/resource");
    assert_null(result);
}

void
jid_create__returns__null_from_multiple_at_in_bare(void** state)
{
    Jid* result = jid_create("user@domain@other.com");
    assert_null(result);
}

void
jid_create__returns__correct_parts_with_at_in_resource_only(void** state)
{
    // domain.com/user@host (no localpart)
    Jid* result = jid_create("domain.com/user@host");
    assert_non_null(result);
    assert_null(result->localpart);
    assert_string_equal("domain.com", result->domainpart);
    assert_string_equal("user@host", result->resourcepart);
    jid_destroy(result);
}

void
jid_is_valid_user_jid__is__true_for_valid_user_jid(void** state)
{
    assert_true(jid_is_valid_user_jid("myuser@mydomain/laptop"));
    assert_true(jid_is_valid_user_jid("myuser@mydomain"));
}

void
jid_is_valid_user_jid__is__true_for_at_in_resource(void** state)
{
    // RFC 6122 section 2.4: '@' is allowed in the resourcepart.
    assert_true(jid_is_valid_user_jid("myuser@mydomain/user@laptop"));
    assert_true(jid_is_valid_user_jid("room@conference.example.org/user@host.example.org"));
}

void
jid_is_valid_user_jid__is__false_for_domain_jid(void** state)
{
    assert_false(jid_is_valid_user_jid("mydomain/laptop"));
    assert_false(jid_is_valid_user_jid("mydomain"));
}

void
jid_is_valid_user_jid__is__false_for_invalid_jid(void** state)
{
    assert_false(jid_is_valid_user_jid("@mydomain"));
    assert_false(jid_is_valid_user_jid("/laptop"));
    assert_false(jid_is_valid_user_jid(NULL));
    assert_false(jid_is_valid_user_jid(""));
}

void
jid_is_valid__is__true_for_valid_jid(void** state)
{
    assert_true(jid_is_valid("myuser@mydomain/laptop"));
    assert_true(jid_is_valid("myuser@mydomain"));
    assert_true(jid_is_valid("mydomain/laptop"));
    assert_true(jid_is_valid("mydomain"));
}

void
jid_is_valid__is__false_for_invalid_jid(void** state)
{
    assert_false(jid_is_valid("@mydomain"));
    assert_false(jid_is_valid("/laptop"));
}

void
jid_is_valid__is__false_for_null(void** state)
{
    assert_false(jid_is_valid(NULL));
}

void
jid_is_valid__is__false_for_empty_string(void** state)
{
    assert_false(jid_is_valid(""));
}

/* RFC 6122 size limits: 1023 bytes per part, 3071 for the full JID */
void
jid_is_valid__boundary__localpart_length(void** state)
{
    gchar* local_ok = g_strnfill(1023, 'a');
    gchar* jid_ok = g_strdup_printf("%s@domain", local_ok);
    assert_true(jid_is_valid(jid_ok));

    gchar* local_over = g_strnfill(1024, 'a');
    gchar* jid_over = g_strdup_printf("%s@domain", local_over);
    assert_false(jid_is_valid(jid_over));

    g_free(local_ok);
    g_free(jid_ok);
    g_free(local_over);
    g_free(jid_over);
}

void
jid_is_valid__boundary__domainpart_length(void** state)
{
    gchar* domain_ok = g_strnfill(1023, 'd');
    assert_true(jid_is_valid(domain_ok));

    gchar* domain_over = g_strnfill(1024, 'd');
    assert_false(jid_is_valid(domain_over));

    g_free(domain_ok);
    g_free(domain_over);
}

void
jid_is_valid__boundary__resourcepart_length(void** state)
{
    gchar* res_ok = g_strnfill(1023, 'r');
    gchar* jid_ok = g_strdup_printf("user@domain/%s", res_ok);
    assert_true(jid_is_valid(jid_ok));

    gchar* res_over = g_strnfill(1024, 'r');
    gchar* jid_over = g_strdup_printf("user@domain/%s", res_over);
    assert_false(jid_is_valid(jid_over));

    g_free(res_ok);
    g_free(jid_ok);
    g_free(res_over);
    g_free(jid_over);
}

void
jid_is_valid__boundary__total_length(void** state)
{
    // 1023 + '@' + 1023 + '/' + 1023 = 3071, the largest legal JID
    gchar* local = g_strnfill(1023, 'a');
    gchar* domain = g_strnfill(1023, 'd');
    gchar* res = g_strnfill(1023, 'r');
    gchar* jid_max = g_strdup_printf("%s@%s/%s", local, domain, res);
    assert_true(jid_is_valid(jid_max));

    g_free(local);
    g_free(domain);
    g_free(res);
    g_free(jid_max);
}

void
jid_is_valid__is__false_for_invalid_utf8(void** state)
{
    assert_false(jid_is_valid("user\xff\xfe@domain"));
    assert_false(jid_is_valid("us\xc3@domain")); // truncated multi-byte sequence
    assert_false(jid_is_valid("user@domain/res\x80")); // stray continuation byte
}