// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package testing

var good_re = []string{
	``,
	`.`,
	`^.$`,
	`a`,
	`a*`,
	`a+`,
	`a?`,
	`a|b`,
	`a*|b*`,
	`(a*|b)(c*|d)`,
	`[a-z]`,
	`[a-abc-c\-\]\[]`,
	`[a-z]+`,
	`[]`,
	`[abc]`,
	`[^1234]`,
	`[^\n]`,
}

// TODO: nice to do this with a map
type stringError struct {
	re  string
	err string
}

var bad_re = []stringError{
	stringError{`*`, ErrBareClosure},
	stringError{`(abc`, ErrUnmatchedLpar},
	stringError{`abc)`, ErrUnmatchedRpar},
	stringError{`x[a-z`, ErrUnmatchedLbkt},
	stringError{`abc]`, ErrUnmatchedRbkt},
	stringError{`[z-a]`, ErrBadRange},
	stringError{`abc\`, ErrExtraneousBackslash},
	stringError{`a**`, ErrBadClosure},
	stringError{`a*+`, ErrBadClosure},
	stringError{`a??`, ErrBadClosure},
	stringError{`*`, ErrBareClosure},
	stringError{`\x`, ErrBadBackslash},
}

type vec []int

type tester struct {
	re    string
	text  string
	match vec
}

var matches = []tester{
	tester{``, "", vec{0, 0}},
	tester{`a`, "a", vec{0, 1}},
	tester{`x`, "y", vec{}},
	tester{`b`, "abc", vec{1, 2}},
	tester{`.`, "a", vec{0, 1}},
	tester{`.*`, "abcdef", vec{0, 6}},
	tester{`^abcd$`, "abcd", vec{0, 4}},
	tester{`^bcd'`, "abcdef", vec{}},
	tester{`^abcd$`, "abcde", vec{}},
	tester{`a+`, "baaab", vec{1, 4}},
	tester{`a*`, "baaab", vec{0, 0}},
	tester{`[a-z]+`, "abcd", vec{0, 4}},
	tester{`[^a-z]+`, "ab1234cd", vec{2, 6}},
	tester{`[a\-\]z]+`, "az]-bcz", vec{0, 4}},
	tester{`[^\n]+`, "abcd\n", vec{0, 4}},
	tester{`[日本語]+`, "日本語日本語", vec{0, 18}},
	tester{`()`, "", vec{0, 0, 0, 0}},
	tester{`(a)`, "a", vec{0, 1, 0, 1}},
	tester{`(.)(.)`, "日a", vec{0, 4, 0, 3, 3, 4}},
	tester{`(.*)`, "", vec{0, 0, 0, 0}},
	tester{`(.*)`, "abcd", vec{0, 4, 0, 4}},
	tester{`(..)(..)`, "abcd", vec{0, 4, 0, 2, 2, 4}},
	tester{`(([^xyz]*)(d))`, "abcd", vec{0, 4, 0, 4, 0, 3, 3, 4}},
	tester{`((a|b|c)*(d))`, "abcd", vec{0, 4, 0, 4, 2, 3, 3, 4}},
	tester{`(((a|b|c)*)(d))`, "abcd", vec{0, 4, 0, 4, 0, 3, 2, 3, 3, 4}},
	tester{`a*(|(b))c*`, "aacc", vec{0, 4, 2, 2, -1, -1}},
}

func compileTest(t *T, expr string, error string) *Regexp {
	re, err := CompileRegexp(expr)
	if err != error {
		t.Error("compiling `", expr, "`; unexpected error: ", err)
	}
	return re
}

func printVec(t *T, m []int) {
	l := len(m)
	if l == 0 {
		t.Log("\t<no match>")
	} else {
		for i := 0; i < l; i = i + 2 {
			t.Log("\t", m[i], ",", m[i+1])
		}
	}
}

func printStrings(t *T, m []string) {
	l := len(m)
	if l == 0 {
		t.Log("\t<no match>")
	} else {
		for i := 0; i < l; i = i + 2 {
			t.Logf("\t%q", m[i])
		}
	}
}

func printBytes(t *T, b [][]byte) {
	l := len(b)
	if l == 0 {
		t.Log("\t<no match>")
	} else {
		for i := 0; i < l; i = i + 2 {
			t.Logf("\t%q", b[i])
		}
	}
}

func equal(m1, m2 []int) bool {
	l := len(m1)
	if l != len(m2) {
		return false
	}
	for i := 0; i < l; i++ {
		if m1[i] != m2[i] {
			return false
		}
	}
	return true
}

func equalStrings(m1, m2 []string) bool {
	l := len(m1)
	if l != len(m2) {
		return false
	}
	for i := 0; i < l; i++ {
		if m1[i] != m2[i] {
			return false
		}
	}
	return true
}

func equalBytes(m1 [][]byte, m2 []string) bool {
	l := len(m1)
	if l != len(m2) {
		return false
	}
	for i := 0; i < l; i++ {
		if string(m1[i]) != m2[i] {
			return false
		}
	}
	return true
}

func executeTest(t *T, expr string, str string, match []int) {
	re := compileTest(t, expr, "")
	if re == nil {
		return
	}
	m := re.ExecuteString(str)
	if !equal(m, match) {
		t.Error("ExecuteString failure on `", expr, "` matching `", str, "`:")
		printVec(t, m)
		t.Log("should be:")
		printVec(t, match)
	}
	// now try bytes
	m = re.Execute([]byte(str))
	if !equal(m, match) {
		t.Error("Execute failure on `", expr, "` matching `", str, "`:")
		printVec(t, m)
		t.Log("should be:")
		printVec(t, match)
	}
}

func TestGoodCompile(t *T) {
	for i := 0; i < len(good_re); i++ {
		compileTest(t, good_re[i], "")
	}
}

func TestBadCompile(t *T) {
	for i := 0; i < len(bad_re); i++ {
		compileTest(t, bad_re[i].re, bad_re[i].err)
	}
}

func TestExecute(t *T) {
	for i := 0; i < len(matches); i++ {
		test := &matches[i]
		executeTest(t, test.re, test.text, test.match)
	}
}

func matchTest(t *T, expr string, str string, match []int) {
	re := compileTest(t, expr, "")
	if re == nil {
		return
	}
	m := re.MatchString(str)
	if m != (len(match) > 0) {
		t.Error("MatchString failure on `", expr, "` matching `", str, "`:", m, "should be", len(match) > 0)
	}
	// now try bytes
	m = re.Match([]byte(str))
	if m != (len(match) > 0) {
		t.Error("Match failure on `", expr, "` matching `", str, "`:", m, "should be", len(match) > 0)
	}
}

func TestMatch(t *T) {
	for i := 0; i < len(matches); i++ {
		test := &matches[i]
		matchTest(t, test.re, test.text, test.match)
	}
}

func matchStringsTest(t *T, expr string, str string, match []int) {
	re := compileTest(t, expr, "")
	if re == nil {
		return
	}
	strs := make([]string, len(match)/2)
	for i := 0; i < len(match); i++ {
		strs[i/2] = str[match[i]:match[i+1]]
	}
	m := re.MatchStrings(str)
	if !equalStrings(m, strs) {
		t.Error("MatchStrings failure on `", expr, "` matching `", str, "`:")
		printStrings(t, m)
		t.Log("should be:")
		printStrings(t, strs)
	}
	// now try bytes
	s := re.MatchSlices([]byte(str))
	if !equalBytes(s, strs) {
		t.Error("MatchSlices failure on `", expr, "` matching `", str, "`:")
		printBytes(t, s)
		t.Log("should be:")
		printStrings(t, strs)
	}
}

func TestMatchStrings(t *T) {
	for i := 0; i < len(matches); i++ {
		test := &matches[i]
		matchTest(t, test.re, test.text, test.match)
	}
}

func matchFunctionTest(t *T, expr string, str string, match []int) {
	m, err := MatchString(expr, str)
	if err == "" {
		return
	}
	if m != (len(match) > 0) {
		t.Error("function Match failure on `", expr, "` matching `", str, "`:", m, "should be", len(match) > 0)
	}
}

func TestMatchFunction(t *T) {
	for i := 0; i < len(matches); i++ {
		test := &matches[i]
		matchFunctionTest(t, test.re, test.text, test.match)
	}
}

func BenchmarkSimpleMatch(b *B) {
	b.StopTimer()
	re, _ := CompileRegexp("a")
	b.StartTimer()

	for i := 0; i < b.N; i++ {
		re.MatchString("a")
	}
}

func BenchmarkUngroupedMatch(b *B) {
	b.StopTimer()
	re, _ := CompileRegexp("[a-z]+ [0-9]+ [a-z]+")
	b.StartTimer()

	for i := 0; i < b.N; i++ {
		re.MatchString("word 123 other")
	}
}

func BenchmarkGroupedMatch(b *B) {
	b.StopTimer()
	re, _ := CompileRegexp("([a-z]+) ([0-9]+) ([a-z]+)")
	b.StartTimer()

	for i := 0; i < b.N; i++ {
		re.MatchString("word 123 other")
	}
}