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

// Binary i18n_test tests message catalogues.

package i18n

import "strings"
import "testing"
import "v.io/v23/context"

// testLookupSetAndRemove tests Lookup, Set, and Set-to-empty on *cat.
func testLookupSetAndRemove(t *testing.T, cat *Catalogue, catName string) {
	want := "expected format"
	expectLookup(t, cat, "", "en", "bar", catName+" 1")
	expectLookup(t, cat, "", "en-US", "bar", catName+" 2")
	expectLookup(t, cat, "", "en", "foo", catName+" 3")
	expectLookup(t, cat, "", "en-US", "foo", catName+" 4")
	if cat.Set(LangID("en-US"), MsgID("bar"), want) != "" {
		t.Errorf("Set found en-US/bar in %s catalogue", catName)
	}
	if cat.SetWithBase(LangID("en-US"), MsgID("foo"), want) != "" {
		t.Errorf("Set found en-US/foo in %s catalogue", catName)
	}
	expectLookup(t, cat, "", "en", "bar", catName+" 5")
	expectLookup(t, cat, want, "en-US", "bar", catName+" 6")
	expectLookup(t, cat, want, "en", "foo", catName+" 7")
	expectLookup(t, cat, want, "en-US", "foo", catName+" 8")
	// Check that Set(..., "") doesn't delete the base entry.
	if cat.Set(LangID("en"), MsgID("bar"), "other format") != "" {
		t.Errorf("Set found en/bar in %s catalogue", catName)
	}
	if cat.Set(LangID("en-US"), MsgID("bar"), "") != want {
		t.Errorf("Set didn't find en-US/bar in %s catalogue", catName)
	}
	if cat.SetWithBase(LangID("en-US"), MsgID("foo"), "") != want {
		t.Errorf("Set didn't find en-US/foo in %s catalogue", catName)
	}
	// The previous SetWithBase will not have removed the base entry.
	if cat.Set(LangID("en"), MsgID("foo"), "") != want {
		t.Errorf("Set didn't find en/foo in %s catalogue", catName)
	}
	expectLookup(t, cat, "other format", "en", "bar", catName+" 9")
	// Test that a lookup of en-US finds the "en" entry.
	expectLookup(t, cat, "other format", "en-US", "bar", catName+" 10")
	if cat.Set(LangID("en"), MsgID("bar"), "") != "other format" {
		t.Errorf("Set didn't find en/bar in %s catalogue", catName)
	}
	expectLookup(t, cat, "", "en", "bar", catName+" 11")
	expectLookup(t, cat, "", "en-US", "bar", catName+" 12")
	expectLookup(t, cat, "", "en", "foo", catName+" 13")
	expectLookup(t, cat, "", "en-US", "foo", catName+" 14")
}

// testLookupSetAndRemove tests Lookup, Set, and Set-to-empty on
// a newly created catalogue.
func TestLookupSetAndRemove(t *testing.T) {
	testLookupSetAndRemove(t, new(Catalogue), "new")
}

// TestDefaultCatalogue verifies that the default Catalogue behaves like a
// catalogue and is the same whenever it's invoked.
func TestDefaultCatalogue(t *testing.T) {
	cat := Cat()
	if cat != Cat() {
		t.Errorf("got different default Catalogue")
	}
	testLookupSetAndRemove(t, cat, "default")
	if cat != Cat() {
		t.Errorf("got different default Catalogue")
	}
}

// expectFormatParams verifies that FormatParams(format, v...) generates
// want.
func expectFormatParams(t *testing.T, want string, format string, v ...interface{}) {
	got := FormatParams(format, v...)
	if want != got {
		t.Errorf("FormatParams(%q, %v): got %q, want %q", format, v, got, want)
	}
}

// TestFormatParams tests the FormatParams() call with various arguments
func TestFormatParams(t *testing.T) {
	expectFormatParams(t, "", "", "1st")
	expectFormatParams(t, "", "{_}")
	expectFormatParams(t, "? ? ? ? ? ?", "{0} {1} {2} {3} {4} {5}")
	expectFormatParams(t, "{ foo }?", "{ foo }{2}")
	expectFormatParams(t, "3rd: foo 2nd bar 1st 4th (3rd)",
		"{3}: foo {2} bar {_} ({3})", "1st", "2nd", "3rd", "4th")
	expectFormatParams(t, "?: foo 4th ?",
		"{0}: foo {4} {5}", "1st", "2nd", "3rd", "4th")
	expectFormatParams(t, " foo 1st 2nd 3rd 4th{-1}",
		"{_} foo {_}{-1}", "1st", "2nd", "3rd", "4th")
	expectFormatParams(t, "{ foo }2nd",
		"{ foo }{2}", "1st", "2nd", "3rd", "4th")

	// Test the formatting of colon-formats.
	expectFormatParams(t, "", "{:_}")
	expectFormatParams(t, "", "{_:}")
	expectFormatParams(t, "", "{:_:}")

	expectFormatParams(t, ": 1st 2nd", "{:_}", "1st", "2nd")
	expectFormatParams(t, "1st 2nd:", "{_:}", "1st", "2nd")
	expectFormatParams(t, ": 1st 2nd:", "{:_:}", "1st", "2nd")

	expectFormatParams(t, "", "{:_}", "")
	expectFormatParams(t, "", "{_:}", "")
	expectFormatParams(t, "", "{:_:}", "")

	expectFormatParams(t, ": 1st", "{:1}", "1st")
	expectFormatParams(t, "1st:", "{1:}", "1st")
	expectFormatParams(t, ": 1st:", "{:1:}", "1st")

	expectFormatParams(t, "", "{:1}", "")
	expectFormatParams(t, "", "{1:}", "")
	expectFormatParams(t, "", "{:1:}", "")

	expectFormatParams(t, "?: ? ?: ?: ?: ?", "{0}{:1} {2:} {3}{:4:} {5}")

	expectFormatParams(t, "{: foo }?", "{: foo }{2}")
	expectFormatParams(t, "{ foo :}?", "{ foo :}{2}")
	expectFormatParams(t, "{: foo :}?", "{: foo :}{2}")

	expectFormatParams(t, "3rd: foo 2nd bar: 1st 4th (3rd)",
		"{3:} foo {2} bar{:_} ({3})", "1st", "2nd", "3rd", "4th")

	expectFormatParams(t, "?: foo: 4th ?",
		"{0:} foo{:4} {5}", "1st", "2nd", "3rd", "4th")

	expectFormatParams(t, " foo: 1st 2nd 3rd 4th{-1}",
		"{_:} foo{:_}{-1}", "1st", "2nd", "3rd", "4th")

	expectFormatParams(t, "{ foo }: 2nd",
		"{4:}{ foo }{:2}", "1st", "2nd", "3rd", "")

	expectFormatParams(t, "1st foo 2nd: bar: 3rd wombat: 4th: numbat",
		"{1} foo {2:} bar{:3} wombat{:4:} numbat",
		"1st", "2nd", "3rd", "4th")

	expectFormatParams(t, " foo  bar wombat numbat",
		"{1} foo {2:} bar{:3} wombat{:4:} numbat",
		"", "", "", "")
}

var mergeData string = `# In what follows we use the "languages" "fwd" and "back".
fwd foo "{1} foo to {2}"
# Next line has a missing trailing double quote, so will be ignored.
 back   foo   "{2} from foo {1}

# Comment "quote"

# The following two lines are ignored, since each has fewer than three tokens.
one
one two

fwd 	bar "{1} bar to {2}"
back bar "{2} from bar {1}" extraneous word

back funny.msg.id "{2} from funny msg id {1}"
odd.lang.id funny.msg.id "odd and\b \"funny\""
`

// expectLookup verifies that cat.Lookup(lang, msg)==want
func expectLookup(t *testing.T, cat *Catalogue, want string,
	lang string, msg string, tag string) {

	got := cat.Lookup(LangID(lang), MsgID(msg))
	if want != got {
		t.Errorf("%s: cat.Lookup(%s, %s): got %q, want %q",
			tag, lang, msg, got, want)
	}
}

// expectInMap verifies that m[s]==true.
func expectInMap(t *testing.T, m map[string]bool, s string) {
	if !m[s] {
		t.Errorf("m[%#v]==false; want true", s)
	}
}

// A writableString can be appended to via the Writer interface.
type writeableString struct {
	s string
}

// Write writes p to the the target string.
func (ws *writeableString) Write(p []byte) (n int, err error) {
	ws.s += string(p)
	return len(p), nil
}

// TestMerge tests the Merge() call.
func TestMergeAndOutput(t *testing.T) {
	cat := new(Catalogue)

	// Check that Merge() works.
	cat.Merge(strings.NewReader(mergeData))
	expectLookup(t, cat, "{1} foo to {2}", "fwd", "foo", "1")
	expectLookup(t, cat, "", "back", "foo", "2")
	expectLookup(t, cat, "{1} bar to {2}", "fwd", "bar", "3")
	expectLookup(t, cat, "{2} from bar {1}", "back", "bar", "4")
	expectLookup(t, cat, "{2} from funny msg id {1}", "back", "funny.msg.id", "5")
	expectLookup(t, cat, "odd and\b \"funny\"", "odd.lang.id", "funny.msg.id", "6")

	// Verify that the result of Output is as expected.
	var ws writeableString
	err := cat.Output(&ws)
	if err != nil {
		t.Errorf("error from cat.Output(): %v", err)
	}

	m := make(map[string]bool)
	for _, line := range strings.Split(ws.s, "\n") {
		if line != "" {
			m[line] = true
		}
	}
	expectInMap(t, m, "fwd foo \"{1} foo to {2}\"")
	expectInMap(t, m, "fwd bar \"{1} bar to {2}\"")
	expectInMap(t, m, "back bar \"{2} from bar {1}\"")
	expectInMap(t, m, "back funny.msg.id \"{2} from funny msg id {1}\"")
	expectInMap(t, m, "odd.lang.id funny.msg.id \"odd and\\b \\\"funny\\\"\"")
	if want := 5; len(m) != want {
		t.Errorf("wrong number of lines in <%s>; got %d, want %d ", ws.s, len(m), want)

	}
}

// expectNormalizeLangID verifies that NormalizeLangID(input)==want.
func expectNormalizeLangID(t *testing.T, input string, want LangID) {
	got := NormalizeLangID(input)
	if got != want {
		t.Errorf("NormalizeLangID(%s) got %q, want %q", input, got, want)
	}
}

// TestNormalizeLangID tests NormalizeLangID().
func TestNormalizeLangID(t *testing.T) {
	expectNormalizeLangID(t, "en", "en")
	expectNormalizeLangID(t, "en-US", "en-US")
	expectNormalizeLangID(t, "en_US", "en-US")
}

// expectBaseLangID verifies that BaseLangID(input)==want.
func expectBaseLangID(t *testing.T, input LangID, want LangID) {
	got := BaseLangID(input)
	if got != want {
		t.Errorf("BaseLangID(%s) got %q, want %q", input, got, want)
	}
}

// TestBaseLangID tests BaseLangID().
func TestBaseLangID(t *testing.T) {
	expectBaseLangID(t, "en", "en")
	expectBaseLangID(t, "en-US", "en")
}

func testContext() *context.T {
	ctx, _ := context.RootContext()
	return ctx
}

// TestGetWithLangID tests GetLangID() and WithLangID.
func TestGetWithLangID(t *testing.T) {
	var dcWithoutLangID *context.T = testContext()
	dcWithEN := WithLangID(dcWithoutLangID, "en")
	dcWithFR := WithLangID(dcWithEN, "fr")
	var got LangID

	got = GetLangID(dcWithoutLangID)
	if got != NoLangID {
		t.Errorf("GetLangID(dcWithoutLangID); got %v, want \"\"", got)
	}

	got = GetLangID(dcWithEN)
	if got != LangID("en") {
		t.Errorf("GetLangID(dcWithEN); got %v, want \"en\"", got)
	}

	got = GetLangID(dcWithFR)
	if got != LangID("fr") {
		t.Errorf("GetLangID(dcWithFR); got %v, want \"fr\"", got)
	}
}