// Copyright 2020 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 codec

import (
	"math"
	"strings"
	"testing"

	"github.com/google/go-cmp/cmp"
)

func TestLowLevelIO(t *testing.T) {
	var (
		b   byte   = 15
		bs  []byte = []byte{4, 10, 8}
		s          = "hello"
		u32 uint32 = 999
		u64 uint64 = math.MaxUint32 + 1
	)

	e := NewEncoder()
	e.writeByte(b)
	e.writeBytes(bs)
	e.writeString(s)
	e.writeUint32(u32)
	e.writeUint64(u64)

	d := NewDecoder(e.Bytes())
	d.decodeInitial()
	if got := d.readByte(); got != b {
		t.Fatalf("got %d, want %d", got, b)
	}
	if got := d.readBytes(len(bs)); !cmp.Equal(got, bs) {
		t.Fatalf("got %v, want %v", got, bs)
	}
	if got := d.readString(len(s)); got != s {
		t.Fatalf("got %q, want %q", got, s)
	}
	if got := d.readUint32(); got != u32 {
		t.Errorf("got %d, want %d", got, u32)
	}
	if got := d.readUint64(); got != u64 {
		t.Errorf("got %d, want %d", got, u64)
	}
}

func TestUint(t *testing.T) {
	e := NewEncoder()
	uints := []uint64{99, 999, math.MaxUint32 + 1}
	for _, u := range uints {
		e.EncodeUint(u)
	}
	d := NewDecoder(e.Bytes())
	d.decodeInitial()
	for _, want := range uints {
		if got := d.DecodeUint(); got != want {
			t.Errorf("got %d, want %d", got, want)
		}
	}
}

func TestInt(t *testing.T) {
	e := NewEncoder()
	ints := []int64{99, 999, math.MaxUint32 + 1, -123}
	for _, i := range ints {
		e.EncodeInt(i)
	}
	d := NewDecoder(e.Bytes())
	d.decodeInitial()
	for _, want := range ints {
		if got := d.DecodeInt(); got != want {
			t.Errorf("got %d, want %d", got, want)
		}
	}
}

func TestBasicTypes(t *testing.T) {
	e := NewEncoder()
	var (
		by = []byte{1, 2, 3}
		s  = "hello"
		b  = true
		f  = 3.14
	)
	e.EncodeBytes(by)
	e.EncodeString(s)
	e.EncodeBool(b)
	e.EncodeFloat(f)

	d := NewDecoder(e.Bytes())
	d.decodeInitial()
	gots := []interface{}{
		d.DecodeBytes(),
		d.DecodeString(),
		d.DecodeBool(),
		d.DecodeFloat(),
	}
	wants := []interface{}{by, s, b, f}
	if !cmp.Equal(gots, wants) {
		t.Errorf("got %v, want %v", gots, wants)
	}
}

func TestList(t *testing.T) {
	e := NewEncoder()
	want := []string{"Green", "eggs", "and", "ham"}
	e.StartList(len(want))
	for _, s := range want {
		e.EncodeString(s)
	}

	d := NewDecoder(e.Bytes())
	d.decodeInitial()
	n := d.StartList()
	if n < 0 {
		t.Fatal("got nil")
	}
	got := make([]string, n)
	for i := 0; i < n; i++ {
		got[i] = d.DecodeString()
	}
	if !cmp.Equal(got, want) {
		t.Errorf("got %q, want %q", got, want)
	}
}

func TestAny(t *testing.T) {
	want := []interface{}{"bar", nil, 1, -5, 98.6, uint64(1 << 63), "Luke Luck likes lakes", true}
	e := NewEncoder()
	for _, w := range want {
		e.EncodeAny(w)
	}

	d := NewDecoder(e.Bytes())
	d.decodeInitial()
	for _, w := range want {
		g := d.DecodeAny()
		if g != w {
			t.Errorf("got %v, want %v", g, w)
		}
	}
}

func TestEncodeDecode(t *testing.T) {
	want := []interface{}{"bar", nil, 1, -5, 98.6, uint64(1 << 63), "Luke Luck likes lakes", true}
	e := NewEncoder()
	for _, w := range want {
		if err := e.Encode(w); err != nil {
			t.Fatal(err)
		}
	}

	d := NewDecoder(e.Bytes())
	for _, w := range want {
		g, err := d.Decode()
		if err != nil {
			t.Fatal(err)
		}
		if g != w {
			t.Errorf("got %v, want %v", g, w)
		}
	}
}

func TestEncodeErrors(t *testing.T) {
	// The only encoding error is an unregistered type.
	e := NewEncoder()
	type MyInt int
	checkMessage(t, e.Encode(MyInt(0)), "unregistered")
}

func TestDecodeErrors(t *testing.T) {
	for _, test := range []struct {
		offset  int
		change  byte
		message string
	}{
		// d.buf[d.i:] should look like: nValues 2 0 nBytes 4 ...
		// Induce errors by changing some bytes.
		{0, startCode, "bad code"},   // mess with the initial code
		{1, 5, "bad list length"},    // mess with the list length
		{2, 1, "out of range"},       // mess with the type number
		{3, nValuesCode, "bad code"}, // mess with the uint code
		{4, 5, "bad length"},         // mess with the uint length
	} {
		d := NewDecoder(mustEncode(t, uint64(3000)))
		d.decodeInitial()
		d.buf[d.i+test.offset] = test.change
		_, err := d.Decode()
		checkMessage(t, err, test.message)
	}
}

func mustEncode(t *testing.T, x interface{}) []byte {
	t.Helper()
	e := NewEncoder()
	if err := e.Encode(x); err != nil {
		t.Fatal(err)
	}
	return e.Bytes()
}

func checkMessage(t *testing.T, err error, target string) {
	t.Helper()
	if err == nil {
		t.Error("want error, got nil")
	}
	if !strings.Contains(err.Error(), target) {
		t.Errorf("error %q does not contain %q", err, target)
	}
}

func TestSkip(t *testing.T) {
	e := NewEncoder()
	values := []interface{}{
		1,
		false,
		"yes",
		"no",
		65000,
	}
	for _, v := range values {
		if err := e.Encode(v); err != nil {
			t.Fatal(err)
		}
	}

	d := NewDecoder(e.Bytes())
	// Skip odd indexes.
	for i, want := range values {
		if i%2 == 0 {
			got, err := d.Decode()
			if err != nil {
				t.Fatal(err)
			}
			if !cmp.Equal(got, want) {
				t.Errorf("got %v, want %v", got, want)
			}
		} else {
			d.skip()
		}
	}
}

type node struct {
	Value int
	Next  *node
}

func TestSharing(t *testing.T) {
	n := &node{Value: 1, Next: &node{Value: 2}}
	n.Next.Next = n // create a cycle
	d := NewDecoder(mustEncode(t, n))
	g, err := d.Decode()
	if err != nil {
		t.Fatal(err)
	}
	got := g.(*node)
	if !cmp.Equal(got, n) {
		t.Error("did not preserve cycle")
	}
}

// The following three functions were generated with
//   Generate(os.Stdout, "p", node{})
// and pasted here. They should be kept in sync
// with the output of Generate.
func encode_node(e *Encoder, x *node) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Value != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.Value))
	}
	if x.Next != nil {
		e.EncodeUint(1)
		encode_node(e, x.Next)
	}
	e.EndStruct()
}

func decode_node(d *Decoder, p **node) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*node)
		return
	}
	var x node
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.Value = int(d.DecodeInt())
		case 1:
			decode_node(d, &x.Next)

		default:
			d.UnknownField("node", n)
		}
		*p = &x
	}
}

func init() {
	Register(&node{},
		func(e *Encoder, x interface{}) { encode_node(e, x.(*node)) },
		func(d *Decoder) interface{} {
			var x *node
			decode_node(d, &x)
			return x
		})
}