#include "tests/ArrayStringTests.h"

#include "data/HashMap.h"
#include "test/Test.h"
#include "utils/ArrayString.h"

using String = Core::ArrayString<128>;

static String build(const char* cs) {
    String s;
    CORE_TEST_FALSE(s.append(cs));
    return s;
}

static void testEquality() {
    String s = build("test");
    CORE_TEST_TRUE(s == "test");
    CORE_TEST_TRUE(s == build("test"));
    CORE_TEST_TRUE("test" == s);
    CORE_TEST_TRUE(build("test") == s);
    CORE_TEST_TRUE(s == s);
}

static void testUnicodeEquality() {
    const char* cs = "\u0040\u0400\u8000\U00100000";
    String s = build(cs);
    CORE_TEST_TRUE(s == cs);
    CORE_TEST_TRUE(s == build(cs));
    CORE_TEST_TRUE(cs == s);
    CORE_TEST_TRUE(build(cs) == s);
    CORE_TEST_TRUE(s == s);
}

static void testInequality() {
    String s = build("test");
    CORE_TEST_FALSE(s != "test");
    CORE_TEST_FALSE(s != build("test"));
    CORE_TEST_FALSE("test" != s);
    CORE_TEST_FALSE(build("test") != s);
    CORE_TEST_FALSE(s != s);
}

static void testStringAppend() {
    String s = build("test");
    CORE_TEST_FALSE(s.append("22"));
    CORE_TEST_FALSE(s.append("333"));
    CORE_TEST_FALSE(s.append("4444"));
    CORE_TEST_EQUAL(build("test223334444"), s);
}

static void testStringAppendOverflow() {
    Core::ArrayString<20> s;
    CORE_TEST_FALSE(s.append("te"));
    CORE_TEST_TRUE(s.append("23334444"));
    CORE_TEST_TRUE(build("te23334444") != s);
}

static void testCharacters() {
    String s = build("test");
    CORE_TEST_EQUAL('t', s[0]);
    CORE_TEST_EQUAL('e', s[1]);
    CORE_TEST_EQUAL('s', s[2]);
    CORE_TEST_EQUAL('t', s[3]);
}

static void testLength() {
    String s = build("test");
    CORE_TEST_EQUAL(4, s.getLength());
    CORE_TEST_FALSE(s.append("aaa"));
    CORE_TEST_EQUAL(7, s.getLength());
}

static void testChar() {
    String s = build("test");
    for(char i = 'a'; i < 'd'; i++) {
        CORE_TEST_FALSE(s.append(i));
    }
    CORE_TEST_EQUAL(build("testabc"), s);
}

static void testSignedChar() {
    String s = build("test");
    for(signed char i = 'b'; i < 'e'; i++) {
        CORE_TEST_FALSE(s.append(i));
    }
    CORE_TEST_EQUAL(build("testbcd"), s);
}

static void testUnsignedChar() {
    String s = build("test");
    for(unsigned char i = 'c'; i < 'f'; i++) {
        CORE_TEST_FALSE(s.append(i));
    }
    CORE_TEST_EQUAL(build("testcde"), s);
}

static void testSignedShort() {
    String s = build("test");
    for(signed short i = 100; i < 103; i++) {
        CORE_TEST_FALSE(s.append(i));
    }
    CORE_TEST_EQUAL(build("test100101102"), s);
}

static void testUnsignedShort() {
    String s = build("test");
    for(unsigned short i = 101; i < 104; i++) {
        CORE_TEST_FALSE(s.append(i));
    }
    CORE_TEST_EQUAL(build("test101102103"), s);
}

static void testSignedInt() {
    String s = build("test");
    for(signed int i = 102; i < 105; i++) {
        CORE_TEST_FALSE(s.append(i));
    }
    CORE_TEST_EQUAL(build("test102103104"), s);
}

static void testUnsignedInt() {
    String s = build("test");
    for(unsigned int i = 103; i < 106; i++) {
        CORE_TEST_FALSE(s.append(i));
    }
    CORE_TEST_EQUAL(build("test103104105"), s);
}

static void testSignedLong() {
    String s = build("test");
    for(signed long i = 104; i < 107; i++) {
        CORE_TEST_FALSE(s.append(i));
    }
    CORE_TEST_EQUAL(build("test104105106"), s);
}

static void testUnsignedLong() {
    String s = build("test");
    for(unsigned long i = 105; i < 108; i++) {
        CORE_TEST_FALSE(s.append(i));
    }
    CORE_TEST_EQUAL(build("test105106107"), s);
}

static void testSignedLongLong() {
    String s = build("test");
    for(signed long long i = 106; i < 109; i++) {
        CORE_TEST_FALSE(s.append(i));
    }
    CORE_TEST_EQUAL(build("test106107108"), s);
}

static void testUnsignedLongLong() {
    String s = build("test");
    for(unsigned long long i = 107; i < 110; i++) {
        CORE_TEST_FALSE(s.append(i));
    }
    CORE_TEST_EQUAL(build("test107108109"), s);
}

static void testFloat() {
    String s = build("test");
    for(float i = 108; i < 111; i++) {
        CORE_TEST_FALSE(s.append(i));
    }
    CORE_TEST_EQUAL(build("test108.00109.00110.00"), s);
}

static void testDouble() {
    String s = build("test");
    for(double i = 109; i < 112; i++) {
        CORE_TEST_FALSE(s.append(i));
    }
    CORE_TEST_EQUAL(build("test109.00110.00111.00"), s);
}

static void testLongDouble() {
    String s = build("test");
    for(long double i = 110; i < 113; i++) {
        CORE_TEST_FALSE(s.append(i));
    }
    CORE_TEST_EQUAL(build("test110.00111.00112.00"), s);
}

static void testBool() {
    String s = build("test");
    CORE_TEST_FALSE(s.append(true));
    CORE_TEST_FALSE(s.append(false));
    CORE_TEST_FALSE(s.append(true));
    CORE_TEST_EQUAL(build("testtruefalsetrue"), s);
}

static void testIntOverflow() {
    Core::ArrayString<20> s;
    CORE_TEST_TRUE(s.append(123456));

    String o;
    for(int i = 0; i < s.getCapacity(); i++) {
        CORE_TEST_FALSE(o.append(i + 1));
    }

    CORE_TEST_TRUE(o == s);
}

static void testUnicode() {
    String s;
    CORE_TEST_FALSE(s.appendUnicode('\u0040'));
    CORE_TEST_FALSE(s.appendUnicode(L'\u0400'));
    CORE_TEST_FALSE(s.appendUnicode(L'\u8000'));
    CORE_TEST_FALSE(s.appendUnicode(U'\U00100000'));
    CORE_TEST_EQUAL(build("\u0040\u0400\u8000\U00100000"), s);
}

static void testClear() {
    String s = build("test");
    CORE_TEST_FALSE(s.append(1234));
    s.clear();
    CORE_TEST_FALSE(s.append("wusi"));
    CORE_TEST_FALSE(s.append("1234"));
    CORE_TEST_EQUAL(build("wusi1234"), s);
}

static void testHashCode() {
    String s;
    CORE_TEST_FALSE(s.append("a"));
    CORE_TEST_FALSE(s.append("bc"));
    CORE_TEST_FALSE(s.append(20));
    CORE_TEST_FALSE(s.append(25.5f));
    CORE_TEST_FALSE(s.append(true));
    CORE_TEST_EQUAL(build("abc2025.50true").hashCode(), s.hashCode());
    s.clear();
    CORE_TEST_EQUAL(String().hashCode(), s.hashCode());
}

static void testAddSelf() {
    String s;
    CORE_TEST_FALSE(s.append("test1"));
    CORE_TEST_FALSE(s.append(s));
    CORE_TEST_FALSE(s.append(s));
    CORE_TEST_EQUAL(build("test1test1test1test1"), s);
}

static void testAsHashMapKey() {
    Core::HashMap<String, int> map;
    CORE_TEST_NOT_NULL(map.add(build("wusi"), 3));
    CORE_TEST_NOT_NULL(map.add(build("hiThere"), 7));
    CORE_TEST_NOT_NULL(map.add(build("baum123"), 5));

    int* a = map.search(build("wusi"));
    int* b = map.search(build("hiThere"));
    int* c = map.search(build("baum123"));
    int* d = map.search(build("423hifd"));

    CORE_TEST_NOT_NULL(a);
    CORE_TEST_NOT_NULL(b);
    CORE_TEST_NOT_NULL(c);
    CORE_TEST_NULL(d);

    if(a != nullptr && b != nullptr && c != nullptr) {
        CORE_TEST_EQUAL(3, *a);
        CORE_TEST_EQUAL(7, *b);
        CORE_TEST_EQUAL(5, *c);
    }
}

static void testStartsWith() {
    String s;
    CORE_TEST_FALSE(s.append("0123456789"));

    String s2;
    CORE_TEST_FALSE(s2.append("123"));
    String s3;
    CORE_TEST_FALSE(s3.append("234"));
    String s4;
    CORE_TEST_FALSE(s4.append("789"));
    String s5;
    CORE_TEST_FALSE(s5.append("124"));
    String s6;
    String s7;
    CORE_TEST_FALSE(s7.append("7891"));

    CORE_TEST_FALSE(s.startsWidth(s2));
    CORE_TEST_TRUE(s.startsWidth(s2, 1));

    CORE_TEST_FALSE(s.startsWidth(s3));
    CORE_TEST_TRUE(s.startsWidth(s3, 2));

    CORE_TEST_FALSE(s.startsWidth(s4));
    CORE_TEST_TRUE(s.startsWidth(s4, 7));

    CORE_TEST_FALSE(s.startsWidth(s5));
    CORE_TEST_FALSE(s.startsWidth(s5, 3));

    CORE_TEST_TRUE(s.startsWidth(s6));
    CORE_TEST_TRUE(s.startsWidth(s6, 3));

    CORE_TEST_FALSE(s.startsWidth(s7));
    CORE_TEST_FALSE(s.startsWidth(s7, 7));
}

static void testSearch() {
    String s;
    CORE_TEST_FALSE(s.append("0123456789"));

    String s2;
    CORE_TEST_FALSE(s2.append("123"));
    String s3;
    CORE_TEST_FALSE(s3.append("234"));
    String s4;
    CORE_TEST_FALSE(s4.append("789"));
    String s5;
    CORE_TEST_FALSE(s5.append("124"));
    String s6;
    String s7;
    CORE_TEST_FALSE(s7.append("7891"));

    CORE_TEST_EQUAL(1, s.search(s2));
    CORE_TEST_EQUAL(2, s.search(s3));
    CORE_TEST_EQUAL(7, s.search(s4));
    CORE_TEST_EQUAL(-1, s.search(s5));
    CORE_TEST_EQUAL(0, s.search(s6));
    CORE_TEST_EQUAL(-1, s.search(s7));

    CORE_TEST_EQUAL(-1, s.search(s2, 3));
    CORE_TEST_EQUAL(-1, s.search(s3, 3));
    CORE_TEST_EQUAL(7, s.search(s4, 3));
    CORE_TEST_EQUAL(-1, s.search(s5, 3));
    CORE_TEST_EQUAL(3, s.search(s6, 3));
    CORE_TEST_EQUAL(-1, s.search(s7, 3));
}

static void testContains() {
    String s;
    CORE_TEST_FALSE(s.append("0123456789"));

    String s2;
    CORE_TEST_FALSE(s2.append("123"));
    String s3;
    CORE_TEST_FALSE(s3.append("234"));
    String s4;
    CORE_TEST_FALSE(s4.append("789"));
    String s5;
    CORE_TEST_FALSE(s5.append("124"));
    String s6;
    String s7;
    CORE_TEST_FALSE(s7.append("7891"));

    CORE_TEST_TRUE(s.contains(s2));
    CORE_TEST_TRUE(s.contains(s3));
    CORE_TEST_TRUE(s.contains(s4));
    CORE_TEST_FALSE(s.contains(s5));
    CORE_TEST_TRUE(s.contains(s6));
    CORE_TEST_FALSE(s.contains(s7));
}

static void testSearchChar() {
    String s;
    CORE_TEST_FALSE(s.append("01üää3ä"));

    CORE_TEST_EQUAL(0, s.search(U'0'));
    CORE_TEST_EQUAL(1, s.search(U'1'));
    CORE_TEST_EQUAL(2, s.search(U'ü'));
    CORE_TEST_EQUAL(3, s.search(U'ä'));
    CORE_TEST_EQUAL(4, s.search(U'ä', 4));
    CORE_TEST_EQUAL(5, s.search(U'3'));
    CORE_TEST_EQUAL(6, s.search(U'ä', 5));
}

static void testContainsChar() {
    String s;
    CORE_TEST_FALSE(s.append("01üää3ä"));

    CORE_TEST_TRUE(s.contains(U'0'));
    CORE_TEST_TRUE(s.contains(U'1'));
    CORE_TEST_TRUE(s.contains(U'ü'));
    CORE_TEST_TRUE(s.contains(U'ä'));
    CORE_TEST_FALSE(s.contains(U'ö'));
}

static void testSubString() {
    String s;
    CORE_TEST_FALSE(s.append("01üää3ä"));

    CORE_TEST_STRING("01üää3ä", s.substring(-2));
    CORE_TEST_STRING("1üää3ä", s.substring(1));
    CORE_TEST_STRING("üää3ä", s.substring(2));
    CORE_TEST_STRING("ää3ä", s.substring(3));
    CORE_TEST_STRING("ä3ä", s.substring(4));

    CORE_TEST_STRING("01üää3ä", s.substring(0, 6));
    CORE_TEST_STRING("1üää3", s.substring(1, 5));
    CORE_TEST_STRING("üää", s.substring(2, 4));
    CORE_TEST_STRING("ä", s.substring(3, 3));
    CORE_TEST_STRING("", s.substring(4, 2));
    CORE_TEST_STRING("ä3ä", s.substring(4, 23));
}

static void testReplace() {
    String s;
    CORE_TEST_FALSE(s.append("0äääää1üää3ä"));

    String search;
    CORE_TEST_FALSE(search.append("ää"));

    String replace;
    CORE_TEST_FALSE(replace.append("ABCD"));

    CORE_TEST_FALSE(s.replace(search, replace));

    CORE_TEST_STRING("0ABCDABCDä1üABCD3ä", s);

    String s2;
    CORE_TEST_FALSE(s2.append("0ABCDABCDä1üABCD3ä"));
    CORE_TEST_EQUAL(s2.hashCode(), s.hashCode());
}

static void testReplaceChar() {
    String s;
    CORE_TEST_FALSE(s.append("01üää3ä"));
    s.replace(U'0', U'A');
    CORE_TEST_STRING("A1üää3ä", s);
    s.replace(U'1', U'B');
    CORE_TEST_STRING("ABüää3ä", s);
    s.replace(U'ü', U'C');
    CORE_TEST_STRING("ABCää3ä", s);
    s.replace(U'ä', U'D');
    CORE_TEST_STRING("ABCDD3D", s);
    s.replace(U'3', U'E');
    CORE_TEST_STRING("ABCDDED", s);

    String s2;
    CORE_TEST_FALSE(s2.append("ABCDDED"));
    CORE_TEST_EQUAL(s2.hashCode(), s.hashCode());
}

void Core::ArrayStringTests::test() {
    testEquality();
    testUnicodeEquality();
    testInequality();
    testStringAppend();
    testStringAppendOverflow();
    testCharacters();
    testLength();
    testChar();
    testSignedChar();
    testUnsignedChar();
    testSignedShort();
    testUnsignedShort();
    testSignedInt();
    testUnsignedInt();
    testSignedLong();
    testUnsignedLong();
    testSignedLongLong();
    testUnsignedLongLong();
    testFloat();
    testDouble();
    testLongDouble();
    testBool();
    testIntOverflow();
    testUnicode();
    testClear();
    testHashCode();
    testAddSelf();
    testAsHashMapKey();
    testStartsWith();
    testSearch();
    testContains();
    testSearchChar();
    testContainsChar();
    testSubString();
    testReplace();
    testReplaceChar();
}