/*
 *  Copyright (c) 2018, The OpenThread Authors.
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. Neither the name of the copyright holder nor the
 *     names of its contributors may be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 */

#include "test_platform.h"

#include <openthread/config.h>

#include "test_util.h"
#include "common/code_utils.hpp"
#include "common/string.hpp"

namespace ot {

enum
{
    kStringSize = 10,
};

template <uint16_t kSize> void PrintString(const char *aName, const String<kSize> aString)
{
    printf("\t%s = [%zu] \"%s\"\n", aName, strlen(aString.AsCString()), aString.AsCString());
}

void TestStringWriter(void)
{
    String<kStringSize> str;
    const char          kLongString[] = "abcdefghijklmnopqratuvwxyzabcdefghijklmnopqratuvwxyz";

    printf("\nTest 1: StringWriter constructor\n");

    VerifyOrQuit(str.GetSize() == kStringSize);
    VerifyOrQuit(str.GetLength() == 0, "failed for empty string");

    VerifyOrQuit(strcmp(str.AsCString(), "") == 0);

    PrintString("str", str);

    printf(" -- PASS\n");

    printf("\nTest 2: StringWriter::Append() method\n");

    str.Append("Hi");
    VerifyOrQuit(str.GetLength() == 2);
    VerifyOrQuit(strcmp(str.AsCString(), "Hi") == 0);
    PrintString("str", str);

    str.Append("%s%d", "!", 12);
    VerifyOrQuit(str.GetLength() == 5);
    VerifyOrQuit(strcmp(str.AsCString(), "Hi!12") == 0);
    PrintString("str", str);

    str.Append(kLongString);
    VerifyOrQuit(str.IsTruncated() && str.GetLength() == 5 + sizeof(kLongString) - 1,
                 "String::Append() did not handle overflow buffer correctly");
    PrintString("str", str);

    printf("\nTest 3: StringWriter::Clear() method\n");

    str.Clear();
    str.Append("Hello");
    VerifyOrQuit(str.GetLength() == 5);
    VerifyOrQuit(strcmp(str.AsCString(), "Hello") == 0);
    PrintString("str", str);

    str.Clear();
    VerifyOrQuit(str.GetLength() == 0, "failed after Clear()");
    VerifyOrQuit(strcmp(str.AsCString(), "") == 0);

    str.Append("%d", 12);
    VerifyOrQuit(str.GetLength() == 2);
    VerifyOrQuit(strcmp(str.AsCString(), "12") == 0);
    PrintString("str", str);

    str.Clear();
    str.Append(kLongString);
    VerifyOrQuit(str.IsTruncated() && str.GetLength() == sizeof(kLongString) - 1,
                 "String::Clear() + String::Append() did not handle overflow buffer correctly");
    PrintString("str", str);

    printf(" -- PASS\n");
}

void TestStringLength(void)
{
    char string_a[5] = "\0foo";
    char string_b[8] = "foo\0bar";

    printf("\nTest 4: String::StringLength() method\n");

    VerifyOrQuit(StringLength(string_a, 0) == 0);
    VerifyOrQuit(StringLength(string_a, 1) == 0);
    VerifyOrQuit(StringLength(string_a, 2) == 0);

    VerifyOrQuit(StringLength(string_b, 0) == 0);
    VerifyOrQuit(StringLength(string_b, 1) == 1);
    VerifyOrQuit(StringLength(string_b, 2) == 2);
    VerifyOrQuit(StringLength(string_b, 3) == 3);
    VerifyOrQuit(StringLength(string_b, 4) == 3);
    VerifyOrQuit(StringLength(string_b, 5) == 3);
    VerifyOrQuit(StringLength(string_b, 6) == 3);

    printf(" -- PASS\n");
}

void TestUtf8(void)
{
    printf("\nTest 5: IsValidUtf8String() function\n");

    VerifyOrQuit(IsValidUtf8String("An ASCII string"));
    VerifyOrQuit(IsValidUtf8String(u8"Строка UTF-8"));
    VerifyOrQuit(!IsValidUtf8String("\xbf"));
    VerifyOrQuit(!IsValidUtf8String("\xdf"));
    VerifyOrQuit(!IsValidUtf8String("\xef\x80"));
    VerifyOrQuit(!IsValidUtf8String("\xf7\x80\x80"));
    VerifyOrQuit(!IsValidUtf8String("\xff"));
    VerifyOrQuit(!IsValidUtf8String("NUL\x00NUL", 7)); // UTF-8 NUL
    VerifyOrQuit(!IsValidUtf8String("abcde\x11"));     // control character

    printf(" -- PASS\n");
}

void TestStringFind(void)
{
    char emptyString[1] = {'\0'};
    char testString[]   = "Foo.bar.bar\\.";
    char testString2[]  = "abcabcabcdabc";

    printf("\nTest 6: StringFind() function\n");

    VerifyOrQuit(StringFind(testString, 'F') == testString);
    VerifyOrQuit(StringFind(testString, 'o') == &testString[1]);
    VerifyOrQuit(StringFind(testString, '.') == &testString[3]);
    VerifyOrQuit(StringFind(testString, 'r') == &testString[6]);
    VerifyOrQuit(StringFind(testString, '\\') == &testString[11]);
    VerifyOrQuit(StringFind(testString, 'x') == nullptr);
    VerifyOrQuit(StringFind(testString, ',') == nullptr);

    VerifyOrQuit(StringFind(emptyString, 'F') == nullptr);
    VerifyOrQuit(StringFind(emptyString, '.') == nullptr);

    VerifyOrQuit(StringFind(testString, "Foo") == &testString[0]);
    VerifyOrQuit(StringFind(testString, "oo") == &testString[1]);
    VerifyOrQuit(StringFind(testString, "bar") == &testString[4]);
    VerifyOrQuit(StringFind(testString, "bar\\") == &testString[8]);
    VerifyOrQuit(StringFind(testString, "\\.") == &testString[11]);
    VerifyOrQuit(StringFind(testString, testString) == testString);
    VerifyOrQuit(StringFind(testString, "Fooo") == nullptr);
    VerifyOrQuit(StringFind(testString, "Far") == nullptr);
    VerifyOrQuit(StringFind(testString, "FOO") == nullptr);
    VerifyOrQuit(StringFind(testString, "BAR") == nullptr);
    VerifyOrQuit(StringFind(testString, "bar\\..") == nullptr);
    VerifyOrQuit(StringFind(testString, "") == &testString[0]);

    VerifyOrQuit(StringFind(emptyString, "foo") == nullptr);
    VerifyOrQuit(StringFind(emptyString, "bar") == nullptr);
    VerifyOrQuit(StringFind(emptyString, "") == &emptyString[0]);

    // Verify when sub-string has repeated patterns
    VerifyOrQuit(StringFind(testString2, "abcabc") == &testString2[0]);
    VerifyOrQuit(StringFind(testString2, "abcabcd") == &testString2[3]);

    VerifyOrQuit(StringFind(testString, "FOO", kStringCaseInsensitiveMatch) == &testString[0]);
    VerifyOrQuit(StringFind(testString, "OO", kStringCaseInsensitiveMatch) == &testString[1]);
    VerifyOrQuit(StringFind(testString, "BAR", kStringCaseInsensitiveMatch) == &testString[4]);
    VerifyOrQuit(StringFind(testString, "BAR\\", kStringCaseInsensitiveMatch) == &testString[8]);
    VerifyOrQuit(StringFind(testString, "\\.", kStringCaseInsensitiveMatch) == &testString[11]);
    VerifyOrQuit(StringFind(testString, testString) == testString);
    VerifyOrQuit(StringFind(testString, "FOOO", kStringCaseInsensitiveMatch) == nullptr);
    VerifyOrQuit(StringFind(testString, "FAR", kStringCaseInsensitiveMatch) == nullptr);
    VerifyOrQuit(StringFind(testString, "BAR\\..", kStringCaseInsensitiveMatch) == nullptr);
    VerifyOrQuit(StringFind(testString, "", kStringCaseInsensitiveMatch) == &testString[0]);

    VerifyOrQuit(StringFind(emptyString, "FOO", kStringCaseInsensitiveMatch) == nullptr);
    VerifyOrQuit(StringFind(emptyString, "BAR", kStringCaseInsensitiveMatch) == nullptr);
    VerifyOrQuit(StringFind(emptyString, "", kStringCaseInsensitiveMatch) == &emptyString[0]);

    // Verify when sub-string has repeated patterns
    VerifyOrQuit(StringFind(testString2, "ABCABC", kStringCaseInsensitiveMatch) == &testString2[0]);
    VerifyOrQuit(StringFind(testString2, "ABCABCD", kStringCaseInsensitiveMatch) == &testString2[3]);

    printf(" -- PASS\n");
}

void TestStringStartsWith(void)
{
    printf("\nTest 7: StringStartsWith() function\n");

    VerifyOrQuit(StringStartsWith("FooBar", "Foo"));
    VerifyOrQuit(!StringStartsWith("FooBar", "Ba"));
    VerifyOrQuit(StringStartsWith("FooBar", "FooBar"));
    VerifyOrQuit(!StringStartsWith("FooBar", "FooBarr"));
    VerifyOrQuit(!StringStartsWith("FooBar", "foo"));
    VerifyOrQuit(!StringStartsWith("FooBar", "FoO"));

    VerifyOrQuit(!StringStartsWith("", "foo"));

    VerifyOrQuit(StringStartsWith("FooBar", "FOO", kStringCaseInsensitiveMatch));
    VerifyOrQuit(!StringStartsWith("FooBar", "BA", kStringCaseInsensitiveMatch));
    VerifyOrQuit(StringStartsWith("FooBar", "FOOBAR", kStringCaseInsensitiveMatch));
    VerifyOrQuit(!StringStartsWith("FooBar", "FooBarr", kStringCaseInsensitiveMatch));
    VerifyOrQuit(StringStartsWith("FooBar", "foO", kStringCaseInsensitiveMatch));

    VerifyOrQuit(!StringStartsWith("", "foo", kStringCaseInsensitiveMatch));

    printf(" -- PASS\n");
}

void TestStringEndsWith(void)
{
    printf("\nTest 8: StringEndsWith() function\n");

    VerifyOrQuit(StringEndsWith("FooBar", 'r'));
    VerifyOrQuit(!StringEndsWith("FooBar", 'a'));
    VerifyOrQuit(!StringEndsWith("FooBar", '\0'));
    VerifyOrQuit(StringEndsWith("a", 'a'));
    VerifyOrQuit(!StringEndsWith("a", 'b'));

    VerifyOrQuit(StringEndsWith("FooBar", "Bar"));
    VerifyOrQuit(!StringEndsWith("FooBar", "Ba"));
    VerifyOrQuit(StringEndsWith("FooBar", "FooBar"));
    VerifyOrQuit(!StringEndsWith("FooBar", "FooBarr"));

    VerifyOrQuit(!StringEndsWith("", 'a'));
    VerifyOrQuit(!StringEndsWith("", "foo"));

    VerifyOrQuit(StringEndsWith("FooBar", "baR", kStringCaseInsensitiveMatch));
    VerifyOrQuit(!StringEndsWith("FooBar", "bA", kStringCaseInsensitiveMatch));
    VerifyOrQuit(StringEndsWith("FooBar", "fOOBar", kStringCaseInsensitiveMatch));
    VerifyOrQuit(!StringEndsWith("FooBar", "Foobarr", kStringCaseInsensitiveMatch));
    VerifyOrQuit(!StringEndsWith("", "Foo", kStringCaseInsensitiveMatch));

    printf(" -- PASS\n");
}

void TestStringMatch(void)
{
    printf("\nTest 9: StringMatch() function\n");

    VerifyOrQuit(StringMatch("", ""));
    VerifyOrQuit(StringMatch("FooBar", "FooBar"));
    VerifyOrQuit(!StringMatch("FooBar", "FooBa"));
    VerifyOrQuit(!StringMatch("FooBa", "FooBar"));
    VerifyOrQuit(!StringMatch("FooBa", "FooBar"));
    VerifyOrQuit(!StringMatch("FooBar", "fooBar"));
    VerifyOrQuit(!StringMatch("FooBaR", "FooBar"));

    VerifyOrQuit(StringMatch("", "", kStringCaseInsensitiveMatch));
    VerifyOrQuit(StringMatch("FooBar", "fOObAR", kStringCaseInsensitiveMatch));
    VerifyOrQuit(!StringMatch("FooBar", "fOObA", kStringCaseInsensitiveMatch));
    VerifyOrQuit(!StringMatch("FooBa", "FooBar", kStringCaseInsensitiveMatch));
    VerifyOrQuit(!StringMatch("FooBa", "FooBar", kStringCaseInsensitiveMatch));
    VerifyOrQuit(!StringMatch("Fooba", "fooBar", kStringCaseInsensitiveMatch));
    VerifyOrQuit(StringMatch("FooBar", "FOOBAR", kStringCaseInsensitiveMatch));
    VerifyOrQuit(StringMatch("FoobaR", "FooBar", kStringCaseInsensitiveMatch));
    VerifyOrQuit(StringMatch("FOOBAR", "foobar", kStringCaseInsensitiveMatch));

    printf(" -- PASS\n");
}

void TestStringToLowercase(void)
{
    const uint16_t kMaxSize = 100;

    const char kTestString[]      = "!@#$%^&*()_+=[].,<>//;:\"'`~ \t\r\n";
    const char kUppercaseString[] = "ABCDEFGHIJKLMNOPQRATUVWXYZABCDEFGHIJKLMNOPQRATUVWXYZ";
    const char kLowercaseString[] = "abcdefghijklmnopqratuvwxyzabcdefghijklmnopqratuvwxyz";

    char string[kMaxSize];

    printf("\nTest 10: StringConvertToLowercase() function\n");

    memcpy(string, kTestString, sizeof(kTestString));
    StringConvertToLowercase(string);
    VerifyOrQuit(memcmp(string, kTestString, sizeof(kTestString)) == 0);
    StringConvertToUppercase(string);
    VerifyOrQuit(memcmp(string, kTestString, sizeof(kTestString)) == 0);

    memcpy(string, kUppercaseString, sizeof(kUppercaseString));
    StringConvertToLowercase(string);
    VerifyOrQuit(memcmp(string, kLowercaseString, sizeof(kLowercaseString)) == 0);
    StringConvertToUppercase(string);
    VerifyOrQuit(memcmp(string, kUppercaseString, sizeof(kUppercaseString)) == 0);

    printf(" -- PASS\n");
}

void TestStringParseUint8(void)
{
    struct TestCase
    {
        const char *mString;
        Error       mError;
        uint8_t     mExpectedValue;
        uint16_t    mParsedLength;
    };

    static const TestCase kTestCases[] = {
        {"0", kErrorNone, 0, 1},
        {"1", kErrorNone, 1, 1},
        {"12", kErrorNone, 12, 2},
        {"91", kErrorNone, 91, 2},
        {"200", kErrorNone, 200, 3},
        {"00000", kErrorNone, 0, 5},
        {"00000255", kErrorNone, 255, 8},
        {"2 00", kErrorNone, 2, 1},
        {"77a12", kErrorNone, 77, 2},
        {"", kErrorParse},     // Does not start with digit char ['0'-'9']
        {"a12", kErrorParse},  // Does not start with digit char ['0'-'9']
        {" 12", kErrorParse},  // Does not start with digit char ['0'-'9']
        {"256", kErrorParse},  // Larger than max `uint8_t`
        {"1000", kErrorParse}, // Larger than max `uint8_t`
        {"0256", kErrorParse}, // Larger than max `uint8_t`
    };

    uint8_t digit;

    printf("\nTest 11: TestStringParseUint8() function\n");

    for (const TestCase &testCase : kTestCases)
    {
        const char *string = testCase.mString;
        Error       error;
        uint8_t     u8;

        error = StringParseUint8(string, u8);

        VerifyOrQuit(error == testCase.mError);

        if (testCase.mError == kErrorNone)
        {
            printf("\n%-10s -> %-3u (expect: %-3u), len:%u (expect:%u)", testCase.mString, u8, testCase.mExpectedValue,
                   static_cast<uint8_t>(string - testCase.mString), testCase.mParsedLength);

            VerifyOrQuit(u8 == testCase.mExpectedValue);
            VerifyOrQuit(string - testCase.mString == testCase.mParsedLength);
        }
        else
        {
            printf("\n%-10s -> kErrorParse", testCase.mString);
        }
    }

    for (char c = '0'; c <= '9'; c++)
    {
        VerifyOrQuit(IsDigit(c));
        VerifyOrQuit(!IsUppercase(c));
        VerifyOrQuit(!IsLowercase(c));

        SuccessOrQuit(ParseDigit(c, digit));
        VerifyOrQuit(digit == (c - '0'));

        SuccessOrQuit(ParseHexDigit(c, digit));
        VerifyOrQuit(digit == (c - '0'));
    }

    for (char c = 'A'; c <= 'Z'; c++)
    {
        VerifyOrQuit(!IsDigit(c));
        VerifyOrQuit(IsUppercase(c));
        VerifyOrQuit(!IsLowercase(c));
        VerifyOrQuit(ParseDigit(c, digit) != kErrorNone);

        if (c <= 'F')
        {
            SuccessOrQuit(ParseHexDigit(c, digit));
            VerifyOrQuit(digit == (c - 'A' + 10));
        }
        else
        {
            VerifyOrQuit(ParseHexDigit(c, digit) != kErrorNone);
        }
    }

    for (char c = 'a'; c <= 'z'; c++)
    {
        VerifyOrQuit(!IsDigit(c));
        VerifyOrQuit(!IsUppercase(c));
        VerifyOrQuit(IsLowercase(c));
        VerifyOrQuit(ParseDigit(c, digit) != kErrorNone);

        if (c <= 'f')
        {
            SuccessOrQuit(ParseHexDigit(c, digit));
            VerifyOrQuit(digit == (c - 'a' + 10));
        }
        else
        {
            VerifyOrQuit(ParseHexDigit(c, digit) != kErrorNone);
        }
    }

    VerifyOrQuit(!IsDigit(static_cast<char>('0' - 1)));
    VerifyOrQuit(!IsDigit(static_cast<char>('9' + 1)));

    VerifyOrQuit(!IsUppercase(static_cast<char>('A' - 1)));
    VerifyOrQuit(!IsUppercase(static_cast<char>('Z' + 1)));

    VerifyOrQuit(!IsLowercase(static_cast<char>('a' - 1)));
    VerifyOrQuit(!IsLowercase(static_cast<char>('z' + 1)));

    printf("\n\n -- PASS\n");
}

void TestStringCopy(void)
{
    char buffer[10];
    char smallBuffer[1];

    printf("\nTest 11: StringCopy() function\n");

    SuccessOrQuit(StringCopy(buffer, "foo", kStringCheckUtf8Encoding));
    VerifyOrQuit(StringMatch(buffer, "foo"));

    SuccessOrQuit(StringCopy(buffer, nullptr, kStringCheckUtf8Encoding));
    VerifyOrQuit(StringMatch(buffer, ""));

    SuccessOrQuit(StringCopy(buffer, "", kStringCheckUtf8Encoding));
    VerifyOrQuit(StringMatch(buffer, ""));

    SuccessOrQuit(StringCopy(buffer, "123456789", kStringCheckUtf8Encoding));
    VerifyOrQuit(StringMatch(buffer, "123456789"));

    VerifyOrQuit(StringCopy(buffer, "1234567890") == kErrorInvalidArgs);
    VerifyOrQuit(StringCopy(buffer, "1234567890abcdef") == kErrorInvalidArgs);

    SuccessOrQuit(StringCopy(smallBuffer, "", kStringCheckUtf8Encoding));
    VerifyOrQuit(StringMatch(smallBuffer, ""));

    VerifyOrQuit(StringCopy(smallBuffer, "a") == kErrorInvalidArgs);

    printf(" -- PASS\n");
}

// gcc-4 does not support constexpr function
#if __GNUC__ > 4
static_assert(ot::AreStringsInOrder("a", "b"), "AreStringsInOrder() failed");
static_assert(ot::AreStringsInOrder("aa", "aaa"), "AreStringsInOrder() failed");
static_assert(ot::AreStringsInOrder("", "a"), "AreStringsInOrder() failed");
static_assert(!ot::AreStringsInOrder("cd", "cd"), "AreStringsInOrder() failed");
static_assert(!ot::AreStringsInOrder("z", "abcd"), "AreStringsInOrder() failed");
static_assert(!ot::AreStringsInOrder("0", ""), "AreStringsInOrder() failed");
#endif

} // namespace ot

int main(void)
{
    ot::TestStringWriter();
    ot::TestStringLength();
    ot::TestUtf8();
    ot::TestStringFind();
    ot::TestStringStartsWith();
    ot::TestStringEndsWith();
    ot::TestStringMatch();
    ot::TestStringToLowercase();
    ot::TestStringParseUint8();
    ot::TestStringCopy();
    printf("\nAll tests passed.\n");
    return 0;
}