#include <al/test.h>
#include <al/str.h>
#include <al/wstr.h>

static bool str_test_cmp(void)
{
    AL_TEST_START("str_cmp");

    str *s0 = al_str_c("testtestasdf");
    str *s1 = al_str_c("testtestasdf");
    str *s2 = al_str_c("testtedfdfstasdf");
    str *s3 = al_str_c("dtesttedfdfstasdf");

    AL_TEST_TRUE(al_str_eq(s0, s1));
    AL_TEST_FALSE(al_str_eq(s0, s2));
    AL_TEST_FALSE(al_str_eq(s0, s3));
    AL_TEST_FALSE(al_str_eq(s2, s3));

    AL_TEST_EQ(al_str_cmp(s0, al_str_c("test"), 0, 4), 0, u32);
    AL_TEST_EQ(al_str_cmp(s0, al_str_c("tt"), 3, 2), 0, u32);
    AL_TEST_GT(al_str_cmp(s0, al_str_c("r"), 6, 1), 0, u32);
    AL_TEST_EQ(al_str_cmp(s0, al_str_c("ee"), 15, 2), -1, u32);

    str *s4 = al_str_c("page");
    str *s5 = al_str_c("page.json");

    AL_TEST_FALSE(al_str_eq(s5, s4));
    AL_TEST_FALSE(al_str_eq(s4, s5));

    AL_TEST_END();
}

static bool str_test_cat(void)
{
    AL_TEST_START("str_cat");

    str *result = al_str_c("testtestasdf");

    str s0;
    al_str_from(&s0, "");

    AL_TEST_EQ(s0.len, 0, u32);

    al_str_cat(&s0, al_str_c("testtestasdf"));

    AL_TEST_TRUE(al_str_eq(result, &s0));

    al_str_free(&s0);

    AL_TEST_END();
}

static bool str_test_insert(void)
{
    AL_TEST_START("str_insert");

    str *insert_result = al_str_c("testtest[insert]asdf");
    str *prepend_result = al_str_c("[prepend]testtestasdf");

    str insert_str;
    str prepend_str;

    al_str_from(&insert_str, "testtestasdf");
    al_str_from(&prepend_str, "testtestasdf");

    al_str_insert(&insert_str, 8, al_str_c("[insert]"));
    al_str_prepend(&prepend_str, al_str_c("[prepend]"));

    AL_TEST_TRUE(al_str_eq(insert_result, &insert_str));
    AL_TEST_TRUE(al_str_eq(prepend_result, &prepend_str));

    al_str_free(&insert_str);
    al_str_free(&prepend_str);

    AL_TEST_END();
}

static bool str_test_find_rfind(void)
{
    AL_TEST_START("str_find_rfind");

    str *s0 = al_str_c("testtes\\ta\\sdf");

    AL_TEST_EQ(al_str_find(s0, '\\'), 7, s32);
    AL_TEST_EQ(al_str_rfind(s0, '\\'), 10, s32);

    AL_TEST_EQ(al_str_find_str(s0, al_str_c("tes\\")), 4, s32);

    AL_TEST_END();
}

static bool str_test_substr(void)
{
    AL_TEST_START("str_substr");

    str *result0 = al_str_c("[cutout0]");
    str *result1 = al_str_c("[cutout1]");

    str s;
    al_str_from(&s, "dfkdljfd[cutout0]dfd[cutout1]fd");

    s32 start = al_str_find(&s, '[');
    s32 end = al_str_find(&s, ']') + 1;

    str *cutout0 = al_str_substr(&s, start, end);
    str *sub = al_str_substr(&s, end, s.len);

    start = al_str_find(sub, '[');
    end = al_str_find(sub, ']') + 1;

    str *cutout1 = al_str_substr(sub, start, end);

    AL_TEST_TRUE(al_str_eq(result0, cutout0));
    AL_TEST_TRUE(al_str_eq(result1, cutout1));

    al_str_free(&s);

    AL_TEST_END();
}

static bool str_test_get_line(void)
{
    AL_TEST_START("str_get_line");

    str *lines0 = al_str_c("test\nasdf\ntest2\na\n ");
    str *lines_array0[] = { al_str_c("test"), al_str_c("asdf"), al_str_c("test2"), al_str_c("a"), al_str_c(" ") };

    str *lines1 = al_str_c("test\nasdf\ntest2\na\n");
    str *lines_array1[] = { al_str_c("test"), al_str_c("asdf"), al_str_c("test2"), al_str_c("a") };

    str *lines;
    str **lines_array;
    u32 lines_array_size;

    for (u32 i = 0; i < 2; i++) {
        if (i == 0) {
            lines = lines0;
            lines_array = lines_array0;
            lines_array_size = (u32)ARRAY_SIZE(lines_array0);
        } else if (i == 1) {
            lines = lines1;
            lines_array = lines_array1;
            lines_array_size = (u32)ARRAY_SIZE(lines_array1);
        }

        str line = al_str_zero();
        u32 c = 0;

        for (; al_str_get_line(lines, '\n', &line); ) {
            AL_TEST_LT(c, lines_array_size, u32);
            AL_TEST_TRUE(al_str_eq(&line, lines_array[c++]));
        }

        AL_TEST_EQ(c, lines_array_size, u32);

        lines = al_str_c("");

        al_memset(&line, 0, sizeof(str));
        c = 0;

        for (; al_str_get_line(lines, '\n', &line); ) {
            AL_TEST_LT(c, 1, u32);
            AL_TEST_EQ(line.len, 0, u32);
            c++;
        }
    }

    AL_TEST_END();
}

static bool str_test_to_long(void)
{
    AL_TEST_START("str_to_long");

    str *s0 = al_str_c("10353");
    str *s1 = al_str_c("-3563");
    str *s2 = al_str_c("-2147483647"); // 1 away
    // This fails on MSVC for some reason.
    str *s2_1 = al_str_c("-2147483648"); // min
    str *s2_2 = al_str_c("-2147483649"); // underflow
    str *s3 = al_str_c("0xfff");
    str *s4 = al_str_c("0b01010");
    str *s5 = al_str_c("01010");
    str *s6 = al_str_c("99999999999999999999");
    str *s7 = al_str_c("    -99999999999999999999");
    str *s8 = al_str_c("---99999999999999999999");
    str *s9 = al_str_c("'p[afd'dfdfs[f");
    str *s10 = al_str_c("\n\t 01010");
    str *s11 = al_str_c("-9223372036854775809");
    str *s12 = al_str_c("6519749124957310923");
    str *s13 = al_str_c("-3519311901742109472");

    AL_TEST_EQ(al_str_to_long(s0, 10), 10353L, s64);
    AL_TEST_EQ(al_str_to_long(s1, 10), -3563L, s64);
    AL_TEST_EQ(al_str_to_long(s2, 10), -2147483647L, s64);
    AL_TEST_EQ(al_str_to_long(s2_1, 10), -2147483648L, s64);
    AL_TEST_EQ(al_str_to_long(s2_2, 10), -2147483649L, s64);
    AL_TEST_EQ(al_str_to_long(s3, 16), 0xfff, s64);
    AL_TEST_EQ(al_str_to_long(s4, 2),  0b01010, s64);
    AL_TEST_EQ(al_str_to_long(s5, 2),  0b01010, s64);
    AL_TEST_EQ(al_str_to_long(s6, 10), INT64_MAX, s64);
    AL_TEST_EQ(al_str_to_long(s7, 10), INT64_MIN, s64);
    AL_TEST_EQ(al_str_to_long(s8, 10), INT64_MIN, s64);
    AL_TEST_EQ(al_str_to_long(s9, 10), INT64_MAX, s64);
    AL_TEST_EQ(al_str_to_long(s10, 2), 0b01010, s64);
    AL_TEST_EQ(al_str_to_long(s11, 10), INT64_MIN, s64);
    AL_TEST_EQ(al_str_to_long(s12, 10), 6519749124957310923L, s64);
    AL_TEST_EQ(al_str_to_long(s13, 10), -3519311901742109472, s64);

    AL_TEST_END();
}

static str *global __attribute__((unused)) = al_str_c("yeeee");

static bool str_test_error_prone_str_c(void)
{
    AL_TEST_START("str_error_prone_str_c");

    str *n = al_str_c("yoyoyoyoyo");
    AL_TEST_EQ(n->len, al_strlen("yoyoyoyoyo"), u32);
    AL_TEST_EQ(n->alloc, 0, u32);
    AL_TEST_EQ(al_memcmp(n->data, "yoyoyoyoyo", al_strlen("yoyoyoyoyo") + 1), 0, u32);

// This is expected to cause a compile error.
#if 0
    char *d = al_malloc(26);
    char *s = "yoyoyoyoyo";
    al_memcpy(d, s, strlen(s) + 1);

    str ds = *al_str_c(d);
    str ss = *al_str_cr(d);
    AL_TEST_EQ(ds.len, (u32)(sizeof(char *) - 1), u32);
    AL_TEST_EQ(ss.len, (u32)al_strlen(s), u32);

    al_free(d);

    wchar_t *wd = al_malloc(sizeof(wchar_t) * 26);
    wchar_t *ws = L"yoyoyoyoyo";
    al_memcpy(wd, ws, (wcslen(ws) * sizeof(wchar_t)) + sizeof(wchar_t));

    wstr wds = *al_wstr_c(wd);
    wstr wss = *al_wstr_cr(wd);
    AL_TEST_EQ(wds.len, (u32)((sizeof(wchar_t *) / sizeof(wchar_t)) - 1), u32);
    AL_TEST_EQ(wss.len, (u32)wcslen(ws), u32);

    al_free(wd);
#endif

    AL_TEST_END();
}

bool str_tests_run(void)
{
    AL_TEST_START_GROUP("str");

    AL_TEST_RUN(str_test_cmp);
    AL_TEST_RUN(str_test_cat);
    AL_TEST_RUN(str_test_insert);
    AL_TEST_RUN(str_test_find_rfind);
    AL_TEST_RUN(str_test_substr);
    AL_TEST_RUN(str_test_get_line);
    AL_TEST_RUN(str_test_to_long);
    AL_TEST_RUN(str_test_error_prone_str_c);

    AL_TEST_END_GROUP();
}