/*
 * Public Domain Software
 *
 * I (Matthias Ladkau) am the author of the source code in this file.
 * I have placed the source code in this file in the public domain.
 *
 * For further information see: http://creativecommons.org/publicdomain/zero/1.0/
 */

package stringutil

import (
	"bytes"
	"fmt"
	"regexp"
	"sync"
	"testing"
)

func TestLongestCommonPrefix(t *testing.T) {

	if res := LongestCommonPrefix([]string{}); res != "" {
		t.Error("Unexpected result:", res)
		return
	}

	if res := LongestCommonPrefix([]string{"test"}); res != "test" {
		t.Error("Unexpected result:", res)
		return
	}

	if res := LongestCommonPrefix([]string{"tester", "test"}); res != "test" {
		t.Error("Unexpected result:", res)
		return
	}

	if res := LongestCommonPrefix([]string{"foo", "test"}); res != "" {
		t.Error("Unexpected result:", res)
		return
	}

	if res := LongestCommonPrefix([]string{"foo", "test"}); res != "" {
		t.Error("Unexpected result:", res)
		return
	}

	if res := LongestCommonPrefix([]string{"foo2", "foo1", "footest"}); res != "foo" {
		t.Error("Unexpected result:", res)
		return
	}
}

func TestPrintStringTable(t *testing.T) {

	if res := PrintStringTable(nil, 0); res != "" {
		t.Error("Unexpected result:\n", "#\n"+res+"#")
		return
	}

	test1 := []string{"foo", "bar", "tester", "1", "xxx", "test", "te"}

	if res := PrintStringTable(test1, 4); res != `
foo bar  tester 1
xxx test te
`[1:] {
		t.Error("Unexpected result:\n", "#"+res+"#")
		return
	}

	if res := PrintStringTable(test1, 3); res != `
foo bar tester
1   xxx test
te
`[1:] {
		t.Error("Unexpected result:\n", "#"+res+"#")
		return
	}
}

func TestRuneSlice(t *testing.T) {
	sl := StringToRuneSlice("test")

	if fmt.Sprint(sl) != "[116 101 115 116]" {
		t.Error("Unexpected result:", sl)
		return
	}

	if RuneSliceToString(sl) != "test" {
		t.Error("Unexpected result:", sl)
		return
	}
}

func TestPluralCompareByteArray(t *testing.T) {
	if fmt.Sprintf("There are 2 test%s", Plural(2)) != "There are 2 tests" {
		t.Error("2 items should have an 's'")
		return
	}
	if fmt.Sprintf("There is 1 test%s", Plural(1)) != "There is 1 test" {
		t.Error("1 item should have no 's'")
		return
	}

	if fmt.Sprintf("There are 0 test%s", Plural(0)) != "There are 0 tests" {
		t.Error("0 items should have an 's'")
		return
	}
}

func TestGlobToRegex(t *testing.T) {
	globMatch(t, true, "*", "^$", "foo", "bar")
	globMatch(t, true, "?", "?", "^", "[", "]", "$")
	globMatch(t, true, "foo*", "foo", "food", "fool")
	globMatch(t, true, "f*d", "fud", "food")
	globMatch(t, true, "*d", "good", "bad")
	globMatch(t, true, "\\*\\?\\[\\{\\\\", "*?[{\\")
	globMatch(t, true, "[]^-]", "]", "-", "^")
	globMatch(t, true, "]", "]")
	globMatch(t, true, "^.$()|+", "^.$()|+")
	globMatch(t, true, "[^^]", ".", "$", "[", "]")
	globMatch(t, false, "[^^]", "^")
	globMatch(t, true, "[!!-]", "^", "?")
	globMatch(t, false, "[!!-]", "!", "-")
	globMatch(t, true, "{[12]*,[45]*,[78]*}", "1", "2!", "4", "42", "7", "7$")
	globMatch(t, false, "{[12]*,[45]*,[78]*}", "3", "6", "9ß")
	globMatch(t, true, "}", "}")
	globMatch(t, true, "abc,", "abc,")

	globMatch(t, true, "myfile[^9]", "myfile1")
	globMatch(t, true, "myfile[!9]", "myfile1")
	globMatch(t, false, "myfile[^9]", "myfile9")
	globMatch(t, false, "myfile[!9]", "myfile9")

	globMatch(t, true, "*.*", "tester/bla.txt")
	globMatch(t, false, "*.tmp", "tester/bla.txt")

	testdata := []string{"foo*test", "f?t", "*d", "all"}
	expected := []string{"foo", "f", "", "all"}

	for i, str := range testdata {
		res := GlobStartingLiterals(str)

		if res != expected[i] {
			t.Error("Unexpected starting literal for glob:", res, "str:",
				str, "expected:", expected[i])
		}
	}

	testdata = []string{"[", "{", "\\", "*.*\\", "[["}
	expected = []string{"Unclosed character class at 1 of [",
		"Unclosed group at 1 of {",
		"Missing escaped character at 1 of \\",
		"Missing escaped character at 4 of *.*\\",
		"Unclosed character class at 1 of [["}

	for i, str := range testdata {
		_, err := GlobToRegex(str)

		if err.Error() != expected[i] {
			t.Error("Unexpected error for glob:", err, "str:",
				str, "expected error:", expected[i])
		}
	}

	if str, err := GlobToRegex("[][]"); str != "[][]" || err != nil {
		t.Error("Unecpected glob parsing result:", str, err)
	}

	if str, err := GlobToRegex(")"); str != "\\)" || err != nil {
		t.Error("Unecpected glob parsing result:", str, err)
	}
}

func globMatch(t *testing.T, expectedResult bool, glob string, testStrings ...string) {
	re, err := GlobToRegex(glob)
	if err != nil {
		t.Error("Glob parsing error:", err)
	}
	for _, testString := range testStrings {
		res, err := regexp.MatchString(re, testString)
		if err != nil {
			t.Error("Regexp", re, "parsing error:", err, "from glob", glob)
		}
		if res != expectedResult {
			t.Error("Unexpected evaluation result. Glob:", glob, "testString:",
				testString, "expectedResult:", expectedResult)
		}
	}
}

func TestLevenshteinDistance(t *testing.T) {
	testdata1 := []string{"", "a", "", "abc", "", "a", "abc", "a", "b", "ac",
		"abcdefg", "a", "ab", "example", "sturgeon", "levenshtein", "distance"}
	testdata2 := []string{"", "", "a", "", "abc", "a", "abc", "ab", "ab", "abc",
		"xabxcdxxefxgx", "b", "ac", "samples", "urgently", "frankenstein", "difference"}
	expected := []int{0, 1, 1, 3, 3, 0, 0, 1, 1, 1, 6, 1, 1,
		3, 6, 6, 5}

	for i, str1 := range testdata1 {
		res := LevenshteinDistance(str1, testdata2[i])

		if res != expected[i] {
			t.Error("Unexpected Levenshtein distance result:", res, "str1:",
				str1, "str2:", testdata2[i], "expected:", expected[i])
		}
	}
}

func TestVersionStringCompare(t *testing.T) {
	testdata1 := []string{"1", "1.1", "1.1", "2.1", "5.4.3.2.1", "1.674.2.18",
		"1.674.2", "1.674.2.5", "2.4.18.14smp", "2.4.18.15smp", "1.2.3a1",
		"2.18.15smp"}
	testdata2 := []string{"2", "2.0", "1.1", "2.0", "6.5.4.3.2", "1.674.2.5",
		"1.674.2.5", "1.674.2", "2.4.18.14smp", "2.4.18.14smp", "1.2.3b1",
		"2.4.18.14smp"}

	expected := []int{-1, -1, 0, 1, -1, 1, -1, 1, 0, 1, -1, 1}

	for i, str1 := range testdata1 {
		res := VersionStringCompare(str1, testdata2[i])

		if res != expected[i] {
			t.Error("Unexpected version string compare result:", res, "str1:",
				str1, "str2:", testdata2[i])
		}
	}
}

func TestVersionStringPartCompare(t *testing.T) {

	testdata1 := []string{"", "", "1", "1", "a", "1a", "a", "1a", "1a", "1", "12a", "12a1",
		"12a1"}
	testdata2 := []string{"", "1", "", "2", "b", "b", "2b", "2b", "1", "1b", "12b", "12a2",
		"12b1"}
	expected := []int{0, -1, 1, -1, -1, 1, -1, -1, 1, -1, -1, -1, -1}

	for i, str1 := range testdata1 {
		res := versionStringPartCompare(str1, testdata2[i])

		if res != expected[i] {
			t.Error("Unexpected version string compare result:", res, "str1:",
				str1, "str2:", testdata2[i])
		}
	}
}

func TestIsAlphaNumeric(t *testing.T) {
	testdata := []string{"test", "123test", "test1234_123", "test#", "test-"}
	expected := []bool{true, true, true, false, false}

	for i, str := range testdata {
		if IsAlphaNumeric(str) != expected[i] {
			t.Error("Unexpected result for alphanumeric test:", str)
		}
	}
}

func TestIsTrueValue(t *testing.T) {
	testdata := []string{"1", "ok", "1", "FaLse", "0"}
	expected := []bool{true, true, true, false, false}

	for i, str := range testdata {
		if IsTrueValue(str) != expected[i] {
			t.Error("Unexpected result for alphanumeric test:", str)
		}
	}
}

func TestIndexOf(t *testing.T) {
	slice := []string{"foo", "bar", "test"}

	if res := IndexOf("foo", slice); res != 0 {
		t.Error("Unexpected result", res)
		return
	}
	if res := IndexOf("bar", slice); res != 1 {
		t.Error("Unexpected result", res)
		return
	}
	if res := IndexOf("test", slice); res != 2 {
		t.Error("Unexpected result", res)
		return
	}
	if res := IndexOf("hans", slice); res != -1 {
		t.Error("Unexpected result", res)
		return
	}
}

func TestMapKeys(t *testing.T) {
	testMap := map[string]interface{}{
		"1": "2",
		"3": "4",
		"5": "6",
	}

	if res := MapKeys(testMap); fmt.Sprint(res) != "[1 3 5]" {
		t.Error("Unexpected result:", res)
		return
	}
}

func TestGenerateRollingString(t *testing.T) {
	testdata := []string{"_-=-_", "abc", "=", ""}
	testlen := []int{20, 4, 5, 100}
	expected := []string{"_-=-__-=-__-=-__-=-_", "abca", "=====", ""}

	for i, str := range testdata {
		res := GenerateRollingString(str, testlen[i])
		if res != expected[i] {
			t.Error("Unexpected result for creating a roling string from:", str,
				"result:", res, "expected:", expected[i])
		}
	}
}

func TestConvertToString(t *testing.T) {

	if res := ConvertToString(""); res != "" {
		t.Error("Unexpected result:", res)
		return
	}

	if res := ConvertToString("test"); res != "test" {
		t.Error("Unexpected result:", res)
		return
	}

	if res := ConvertToString(4.123); res != "4.123" {
		t.Error("Unexpected result:", res)
		return
	}

	if res := ConvertToString(6); res != "6" {
		t.Error("Unexpected result:", res)
		return
	}

	if res := ConvertToString(map[string]int{"z": 1, "d": 2, "a": 4}); res != `{"a":4,"d":2,"z":1}` {
		t.Error("Unexpected result:", res)
		return
	}

	if res := ConvertToString([]int{1, 2, 3}); res != "[1,2,3]" {
		t.Error("Unexpected result:", res)
		return
	}

	if res := ConvertToString(map[interface{}]interface{}{"z": 1, "d": 2, "a": 4}); res != `{"a":4,"d":2,"z":1}` {
		t.Error("Unexpected result:", res)
		return
	}

	if res := ConvertToString(map[interface{}]interface{}{"z": []interface{}{1, 2, 3}, "d": 2, "a": 4}); res != `{"a":4,"d":2,"z":[1,2,3]}` {
		t.Error("Unexpected result:", res)
		return
	}

	if res := ConvertToString([]interface{}{1, sync.Mutex{}, 3}); res != `[1,{},3]` {
		t.Error("Unexpected result:", res)
		return
	}

	if res := ConvertToString([]interface{}{1, map[interface{}]interface{}{1: 2}, 3}); res != `[1,{"1":2},3]` {
		t.Error("Unexpected result:", res)
		return
	}

	if res := ConvertToString(&bytes.Buffer{}); res != "" {
		t.Error("Unexpected result:", res)
		return
	}

	// Not much to do with such a construct but we shouldn't fail!

	type foo struct{ i int }

	x := make(map[foo]foo)
	x[foo{1}] = foo{2}

	if res := ConvertToString(x); res != "map[{1}:{2}]" {
		t.Error("Unexpected result:", res)
		return
	}
}

func TestConvertToPrettyString(t *testing.T) {

	if res := ConvertToPrettyString(""); res != `""` {
		t.Error("Unexpected result:", res)
		return
	}

	if res := ConvertToPrettyString("test"); res != `"test"` {
		t.Error("Unexpected result:", res)
		return
	}

	if res := ConvertToPrettyString(4.123); res != "4.123" {
		t.Error("Unexpected result:", res)
		return
	}

	if res := ConvertToString(6); res != "6" {
		t.Error("Unexpected result:", res)
		return
	}

	if res := ConvertToPrettyString(map[string]int{"z": 1, "d": 2, "a": 4}); res != `{
  "a": 4,
  "d": 2,
  "z": 1
}` {
		t.Error("Unexpected result:", res)
		return
	}

	if res := ConvertToPrettyString([]int{1, 2, 3}); res != `[
  1,
  2,
  3
]` {
		t.Error("Unexpected result:", res)
		return
	}

	if res := ConvertToPrettyString(map[interface{}]interface{}{"z": 1, "d": 2, "a": 4}); res != `{
  "a": 4,
  "d": 2,
  "z": 1
}` {
		t.Error("Unexpected result:", res)
		return
	}

	if res := ConvertToPrettyString(map[interface{}]interface{}{"z": []interface{}{1, 2, 3}, "d": 2, "a": 4}); res != `{
  "a": 4,
  "d": 2,
  "z": [
    1,
    2,
    3
  ]
}` {
		t.Error("Unexpected result:", res)
		return
	}

	if res := ConvertToPrettyString([]interface{}{1, sync.Mutex{}, 3}); res != `[
  1,
  {},
  3
]` {
		t.Error("Unexpected result:", res)
		return
	}

	if res := ConvertToPrettyString([]interface{}{1, map[interface{}]interface{}{1: 2}, 3}); res != `[
  1,
  {
    "1": 2
  },
  3
]` {
		t.Error("Unexpected result:", res)
		return
	}

	if res := ConvertToPrettyString(&bytes.Buffer{}); res != "{}" {
		t.Error("Unexpected result:", res)
		return
	}

	// Not much to do with such a construct but we shouldn't fail!

	type foo struct{ i int }

	x := make(map[foo]foo)
	x[foo{1}] = foo{2}

	if res := ConvertToPrettyString(x); res != "map[{1}:{2}]" {
		t.Error("Unexpected result:", res)
		return
	}
}

func TestMD5HexString(t *testing.T) {
	res := MD5HexString("This is a test")
	if res != "ce114e4501d2f4e2dcea3e17b546f339" {
		t.Error("Unexpected md5 hex result", res)

	}
}

func TestLengthConstantEquals(t *testing.T) {

	if !LengthConstantEquals([]byte("test1"), []byte("test1")) {
		t.Error("Unexpected result")
		return
	}

	if LengthConstantEquals([]byte("test1"), []byte("test2")) {
		t.Error("Unexpected result")
		return
	}

	if LengthConstantEquals([]byte("test1"), []byte("test2test123")) {
		t.Error("Unexpected result")
		return
	}
}

func TestPrintGraphicStringTable(t *testing.T) {

	if res := PrintGraphicStringTable(nil, 0, 5, nil); res != "" {
		t.Error("Unexpected result:\n", "#\n"+res+"#")
		return
	}

	if res := PrintGraphicStringTable([]string{}, 4, 5, SingleLineTable); res != `
┌┐
└┘
`[1:] {
		t.Error("Unexpected result:\n", "#\n"+res+"#")
		return
	}

	if res := PrintCSVTable([]string{}, 4); res != "" {
		t.Error("Unexpected result:\n", "#\n"+res+"#")
		return
	}

	test1 := []string{"foo", "bar", "tester", "1", "xxx", "test", "te", "foo",
		"bar", "tester", "1"}

	if res := PrintGraphicStringTable(test1, 4, 5, SingleLineTable); res != `
┌────┬───────┬───────┬────┐
│foo │bar    │tester │1   │
│xxx │test   │te     │foo │
│bar │tester │1      │    │
└────┴───────┴───────┴────┘
`[1:] {
		t.Error("Unexpected result:\n", "#\n"+res+"#")
		return
	}

	if res := PrintCSVTable(test1, 4); res != `
foo, bar, tester, 1
xxx, test, te, foo
bar, tester, 1
`[1:] {
		t.Error("Unexpected result:\n", "#\n"+res+"#")
		return
	}

	test1 = []string{"foo", "bar", "tester", "1", "xxx", "test", "te", "foo",
		"bar"}

	if res := PrintGraphicStringTable(test1, 4, 5, nil); res != `
#########################
#foo #bar  #tester #1   #
#xxx #test #te     #foo #
#bar #     #       #    #
#########################
`[1:] {
		t.Error("Unexpected result:\n", "#\n"+res+"#")
		return
	}

	test1 = []string{"foo", "bar", "tester", "1", "xxx", "test", "te", "foo"}

	if res := PrintGraphicStringTable(test1, 4, 5, nil); res != `
#########################
#foo #bar  #tester #1   #
#xxx #test #te     #foo #
#########################
`[1:] {
		t.Error("Unexpected result:\n", "#\n"+res+"#")
		return
	}
	test1 = []string{"foo", "bar", "tester", "1", "xxx", "test", "te", "foo"}

	if res := PrintGraphicStringTable(test1, 1, 2, SingleLineTable); res != `
┌───────┐
│foo    │
│bar    │
├───────┤
│tester │
│1      │
│xxx    │
│test   │
│te     │
│foo    │
└───────┘
`[1:] {
		t.Error("Unexpected result:\n", "#\n"+res+"#")
		return
	}

	if res := PrintCSVTable(test1, 1); res != `
foo
bar
tester
1
xxx
test
te
foo
`[1:] {
		t.Error("Unexpected result:\n", "#\n"+res+"#")
		return
	}

	if res := PrintGraphicStringTable(test1, 100, 0, nil); res != `
##########################################
#foo #bar #tester #1 #xxx #test #te #foo #
##########################################
`[1:] {
		t.Error("Unexpected result:\n", "#\n"+res+"#")
		return
	}

	test1 = []string{"foo", "bar", "tester", "1", "xxx", "test", "te", "foo"}

	if res := PrintGraphicStringTable(test1, 4, 5, SingleLineTable); res != `
┌────┬─────┬───────┬────┐
│foo │bar  │tester │1   │
│xxx │test │te     │foo │
└────┴─────┴───────┴────┘
`[1:] {
		t.Error("Unexpected result:\n", "#\n"+res+"#")
		return
	}
	test1 = []string{"foo", "bar", "tester", "1", "xxx", "test", "te", "foo"}

	if res := PrintGraphicStringTable(test1, 1, 2, SingleDoubleLineTable); res != `
╒═══════╕
│foo    │
│bar    │
╞═══════╡
│tester │
│1      │
│xxx    │
│test   │
│te     │
│foo    │
╘═══════╛
`[1:] {
		t.Error("Unexpected result:\n", "#\n"+res+"#")
		return
	}

	if res := PrintGraphicStringTable(test1, 1, 2, DoubleSingleLineTable); res != `
╓───────╖
║foo    ║
║bar    ║
╟───────╢
║tester ║
║1      ║
║xxx    ║
║test   ║
║te     ║
║foo    ║
╙───────╜
`[1:] {
		t.Error("Unexpected result:\n", "#\n"+res+"#")
		return
	}

	if res := PrintGraphicStringTable(test1, 1, 2, DoubleLineTable); res != `
╔═══════╗
║foo    ║
║bar    ║
╠═══════╣
║tester ║
║1      ║
║xxx    ║
║test   ║
║te     ║
║foo    ║
╚═══════╝
`[1:] {
		t.Error("Unexpected result:\n", "#\n"+res+"#")
		return
	}

	if res := PrintGraphicStringTable(test1, 100, 0, SingleLineTable); res != `
┌────┬────┬───────┬──┬────┬─────┬───┬────┐
│foo │bar │tester │1 │xxx │test │te │foo │
└────┴────┴───────┴──┴────┴─────┴───┴────┘
`[1:] {
		t.Error("Unexpected result:\n", "#\n"+res+"#")
		return
	}

}

func TestCamelCaseSplit(t *testing.T) {

	if res := fmt.Sprint(CamelCaseSplit("FooBar")); res != "[Foo Bar]" {
		t.Error("Unexpected result:", res)
		return
	}

	if res := fmt.Sprint(CamelCaseSplit("FooB#ar")); res != "[Foo B # ar]" {
		t.Error("Unexpected result:", res)
		return
	}

	if res := fmt.Sprint(CamelCaseSplit("fOObAR")); res != "[f O Ob AR]" {
		t.Error("Unexpected result:", res)
		return
	}

	if res := fmt.Sprint(CamelCaseSplit("lower")); res != "[lower]" {
		t.Error("Unexpected result:", res)
		return
	}

	if res := fmt.Sprint(CamelCaseSplit("foo1bar")); res != "[foo 1 bar]" {
		t.Error("Unexpected result:", res)
		return
	}

	if res := fmt.Sprint(CamelCaseSplit("Low\xf2\xe6Er1")); res != "[Low\xf2\xe6Er1]" {
		t.Error("Unexpected result:", res)
		return
	}

	if res := fmt.Sprint(CamelCaseSplit("ROCKHard")); res != "[ROCK Hard]" {
		t.Error("Unexpected result:", res)
		return
	}
}