// 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.

package verror_test

import (
	"errors"
	"fmt"
	"runtime"
	"strings"
	"testing"

	"v.io/v23/i18n"
	"v.io/v23/verror"
	"v.io/v23/vtrace"

	_ "v.io/x/ref/runtime/factories/roaming"
	"v.io/x/ref/test"
)

var (
	// Some error IDActions.
	idActionA = verror.IDAction{
		ID:     "A",
		Action: verror.NoRetry,
	}
	idActionB = verror.IDAction{
		ID:     "B",
		Action: verror.RetryBackoff,
	}
	idActionC = verror.IDAction{
		ID:     "C",
		Action: verror.NoRetry,
	}

	// Some languages
	en = i18n.LangID("en")
	fr = i18n.LangID("fr")
	de = i18n.LangID("de")
)

var (
	aEN0 error
	aEN1 error
	aFR0 error
	aFR1 error
	aDE0 error
	aDE1 error

	bEN0 error
	bEN1 error
	bFR0 error
	bFR1 error
	bDE0 error
	bDE1 error

	uEN0 error
	uEN1 error
	uFR0 error
	uFR1 error
	uDE0 error
	uDE1 error

	nEN0 error
	nEN1 error
	nFR0 error
	nFR1 error
	nDE0 error
	nDE1 error

	gEN error
	gFR error
	gDE error

	v2EN  error
	v2FR0 error
	v2FR1 error
	v2DE  error
)

// This function comes first because it has line numbers embedded in it, and putting it first
// reduces the chances that its line numbers will change.
func TestSubordinateErrors(t *testing.T) {
	p := verror.ExplicitNew(idActionA, en, "server", "aEN0", 0)
	p1 := verror.AddSubErrs(p, nil, verror.SubErr{
		Name:    "a=1",
		Err:     aEN1,
		Options: verror.Print,
	}, verror.SubErr{
		Name:    "a=2",
		Err:     aFR0,
		Options: verror.Print,
	})
	r1 := "server aEN0 error A 0 [a=1: server aEN1 error A 1 2], [a=2: server aFR0 erreur A 0]"
	if got, want := p1.Error(), r1; got != want {
		t.Errorf("got %q, want %q", got, want)
	}
	p2 := verror.AddSubErrs(p, nil, verror.SubErr{
		Name:    "go_err=1",
		Err:     fmt.Errorf("Oh"),
		Options: verror.Print,
	})
	r2 := "server aEN0 error A 0 [go_err=1: verror.test  unknown error Oh]"
	if got, want := p2.Error(), r2; got != want {
		t.Errorf("got %q, want %q", got, want)
	}
	p2str := verror.DebugString(p2)
	if !strings.Contains(p2str, r2) {
		t.Errorf("debug string missing error message: %q, %q", p2str, r2)
	}
	if !strings.Contains(p2str, "verror_test.go:85") {
		t.Errorf("debug string missing correct line #: %s", p2str)
	}
	// When Go1.4 generates stack traces, it reports the last line of the
	// expression. Go1.5 reports the first line. We check for both so the
	// test passes on either version.
	if !strings.Contains(p2str, "verror_test.go:99") && !strings.Contains(p2str, "verror_test.go:103") {
		t.Errorf("debug string missing correct line #: %s", p2str)
	}
	p3 := verror.AddSubErrs(p, nil, verror.SubErr{
		Name:    "go_err=2",
		Err:     fmt.Errorf("Oh"),
		Options: 0,
	})
	r3 := "server aEN0 error A 0 "
	if got, want := p3.Error(), r3; got != want {
		t.Errorf("got %q, want %q", got, want)
	}
}

// This function comes first because it has line numbers embedded in it, and putting it first
// reduces the chances that its line numbers will change.
func TestChained(t *testing.T) {
	first := verror.IDAction{
		ID:     "first",
		Action: verror.NoRetry,
	}
	second := verror.IDAction{
		ID:     "second",
		Action: verror.NoRetry,
	}
	third := verror.IDAction{
		ID:     "third",
		Action: verror.NoRetry,
	}
	cat := i18n.Cat()
	cat.Set(en, i18n.MsgID(first.ID), "first {_}")
	cat.Set(en, i18n.MsgID(second.ID), "second {3}")
	cat.Set(en, i18n.MsgID(third.ID), "{3}")

	l1 := verror.ExplicitNew(third, en, "", "", "third")
	if got, want := len(verror.Stack(l1)), 3; got != want {
		t.Fatalf("got %v, want %v", got, want)
	}
	l2 := verror.ExplicitNew(second, en, "", "", l1)
	if got, want := len(verror.Stack(l2)), 7; got != want {
		t.Fatalf("got %v, want %v", got, want)
	}
	l3 := verror.ExplicitNew(first, en, "", "", "not first", l2, l1)
	if got, want := len(verror.Stack(l3)), 11; got != want {
		t.Fatalf("got %v, want %v", got, want)
	}
	lines := strings.Split(verror.Stack(l3).String(), "\n")
	if got, want := lines[0], "verror_test.go:160"; !strings.Contains(got, want) {
		t.Fatalf("%q, doesn't contain %q", got, want)
	}
	if got, want := lines[4], "verror_test.go:156"; !strings.Contains(got, want) {
		t.Fatalf("%q, doesn't contain %q", got, want)
	}
	if got, want := lines[8], "verror_test.go:152"; !strings.Contains(got, want) {
		t.Fatalf("%q, doesn't contain %q", got, want)
	}
	for _, i := range []int{3, 7} {
		if got, want := lines[i], "----- chained verror -----"; got != want {
			t.Fatalf("got %v, want %v", got, want)
		}
	}
	l1s := l1.Error()
	l2s := l2.Error()
	if got, want := l3.Error(), "first   not first "+l2s+" "+l1s; got != want {
		t.Fatalf("got %v, want %v", got, want)
	}
}

func init() {
	rootCtx, shutdown := test.V23Init()
	defer shutdown()

	def := i18n.WithLangID(rootCtx, en)
	def = verror.WithComponentName(def, "verror.test")
	verror.SetDefaultContext(def)

	cat := i18n.Cat()
	// Set messages for English and French.  Do not set messages for
	// German, to test the case where the messages are not present.
	cat.Set(en, i18n.MsgID(idActionA.ID), "{1} {2} error A {_}")
	cat.Set(fr, i18n.MsgID(idActionA.ID), "{1} {2} erreur A {_}")

	cat.Set(en, i18n.MsgID(idActionB.ID), "{1} {2} problem B {_}")
	cat.Set(fr, i18n.MsgID(idActionB.ID), "{1} {2} problème B {_}")

	// Set English and French messages for Unknown and NoExist
	// to ones the test can predict.
	// Delete any German messages that may be present.
	cat.Set(en, i18n.MsgID(verror.ErrUnknown.ID), "{1} {2} unknown error {_}")
	cat.Set(fr, i18n.MsgID(verror.ErrUnknown.ID), "{1} {2} erreur inconnu {_}")
	cat.Set(de, i18n.MsgID(verror.ErrUnknown.ID), "")

	cat.Set(en, i18n.MsgID(verror.ErrNoExist.ID), "{1} {2} not found {_}")
	cat.Set(fr, i18n.MsgID(verror.ErrNoExist.ID), "{1} {2} pas trouvé {_}")
	cat.Set(de, i18n.MsgID(verror.ErrNoExist.ID), "")

	// Set up a context that advertises French, on a server called FooServer,
	// running an operation called aFR0.
	ctx := i18n.WithLangID(rootCtx, fr)
	ctx = verror.WithComponentName(ctx, "FooServer")
	ctx, _ = vtrace.WithNewSpan(ctx, "aFR1")

	// A first IDAction in various languages.
	aEN0 = verror.ExplicitNew(idActionA, en, "server", "aEN0", 0)
	aEN1 = verror.ExplicitNew(idActionA, en, "server", "aEN1", 1, 2)
	aFR0 = verror.ExplicitNew(idActionA, fr, "server", "aFR0", 0)
	aFR1 = verror.New(idActionA, ctx, 1, 2)
	aDE0 = verror.ExplicitNew(idActionA, de, "server", "aDE0", 0)
	aDE1 = verror.ExplicitNew(idActionA, de, "server", "aDE1", 1, 2)

	// A second IDAction in various languages.
	bEN0 = verror.ExplicitNew(idActionB, en, "server", "bEN0", 0)
	bEN1 = verror.ExplicitNew(idActionB, en, "server", "bEN1", 1, 2)
	bFR0 = verror.ExplicitNew(idActionB, fr, "server", "bFR0", 0)
	bFR1 = verror.ExplicitNew(idActionB, fr, "server", "bFR1", 1, 2)
	bDE0 = verror.ExplicitNew(idActionB, de, "server", "bDE0", 0)
	bDE1 = verror.ExplicitNew(idActionB, de, "server", "bDE1", 1, 2)

	// The Unknown error in various languages.
	uEN0 = verror.ExplicitNew(verror.ErrUnknown, en, "server", "uEN0", 0)
	uEN1 = verror.ExplicitNew(verror.ErrUnknown, en, "server", "uEN1", 1, 2)
	uFR0 = verror.ExplicitNew(verror.ErrUnknown, fr, "server", "uFR0", 0)
	uFR1 = verror.ExplicitNew(verror.ErrUnknown, fr, "server", "uFR1", 1, 2)
	uDE0 = verror.ExplicitNew(verror.ErrUnknown, de, "server", "uDE0", 0)
	uDE1 = verror.ExplicitNew(verror.ErrUnknown, de, "server", "uDE1", 1, 2)

	// The NoExist error in various languages.
	nEN0 = verror.ExplicitNew(verror.ErrNoExist, en, "server", "nEN0", 0)
	nEN1 = verror.ExplicitNew(verror.ErrNoExist, en, "server", "nEN1", 1, 2)
	nFR0 = verror.ExplicitNew(verror.ErrNoExist, fr, "server", "nFR0", 0)
	nFR1 = verror.ExplicitNew(verror.ErrNoExist, fr, "server", "nFR1", 1, 2)
	nDE0 = verror.ExplicitNew(verror.ErrNoExist, de, "server", "nDE0", 0)
	nDE1 = verror.ExplicitNew(verror.ErrNoExist, de, "server", "nDE1", 1, 2)

	// Errors derived from Go errors.
	gerr := errors.New("Go error")
	gEN = verror.ExplicitConvert(verror.ErrUnknown, en, "server", "op", gerr)
	gFR = verror.ExplicitConvert(verror.ErrUnknown, fr, "server", "op", gerr)
	gDE = verror.ExplicitConvert(verror.ErrUnknown, de, "server", "op", gerr)

	// Errors derived from other verror errors.
	// eEN1 has an English message.
	v2EN = verror.ExplicitConvert(verror.ErrUnknown, en, "", "", aEN1)        // still in English.
	v2FR0 = verror.ExplicitConvert(verror.ErrUnknown, fr, "", "", aEN1)       // converted to French, with original server and op.
	v2FR1 = verror.Convert(verror.ErrUnknown, ctx, aEN1)                      // converted to French, but still with param[1]==aEN1.
	v2DE = verror.ExplicitConvert(verror.ErrUnknown, de, "other", "op", aEN1) // left as English, since we lack German.
}

func TestDefaultValues(t *testing.T) {
	if got, want := verror.ErrorID(nil), verror.ID(""); got != want {
		t.Errorf("got: %v, want: %v", got, want)
	}
	if got, want := verror.Action(nil), verror.NoRetry; got != want {
		t.Errorf("got: %v, want: %v", got, want)
	}

	if got, want := verror.ErrorID(verror.E{}), verror.ID(""); got != want {
		t.Errorf("got: %v, want: %v", got, want)
	}
	if got, want := verror.Action(verror.E{}), verror.NoRetry; got != want {
		t.Errorf("got: %v, want: %v", got, want)
	}

	unknown := verror.ExplicitNew(verror.ErrUnknown, i18n.NoLangID, "", "")
	if got, want := verror.ErrorID(unknown), verror.ErrUnknown.ID; got != want {
		t.Errorf("got: %v, want: %v", got, want)
	}
	if got, want := verror.Action(unknown), verror.NoRetry; got != want {
		t.Errorf("got: %v, want: %v", got, want)
	}
}

func TestBasic(t *testing.T) {
	var tests = []struct {
		err      error
		idAction verror.IDAction
		msg      string
	}{
		{aEN0, idActionA, "server aEN0 error A 0"},
		{aEN1, idActionA, "server aEN1 error A 1 2"},
		{aFR0, idActionA, "server aFR0 erreur A 0"},
		{aFR1, idActionA, "FooServer aFR1 erreur A 1 2"},
		{aDE0, idActionA, "A: server aDE0 0"},
		{aDE1, idActionA, "A: server aDE1 1 2"},

		{bEN0, idActionB, "server bEN0 problem B 0"},
		{bEN1, idActionB, "server bEN1 problem B 1 2"},
		{bFR0, idActionB, "server bFR0 problème B 0"},
		{bFR1, idActionB, "server bFR1 problème B 1 2"},
		{bDE0, idActionB, "B: server bDE0 0"},
		{bDE1, idActionB, "B: server bDE1 1 2"},

		{nEN0, verror.ErrNoExist, "server nEN0 not found 0"},
		{nEN1, verror.ErrNoExist, "server nEN1 not found 1 2"},
		{nFR0, verror.ErrNoExist, "server nFR0 pas trouvé 0"},
		{nFR1, verror.ErrNoExist, "server nFR1 pas trouvé 1 2"},
		{nDE0, verror.ErrNoExist, "v.io/v23/verror.NoExist: server nDE0 0"},
		{nDE1, verror.ErrNoExist, "v.io/v23/verror.NoExist: server nDE1 1 2"},

		{gEN, verror.ErrUnknown, "server op unknown error Go error"},
		{gFR, verror.ErrUnknown, "server op erreur inconnu Go error"},
		{gDE, verror.ErrUnknown, "v.io/v23/verror.Unknown: server op Go error"},

		{v2EN, idActionA, "server aEN1 error A 1 2"},
		{v2FR0, idActionA, "server aEN1 erreur A 1 2"},
		{v2FR1, idActionA, "server aEN1 erreur A 1 2"},
		{v2DE, idActionA, "server aEN1 error A 1 2"},
	}

	for i, test := range tests {
		if got, want := verror.ErrorID(test.err), test.idAction.ID; got != want {
			t.Errorf("%d: ErrorID(%#v); got %v, want %v", i, test.err, got, want)
		}
		if got, nowant := verror.ErrorID(test.err), idActionC.ID; got == nowant {
			t.Errorf("%d: ErrorID(%#v); got %v, nowant %v", i, test.err, got, nowant)
		}
		if got, want := verror.Action(test.err), test.idAction.Action; got != want {
			t.Errorf("%d: Action(%#v); got %v, want %v", i, test.err, got, want)
		}
		if got, want := test.err.Error(), test.msg; got != want {
			t.Errorf("%d: %#v.Error(); got %q, want %q", i, test.err, got, want)
		}

		stack := verror.Stack(test.err)
		if stack == nil {
			t.Errorf("Stack(%q) got nil, want non-nil", verror.ErrorID(test.err))
		} else if len(stack) < 1 || 10 < len(stack) {
			t.Errorf("len(Stack(%q)) got %d, want between 1 and 10", verror.ErrorID(test.err), len(stack))
		} else {
			fnc := runtime.FuncForPC(stack[0])
			if !strings.Contains(fnc.Name(), "verror_test.init") {
				t.Errorf("Func.Name(Stack(%q)[0]) got %q, want \"verror.init\"",
					verror.ErrorID(test.err), fnc.Name())
			}
		}
	}
}

func tester() (error, error) {
	l1 := verror.ExplicitNew(idActionA, en, "server", "aEN0", 0)
	return l1, verror.ExplicitNew(idActionA, en, "server", "aEN0", 1)
}

func TestStack(t *testing.T) {
	l1, l2 := tester()
	stack1 := verror.Stack(l1).String()
	stack2 := verror.Stack(l2).String()
	if stack1 == stack2 {
		t.Errorf("expected %q and %q to differ", stack1, stack2)
	}
	for _, stack := range []string{stack1, stack2} {
		if got := strings.Count(stack, "\n"); got < 1 || 10 < got {
			t.Errorf("got %d, want between 1 and 10", got)
		}
		if !strings.Contains(stack, "verror_test.tester") {
			t.Errorf("got %q, doesn't contain 'verror_test.tester", stack)
		}
	}
}