/*
 * Copyright 2011 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "include/core/SkScalar.h"
#include "include/core/SkString.h"
#include "include/core/SkTypes.h"
#include "include/private/SkTArray.h"
#include "src/core/SkStringUtils.h"
#include "tests/Test.h"

#include <cmath>
#include <cstdarg>
#include <cstdint>
#include <cstring>
#include <string_view>
#include <thread>

using namespace skia_private;

DEF_TEST(String, reporter) {
    SkString    a;
    SkString    b((size_t)0);
    SkString    c("");
    SkString    d(nullptr, 0);
    SkString    v{std::string_view()};

    REPORTER_ASSERT(reporter, a.isEmpty());
    REPORTER_ASSERT(reporter, a == b && a == c && a == d && a == v);

    a.set("hello");
    b.set("hellox", 5);
    c.set(a);
    d.resize(5);
    memcpy(d.data(), "helloz", 5);
    v.set(std::string_view("hellooooo").substr(0, 5));

    REPORTER_ASSERT(reporter, !a.isEmpty());
    REPORTER_ASSERT(reporter, a.size() == 5);
    REPORTER_ASSERT(reporter, a == b && a == c && a == d && a == v);
    REPORTER_ASSERT(reporter, a.equals("hello", 5));
    REPORTER_ASSERT(reporter, a.equals("hello"));
    REPORTER_ASSERT(reporter, !a.equals("help"));

    REPORTER_ASSERT(reporter,  a.startsWith("hell"));
    REPORTER_ASSERT(reporter,  a.startsWith('h'));
    REPORTER_ASSERT(reporter, !a.startsWith( "ell"));
    REPORTER_ASSERT(reporter, !a.startsWith( 'e'));
    REPORTER_ASSERT(reporter,  a.startsWith(""));
    REPORTER_ASSERT(reporter,  a.endsWith("llo"));
    REPORTER_ASSERT(reporter,  a.endsWith('o'));
    REPORTER_ASSERT(reporter, !a.endsWith("ll" ));
    REPORTER_ASSERT(reporter, !a.endsWith('l'));
    REPORTER_ASSERT(reporter,  a.endsWith(""));
    REPORTER_ASSERT(reporter,  a.contains("he"));
    REPORTER_ASSERT(reporter,  a.contains("ll"));
    REPORTER_ASSERT(reporter,  a.contains("lo"));
    REPORTER_ASSERT(reporter,  a.contains("hello"));
    REPORTER_ASSERT(reporter, !a.contains("hellohello"));
    REPORTER_ASSERT(reporter,  a.contains(""));
    REPORTER_ASSERT(reporter,  a.contains('e'));
    REPORTER_ASSERT(reporter, !a.contains('z'));

    v.prepend(std::string_view("[["));
    v.append(std::string_view("]]"));
    REPORTER_ASSERT(reporter, v.equals("[[hello]]"));

    v.insert(2, std::string_view("?!").substr(0, 1));
    REPORTER_ASSERT(reporter, v.equals("[[?hello]]"));

    SkString    e(a);
    SkString    f("hello");
    SkString    g("helloz", 5);

    REPORTER_ASSERT(reporter, a == e && a == f && a == g);

    b.set("world");
    c = b;
    REPORTER_ASSERT(reporter, a != b && a != c && b == c);

    a.append(" world");
    e.append("worldz", 5);
    e.insert(5, " ");
    f.set("world");
    f.prepend("hello ");
    REPORTER_ASSERT(reporter, a.equals("hello world") && a == e && a == f);

    a.reset();
    b.resize(0);
    REPORTER_ASSERT(reporter, a.isEmpty() && b.isEmpty() && a == b);

    a.set("a");
    a.set("ab");
    a.set("abc");
    a.set("abcd");

    a.set("");
    a.appendS32(0x7FFFFFFFL);
    REPORTER_ASSERT(reporter, a.equals("2147483647"));
    a.set("");
    a.appendS32(0x80000001L);
    REPORTER_ASSERT(reporter, a.equals("-2147483647"));
    a.set("");
    a.appendS32(0x80000000L);
    REPORTER_ASSERT(reporter, a.equals("-2147483648"));

    a.set("");
    a.appendU32(0x7FFFFFFFUL);
    REPORTER_ASSERT(reporter, a.equals("2147483647"));
    a.set("");
    a.appendU32(0x80000001UL);
    REPORTER_ASSERT(reporter, a.equals("2147483649"));
    a.set("");
    a.appendU32(0xFFFFFFFFUL);
    REPORTER_ASSERT(reporter, a.equals("4294967295"));

    a.set("");
    a.appendS64(0x7FFFFFFFFFFFFFFFLL, 0);
    REPORTER_ASSERT(reporter, a.equals("9223372036854775807"));
    a.set("");
    a.appendS64(0x8000000000000001LL, 0);
    REPORTER_ASSERT(reporter, a.equals("-9223372036854775807"));
    a.set("");
    a.appendS64(0x8000000000000000LL, 0);
    REPORTER_ASSERT(reporter, a.equals("-9223372036854775808"));
    a.set("");
    a.appendS64(0x0000000001000000LL, 15);
    REPORTER_ASSERT(reporter, a.equals("000000016777216"));
    a.set("");
    a.appendS64(0xFFFFFFFFFF000000LL, 15);
    REPORTER_ASSERT(reporter, a.equals("-000000016777216"));

    a.set("");
    a.appendU64(0x7FFFFFFFFFFFFFFFULL, 0);
    REPORTER_ASSERT(reporter, a.equals("9223372036854775807"));
    a.set("");
    a.appendU64(0x8000000000000001ULL, 0);
    REPORTER_ASSERT(reporter, a.equals("9223372036854775809"));
    a.set("");
    a.appendU64(0xFFFFFFFFFFFFFFFFULL, 0);
    REPORTER_ASSERT(reporter, a.equals("18446744073709551615"));
    a.set("");
    a.appendU64(0x0000000001000000ULL, 15);
    REPORTER_ASSERT(reporter, a.equals("000000016777216"));

    a.printf("%i", 0);
    REPORTER_ASSERT(reporter, a.equals("0"));
    a.printf("%g", 3.14);
    REPORTER_ASSERT(reporter, a.equals("3.14"));
    a.printf("hello %s", "skia");
    REPORTER_ASSERT(reporter, a.equals("hello skia"));

    static const struct {
        SkScalar    fValue;
        const char* fString;
    } gRec[] = {
        { 0,             "0" },
        { SK_Scalar1,    "1" },
        { -SK_Scalar1,   "-1" },
        { SK_Scalar1/2,  "0.5" },
        { INFINITY,      "inf" },
        { -INFINITY,     "-inf" },
        { NAN,           "nan" },
        { -NAN,          "nan" },
  #if defined(SK_BUILD_FOR_WIN) && (_MSC_VER < 1900)
        { 3.4028234e38f,   "3.4028235e+038" },
        { -3.4028234e38f, "-3.4028235e+038" },
  #else
        { 3.4028234e38f,   "3.4028235e+38" },
        { -3.4028234e38f, "-3.4028235e+38" },
  #endif
    };
    for (size_t i = 0; i < std::size(gRec); i++) {
        a.reset();
        a.appendScalar(gRec[i].fValue);
        REPORTER_ASSERT(reporter, a.size() <= kSkStrAppendScalar_MaxSize);
        if (!a.equals(gRec[i].fString)) {
            ERRORF(reporter, "received <%s> expected <%s>\n", a.c_str(), gRec[i].fString);
        }
    }

    REPORTER_ASSERT(reporter, SkStringPrintf("%i", 0).equals("0"));
}

static void assert_2000_spaces(skiatest::Reporter* reporter, const SkString& str) {
    REPORTER_ASSERT(reporter, str.size() == 2000);
    for (size_t i = 0; i < str.size(); ++i) {
        REPORTER_ASSERT(reporter, str[i] == ' ');
    }
}

DEF_TEST(String_overflow, reporter) {
    // 2000 is larger than the static buffer size inside SkString.cpp
    SkString a = SkStringPrintf("%2000s", " ");
    assert_2000_spaces(reporter, a);

    a = "X";
    a.printf("%2000s", " ");
    assert_2000_spaces(reporter, a);

    a = "X";
    a.appendf("%1999s", " ");
    REPORTER_ASSERT(reporter, a[0] == 'X');
    a[0] = ' ';
    assert_2000_spaces(reporter, a);

    a = "X";
    a.prependf("%1999s", " ");
    REPORTER_ASSERT(reporter, a[1999] == 'X');
    a[1999] = ' ';
    assert_2000_spaces(reporter, a);
}

DEF_TEST(String_SkStrSplit, r) {
    TArray<SkString> results;

    SkStrSplit("a-_b_c-dee--f-_-_-g-", "-_", &results);
    REPORTER_ASSERT(r, results.size() == 6);
    REPORTER_ASSERT(r, results[0].equals("a"));
    REPORTER_ASSERT(r, results[1].equals("b"));
    REPORTER_ASSERT(r, results[2].equals("c"));
    REPORTER_ASSERT(r, results[3].equals("dee"));
    REPORTER_ASSERT(r, results[4].equals("f"));
    REPORTER_ASSERT(r, results[5].equals("g"));

    results.clear();
    SkStrSplit("\n", "\n", &results);
    REPORTER_ASSERT(r, results.size() == 0);

    results.clear();
    SkStrSplit("", "\n", &results);
    REPORTER_ASSERT(r, results.size() == 0);

    results.clear();
    SkStrSplit("a", "\n", &results);
    REPORTER_ASSERT(r, results.size() == 1);
    REPORTER_ASSERT(r, results[0].equals("a"));
}
DEF_TEST(String_SkStrSplit_All, r) {
    TArray<SkString> results;
    SkStrSplit("a-_b_c-dee--f-_-_-g-", "-_", kStrict_SkStrSplitMode, &results);
    REPORTER_ASSERT(r, results.size() == 13);
    REPORTER_ASSERT(r, results[0].equals("a"));
    REPORTER_ASSERT(r, results[1].equals(""));
    REPORTER_ASSERT(r, results[2].equals("b"));
    REPORTER_ASSERT(r, results[3].equals("c"));
    REPORTER_ASSERT(r, results[4].equals("dee"));
    REPORTER_ASSERT(r, results[5].equals(""));
    REPORTER_ASSERT(r, results[6].equals("f"));
    REPORTER_ASSERT(r, results[7].equals(""));
    REPORTER_ASSERT(r, results[8].equals(""));
    REPORTER_ASSERT(r, results[9].equals(""));
    REPORTER_ASSERT(r, results[10].equals(""));
    REPORTER_ASSERT(r, results[11].equals("g"));
    REPORTER_ASSERT(r, results[12].equals(""));

    results.clear();
    SkStrSplit("\n", "\n", kStrict_SkStrSplitMode, &results);
    REPORTER_ASSERT(r, results.size() == 2);
    REPORTER_ASSERT(r, results[0].equals(""));
    REPORTER_ASSERT(r, results[1].equals(""));

    results.clear();
    SkStrSplit("", "\n", kStrict_SkStrSplitMode, &results);
    REPORTER_ASSERT(r, results.size() == 0);

    results.clear();
    SkStrSplit("a", "\n", kStrict_SkStrSplitMode, &results);
    REPORTER_ASSERT(r, results.size() == 1);
    REPORTER_ASSERT(r, results[0].equals("a"));

    results.clear();
    SkStrSplit(",,", ",", kStrict_SkStrSplitMode, &results);
    REPORTER_ASSERT(r, results.size() == 3);
    REPORTER_ASSERT(r, results[0].equals(""));
    REPORTER_ASSERT(r, results[1].equals(""));
    REPORTER_ASSERT(r, results[2].equals(""));

    results.clear();
    SkStrSplit(",a,b,", ",", kStrict_SkStrSplitMode, &results);
    REPORTER_ASSERT(r, results.size() == 4);
    REPORTER_ASSERT(r, results[0].equals(""));
    REPORTER_ASSERT(r, results[1].equals("a"));
    REPORTER_ASSERT(r, results[2].equals("b"));
    REPORTER_ASSERT(r, results[3].equals(""));
}

// https://bugs.chromium.org/p/skia/issues/detail?id=7107
DEF_TEST(String_Threaded, r) {
    SkString str("foo");

    std::thread threads[5];
    for (auto& thread : threads) {
        thread = std::thread([&] {
            SkString copy = str;  // NOLINT(performance-unnecessary-copy-initialization)
            (void)copy.equals("test");
        });
    }
    for (auto& thread : threads) {
        thread.join();
    }
}

// Ensure that the string allocate doesn't internally overflow any calculations, and accidentally
// let us create a string with a requested length longer than we can manage.
DEF_TEST(String_huge, r) {
    // start testing slightly below max 32
    size_t size = UINT32_MAX - 16;
    // See where we crash, and manually check that its at the right point.
    //
    //  To test, change the false to true
    if ((false)) {
        for (;;) {
            // On a 64bit build, this should crash when size == 1 << 32, since we can't store
            // that length in the string's header (which has a u32 slot for the length).
            //
            // On a 32bit build, this should crash the first time around, since we can't allocate
            // anywhere near this amount.
            //
            SkString str(size);
            size += 1;
        }
    }
}

DEF_TEST(String_fromUTF16, r) {
    // test data produced with `iconv`.
    const uint16_t test1[] = {
        0xD835, 0xDCD0, 0xD835, 0xDCD1, 0xD835, 0xDCD2, 0xD835, 0xDCD3, 0xD835, 0xDCD4, 0x0020,
        0xD835, 0xDCD5, 0xD835, 0xDCD6, 0xD835, 0xDCD7, 0xD835, 0xDCD8, 0xD835, 0xDCD9
    };
    REPORTER_ASSERT(r, SkStringFromUTF16(test1, std::size(test1)).equals("𝓐𝓑𝓒𝓓𝓔 𝓕𝓖𝓗𝓘𝓙"));

    const uint16_t test2[] = {
        0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0020, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A,
    };
    REPORTER_ASSERT(r, SkStringFromUTF16(test2, std::size(test2)).equals("ABCDE FGHIJ"));

    const uint16_t test3[] = {
        0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x0020, 0x03B6, 0x03B7, 0x03B8, 0x03B9, 0x03BA,
    };
    REPORTER_ASSERT(r, SkStringFromUTF16(test3, std::size(test3)).equals("αβγδε ζηθικ"));
}

static void test_va_list_print(skiatest::Reporter* r, const char format[], ...)
        SK_PRINTF_LIKE(2, 3);

static void test_va_list_print(skiatest::Reporter* r, const char format[], ...) {
    va_list args;
    va_start(args, format);

    SkString str("123");
    str.printVAList(format, args);
    REPORTER_ASSERT(r, str.equals("hello world"));

    va_end(args);
}

static void test_va_list_append(skiatest::Reporter* r, const char format[], ...)
        SK_PRINTF_LIKE(2, 3);

static void test_va_list_append(skiatest::Reporter* r, const char format[], ...) {
    va_list args;
    va_start(args, format);

    SkString str("123");
    str.appendVAList(format, args);
    REPORTER_ASSERT(r, str.equals("123hello world"));

    va_end(args);
}

static void test_va_list_prepend(skiatest::Reporter* r, const char format[], ...)
        SK_PRINTF_LIKE(2, 3);

static void test_va_list_prepend(skiatest::Reporter* r, const char format[], ...) {
    va_list args;
    va_start(args, format);

    SkString str("123");
    str.prependVAList(format, args);
    REPORTER_ASSERT(r, str.equals("hello world123"));

    va_end(args);
}

DEF_TEST(String_VAList, r) {
    test_va_list_print(r, "%s %c%c%c%c%c", "hello", 'w', 'o', 'r', 'l', 'd');
    test_va_list_append(r, "%s %c%c%c%c%c", "hello", 'w', 'o', 'r', 'l', 'd');
    test_va_list_prepend(r, "%s %c%c%c%c%c", "hello", 'w', 'o', 'r', 'l', 'd');
}

static void test_va_list_overflow_print(skiatest::Reporter* r, const char format[], ...)
        SK_PRINTF_LIKE(2, 3);

static void test_va_list_overflow_print(skiatest::Reporter* r, const char format[], ...) {
    va_list args;
    va_start(args, format);

    SkString str("X");
    str.printVAList(format, args);
    assert_2000_spaces(r, str);

    va_end(args);
}

static void test_va_list_overflow_append(skiatest::Reporter* r, const char format[], ...)
        SK_PRINTF_LIKE(2, 3);

static void test_va_list_overflow_append(skiatest::Reporter* r, const char format[], ...) {
    va_list args;
    va_start(args, format);

    SkString str("X");
    str.appendVAList(format, args);
    REPORTER_ASSERT(r, str[0] == 'X');
    str[0] = ' ';
    assert_2000_spaces(r, str);

    va_end(args);
}

static void test_va_list_overflow_prepend(skiatest::Reporter* r, const char format[], ...)
        SK_PRINTF_LIKE(2, 3);

static void test_va_list_overflow_prepend(skiatest::Reporter* r, const char format[], ...) {
    va_list args;
    va_start(args, format);

    SkString str("X");
    str.prependVAList(format, args);
    REPORTER_ASSERT(r, str[1999] == 'X');
    str[1999] = ' ';
    assert_2000_spaces(r, str);

    va_end(args);
}

DEF_TEST(String_VAList_overflow, r) {
    test_va_list_overflow_print(r, "%2000s", " ");
    test_va_list_overflow_append(r, "%1999s", " ");
    test_va_list_overflow_prepend(r, "%1999s", " ");
}

DEF_TEST(String_resize_to_nothing, r) {
    SkString s("hello world!");
    REPORTER_ASSERT(r, s.equals("hello world!"));
    s.resize(0);
    REPORTER_ASSERT(r, s.equals(""));
}

DEF_TEST(String_resize_shrink, r) {
    SkString s("hello world!");
    REPORTER_ASSERT(r, s.equals("hello world!"));
    s.resize(5);
    REPORTER_ASSERT(r, s.equals("hello"));
}

DEF_TEST(String_resize_grow, r) {
    SkString s("hello world!");
    REPORTER_ASSERT(r, s.equals("hello world!"));
    s.resize(25);
    REPORTER_ASSERT(r, 0 == strcmp(s.c_str(), "hello world!"));  // no promises about data past \0
    REPORTER_ASSERT(r, s.size() == 25);
}

DEF_TEST(String_resize_after_assignment, r) {
    SkString s("hello world!");
    SkString t;
    t = s;
    REPORTER_ASSERT(r, s.equals("hello world!"));
    s.resize(25);
    REPORTER_ASSERT(r, 0 == strcmp(s.c_str(), "hello world!"));
    REPORTER_ASSERT(r, s.size() == 25);
    s.resize(5);
    REPORTER_ASSERT(r, s.equals("hello"));
}

static void resize_helper_function(skiatest::Reporter* r, SkString s) {
    REPORTER_ASSERT(r, s.equals("hello world!"));
    s.resize(5);
    REPORTER_ASSERT(r, s.equals("hello"));
    s.resize(25);
    REPORTER_ASSERT(r, 0 == strcmp(s.c_str(), "hello"));
    REPORTER_ASSERT(r, s.size() == 25);
}

DEF_TEST(String_resize_after_copy_construction, r) {
    SkString s("hello world!");
    resize_helper_function(r, s);
}