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

// TODO(toddw): Merge with vdl/testutil_test.go.

import (
	"fmt"
	"strings"
	"testing"

	"v.io/v23/vdl"
)

// CallAndRecover calls the function f and returns the result of recover().
// This minimizes the scope of the deferred recover, to ensure f is actually the
// function that paniced.
func CallAndRecover(f func()) (result interface{}) {
	defer func() {
		result = recover()
	}()
	f()
	return
}

func expectErr(t *testing.T, err error, wantstr string, format string, args ...interface{}) bool {
	gotstr := fmt.Sprint(err)
	msg := fmt.Sprintf(format, args...)
	if wantstr != "" && !strings.Contains(gotstr, wantstr) {
		t.Errorf(`%s got error %q, want substr %q`, msg, gotstr, wantstr)
		return false
	}
	if wantstr == "" && err != nil {
		t.Errorf(`%s got error %q, want nil`, msg, gotstr)
		return false
	}
	return true
}

func expectPanic(t *testing.T, f func(), wantstr string, format string, args ...interface{}) {
	got := CallAndRecover(f)
	gotstr := fmt.Sprint(got)
	msg := fmt.Sprintf(format, args...)
	if wantstr != "" && !strings.Contains(gotstr, wantstr) {
		t.Errorf(`%s got panic %q, want substr %q`, msg, gotstr, wantstr)
	}
	if wantstr == "" && got != nil {
		t.Errorf(`%s got panic %q, want nil`, msg, gotstr)
	}
}

func expectMismatchedKind(t *testing.T, f func()) {
	expectPanic(t, f, "mismatched kind", "")
}

// Define a bunch of regular Go types used in tests.
type (
	// Scalars
	nInterface interface{}
	nType      *vdl.Type
	nBool      bool
	nUint8     uint8
	nUint16    uint16
	nUint32    uint32
	nUint64    uint64
	nUint      uint
	nUintptr   uintptr
	nInt8      int8
	nInt16     int16
	nInt32     int32
	nInt64     int64
	nInt       int
	nFloat32   float32
	nFloat64   float64
	nString    string
	// Arrays
	nArray3Interface  [3]nInterface
	nArray3TypeObject [3]*vdl.Type
	nArray3Bool       [3]bool
	nArray3Uint8      [3]uint8
	nArray3Uint16     [3]uint16
	nArray3Uint32     [3]uint32
	nArray3Uint64     [3]uint64
	nArray3Uint       [3]uint
	nArray3Uintptr    [3]uintptr
	nArray3Int8       [3]int8
	nArray3Int16      [3]int16
	nArray3Int32      [3]int32
	nArray3Int64      [3]int64
	nArray3Int        [3]int
	nArray3Float32    [3]float32
	nArray3Float64    [3]float64
	nArray3String     [3]string
	// Structs
	nStructInterface  struct{ X nInterface }
	nStructTypeObject struct{ X *vdl.Type }
	nStructBool       struct{ X bool }
	nStructUint8      struct{ X uint8 }
	nStructUint16     struct{ X uint16 }
	nStructUint32     struct{ X uint32 }
	nStructUint64     struct{ X uint64 }
	nStructUint       struct{ X uint }
	nStructUintptr    struct{ X uintptr }
	nStructInt8       struct{ X int8 }
	nStructInt16      struct{ X int16 }
	nStructInt32      struct{ X int32 }
	nStructInt64      struct{ X int64 }
	nStructInt        struct{ X int }
	nStructFloat32    struct{ X float32 }
	nStructFloat64    struct{ X float64 }
	nStructString     struct{ X string }
	// Slices
	nSliceInterface  []nInterface
	nSliceTypeObject []*vdl.Type
	nSliceBool       []bool
	nSliceUint8      []uint8
	nSliceUint16     []uint16
	nSliceUint32     []uint32
	nSliceUint64     []uint64
	nSliceUint       []uint
	nSliceUintptr    []uintptr
	nSliceInt8       []int8
	nSliceInt16      []int16
	nSliceInt32      []int32
	nSliceInt64      []int64
	nSliceInt        []int
	nSliceFloat32    []float32
	nSliceFloat64    []float64
	nSliceString     []string
	// Sets
	nSetInterface  map[nInterface]struct{}
	nSetTypeObject map[*vdl.Type]struct{}
	nSetBool       map[bool]struct{}
	nSetUint8      map[uint8]struct{}
	nSetUint16     map[uint16]struct{}
	nSetUint32     map[uint32]struct{}
	nSetUint64     map[uint64]struct{}
	nSetUint       map[uint]struct{}
	nSetUintptr    map[uintptr]struct{}
	nSetInt8       map[int8]struct{}
	nSetInt16      map[int16]struct{}
	nSetInt32      map[int32]struct{}
	nSetInt64      map[int64]struct{}
	nSetInt        map[int]struct{}
	nSetFloat32    map[float32]struct{}
	nSetFloat64    map[float64]struct{}
	nSetString     map[string]struct{}
	// Maps
	nMapInterface  map[nInterface]nInterface
	nMapTypeObject map[*vdl.Type]*vdl.Type
	nMapBool       map[bool]bool
	nMapUint8      map[uint8]uint8
	nMapUint16     map[uint16]uint16
	nMapUint32     map[uint32]uint32
	nMapUint64     map[uint64]uint64
	nMapUint       map[uint]uint
	nMapUintptr    map[uintptr]uintptr
	nMapInt8       map[int8]int8
	nMapInt16      map[int16]int16
	nMapInt32      map[int32]int32
	nMapInt64      map[int64]int64
	nMapInt        map[int]int
	nMapFloat32    map[float32]float32
	nMapFloat64    map[float64]float64
	nMapString     map[string]string
	// Recursive types
	nRecurseSelf struct{ X []nRecurseSelf }
	nRecurseA    struct{ B []nRecurseB }
	nRecurseB    struct{ A []nRecurseA }

	// Composite types representing sets of numbers.
	nMapUint64Empty  map[nUint64]struct{}
	nMapInt64Empty   map[nUint64]struct{}
	nMapFloat64Empty map[nUint64]struct{}
	nMapUint64Bool   map[nUint64]nBool
	nMapInt64Bool    map[nInt64]nBool
	nMapFloat64Bool  map[nFloat64]nBool
	// Composite types representing sets of strings.
	nMapStringEmpty map[nString]struct{}
	nMapStringBool  map[nString]nBool
	nStructXYZBool  struct{ X, Y, Z nBool }
	nStructWXBool   struct{ W, X nBool }
	// Composite types representing maps of strings to numbers.
	nMapStringUint64  map[nString]nUint64
	nMapStringInt64   map[nString]nInt64
	nMapStringFloat64 map[nString]nFloat64
	nStructVWXUint64  struct{ V, W, X nUint64 }
	nStructVWXInt64   struct{ V, W, X nInt64 }
	nStructVWXFloat64 struct{ V, W, X nFloat64 }
	nStructUVUint64   struct{ U, V nUint64 }
	nStructUVInt64    struct{ U, V nInt64 }
	nStructUVFloat64  struct{ U, V nFloat64 }
	// Types that cannot be converted to sets.  We represent sets as
	// map[key]struct{} on the Go side, but don't allow map[key]nEmpty.
	nEmpty           struct{}
	nMapStringnEmpty map[nString]nEmpty
	nStructXYZEmpty  struct{ X, Y, Z struct{} }
	nStructXYZnEmpty struct{ X, Y, Z nEmpty }
)

func recurseSelfType() *vdl.Type {
	var builder vdl.TypeBuilder
	n := builder.Named("v.io/v23/vdl.nRecurseSelf")
	n.AssignBase(builder.Struct().AppendField("X", builder.List().AssignElem(n)))
	builder.Build()
	t, err := n.Built()
	if err != nil {
		panic(err)
	}
	return t
}

func recurseABTypes() [2]*vdl.Type {
	var builder vdl.TypeBuilder
	a := builder.Named("v.io/v23/vdl.nRecurseA")
	b := builder.Named("v.io/v23/vdl.nRecurseB")
	a.AssignBase(builder.Struct().AppendField("B", builder.List().AssignElem(b)))
	b.AssignBase(builder.Struct().AppendField("A", builder.List().AssignElem(a)))
	builder.Build()
	aT, err := a.Built()
	if err != nil {
		panic(err)
	}
	bT, err := b.Built()
	if err != nil {
		panic(err)
	}
	return [2]*vdl.Type{aT, bT}
}

func recurseAType() *vdl.Type { return recurseABTypes()[0] }
func recurseBType() *vdl.Type { return recurseABTypes()[1] }

// Define a bunch of *Type types used in tests.
var (
	// Named scalar types
	boolTypeN    = vdl.NamedType("nBool", vdl.BoolType)
	nByteType    = vdl.NamedType("nByte", vdl.ByteType)
	uint16TypeN  = vdl.NamedType("nUint16", vdl.Uint16Type)
	uint32TypeN  = vdl.NamedType("nUint32", vdl.Uint32Type)
	uint64TypeN  = vdl.NamedType("nUint64", vdl.Uint64Type)
	int16TypeN   = vdl.NamedType("nInt16", vdl.Int16Type)
	int32TypeN   = vdl.NamedType("nInt32", vdl.Int32Type)
	int64TypeN   = vdl.NamedType("nInt64", vdl.Int64Type)
	float32TypeN = vdl.NamedType("nFloat32", vdl.Float32Type)
	float64TypeN = vdl.NamedType("nFloat64", vdl.Float64Type)
	stringTypeN  = vdl.NamedType("nString", vdl.StringType)

	// Composite types representing strings and bytes.
	bytesType   = vdl.ListType(vdl.ByteType)
	bytesTypeN  = vdl.NamedType("nBytes", bytesType)
	bytes3Type  = vdl.ArrayType(3, vdl.ByteType)
	bytes3TypeN = vdl.NamedType("nBytes3", bytes3Type)
	// Composite types representing sequences of numbers.
	array3Uint64Type   = vdl.ArrayType(3, vdl.Uint64Type)
	array3Uint64TypeN  = vdl.NamedType("nArray3Uint64", vdl.ArrayType(3, uint64TypeN))
	array3Int64Type    = vdl.ArrayType(3, vdl.Int64Type)
	array3Int64TypeN   = vdl.NamedType("nArray3Int64", vdl.ArrayType(3, int64TypeN))
	array3Float64Type  = vdl.ArrayType(3, vdl.Float64Type)
	array3Float64TypeN = vdl.NamedType("nArray3Float64", vdl.ArrayType(3, float64TypeN))
	listUint64Type     = vdl.ListType(vdl.Uint64Type)
	listUint64TypeN    = vdl.NamedType("nListUint64", vdl.ListType(uint64TypeN))
	listInt64Type      = vdl.ListType(vdl.Int64Type)
	listInt64TypeN     = vdl.NamedType("nListInt64", vdl.ListType(int64TypeN))
	listFloat64Type    = vdl.ListType(vdl.Float64Type)
	listFloat64TypeN   = vdl.NamedType("nListFloat64", vdl.ListType(float64TypeN))
	// Composite types representing sets of numbers.
	setUint64Type       = vdl.SetType(vdl.Uint64Type)
	setUint64TypeN      = vdl.NamedType("nSetUint64", vdl.SetType(uint64TypeN))
	setInt64Type        = vdl.SetType(vdl.Int64Type)
	setInt64TypeN       = vdl.NamedType("nSetInt64", vdl.SetType(int64TypeN))
	setFloat64Type      = vdl.SetType(vdl.Float64Type)
	setFloat64TypeN     = vdl.NamedType("nSetFloat64", vdl.SetType(float64TypeN))
	mapUint64BoolType   = vdl.MapType(vdl.Uint64Type, vdl.BoolType)
	mapUint64BoolTypeN  = vdl.NamedType("nMapUint64Bool", vdl.MapType(uint64TypeN, boolTypeN))
	mapInt64BoolType    = vdl.MapType(vdl.Int64Type, vdl.BoolType)
	mapInt64BoolTypeN   = vdl.NamedType("nMapInt64Bool", vdl.MapType(int64TypeN, boolTypeN))
	mapFloat64BoolType  = vdl.MapType(vdl.Float64Type, vdl.BoolType)
	mapFloat64BoolTypeN = vdl.NamedType("nMapFloat64Bool", vdl.MapType(float64TypeN, boolTypeN))
	// Composite types representing sets of strings.
	setStringType      = vdl.SetType(vdl.StringType)
	setStringTypeN     = vdl.NamedType("nSetString", vdl.SetType(stringTypeN))
	mapStringBoolType  = vdl.MapType(vdl.StringType, vdl.BoolType)
	mapStringBoolTypeN = vdl.NamedType("nMapStringBool", vdl.MapType(stringTypeN, boolTypeN))
	structXYZBoolType  = vdl.StructType(vdl.Field{Name: "X", Type: vdl.BoolType}, vdl.Field{Name: "Y", Type: vdl.BoolType}, vdl.Field{Name: "Z", Type: vdl.BoolType})
	structXYZBoolTypeN = vdl.NamedType("nStructXYZBool", vdl.StructType(vdl.Field{Name: "X", Type: boolTypeN}, vdl.Field{Name: "Y", Type: boolTypeN}, vdl.Field{Name: "Z", Type: boolTypeN}))
	structWXBoolType   = vdl.StructType(vdl.Field{Name: "W", Type: vdl.BoolType}, vdl.Field{Name: "X", Type: vdl.BoolType})
	structWXBoolTypeN  = vdl.NamedType("nStructWXBool", vdl.StructType(vdl.Field{Name: "W", Type: boolTypeN}, vdl.Field{Name: "X", Type: boolTypeN}))
	// Composite types representing maps of strings to numbers.
	mapStringUint64Type   = vdl.MapType(vdl.StringType, vdl.Uint64Type)
	mapStringUint64TypeN  = vdl.NamedType("nMapStringUint64", vdl.MapType(stringTypeN, uint64TypeN))
	mapStringInt64Type    = vdl.MapType(vdl.StringType, vdl.Int64Type)
	mapStringInt64TypeN   = vdl.NamedType("nMapStringInt64", vdl.MapType(stringTypeN, int64TypeN))
	mapStringFloat64Type  = vdl.MapType(vdl.StringType, vdl.Float64Type)
	mapStringFloat64TypeN = vdl.NamedType("nMapStringFloat64", vdl.MapType(stringTypeN, float64TypeN))
	structVWXUint64Type   = vdl.StructType(vdl.Field{Name: "V", Type: vdl.Uint64Type}, vdl.Field{Name: "W", Type: vdl.Uint64Type}, vdl.Field{Name: "X", Type: vdl.Uint64Type})
	structVWXUint64TypeN  = vdl.NamedType("nStructVWXUint64", vdl.StructType(vdl.Field{Name: "V", Type: uint64TypeN}, vdl.Field{Name: "W", Type: uint64TypeN}, vdl.Field{Name: "X", Type: uint64TypeN}))
	structVWXInt64Type    = vdl.StructType(vdl.Field{Name: "V", Type: vdl.Int64Type}, vdl.Field{Name: "W", Type: vdl.Int64Type}, vdl.Field{Name: "X", Type: vdl.Int64Type})
	structVWXInt64TypeN   = vdl.NamedType("nStructVWXInt64", vdl.StructType(vdl.Field{Name: "V", Type: int64TypeN}, vdl.Field{Name: "W", Type: int64TypeN}, vdl.Field{Name: "X", Type: int64TypeN}))
	structVWXFloat64Type  = vdl.StructType(vdl.Field{Name: "V", Type: vdl.Float64Type}, vdl.Field{Name: "W", Type: vdl.Float64Type}, vdl.Field{Name: "X", Type: vdl.Float64Type})
	structVWXFloat64TypeN = vdl.NamedType("nStructVWXFloat64", vdl.StructType(vdl.Field{Name: "V", Type: float64TypeN}, vdl.Field{Name: "W", Type: float64TypeN}, vdl.Field{Name: "X", Type: float64TypeN}))
	structUVUint64Type    = vdl.StructType(vdl.Field{Name: "U", Type: vdl.Uint64Type}, vdl.Field{Name: "V", Type: vdl.Uint64Type})
	structUVUint64TypeN   = vdl.NamedType("nStructUVUint64", vdl.StructType(vdl.Field{Name: "U", Type: uint64TypeN}, vdl.Field{Name: "V", Type: uint64TypeN}))
	structUVInt64Type     = vdl.StructType(vdl.Field{Name: "U", Type: vdl.Int64Type}, vdl.Field{Name: "V", Type: vdl.Int64Type})
	structUVInt64TypeN    = vdl.NamedType("nStructUVInt64", vdl.StructType(vdl.Field{Name: "U", Type: int64TypeN}, vdl.Field{Name: "V", Type: int64TypeN}))
	structUVFloat64Type   = vdl.StructType(vdl.Field{Name: "U", Type: vdl.Float64Type}, vdl.Field{Name: "V", Type: vdl.Float64Type})
	structUVFloat64TypeN  = vdl.NamedType("nStructUVFloat64", vdl.StructType(vdl.Field{Name: "U", Type: float64TypeN}, vdl.Field{Name: "V", Type: float64TypeN}))

	structAIntType  = vdl.StructType(vdl.Field{Name: "A", Type: vdl.Int64Type})
	structAIntTypeN = vdl.NamedType("nStructA", structAIntType)

	// Types that cannot be converted to sets.  Although we represent sets as
	// map[key]struct{} on the Go side, we don't allow these as general
	// conversions for val.Value.
	emptyType           = vdl.StructType()
	emptyTypeN          = vdl.NamedType("nEmpty", vdl.StructType())
	mapStringEmptyType  = vdl.MapType(vdl.StringType, emptyType)
	mapStringEmptyTypeN = vdl.NamedType("nMapStringEmpty", vdl.MapType(stringTypeN, emptyTypeN))
	structXYZEmptyType  = vdl.StructType(vdl.Field{Name: "X", Type: emptyType}, vdl.Field{Name: "Y", Type: emptyType}, vdl.Field{Name: "Z", Type: emptyType})
	structXYZEmptyTypeN = vdl.NamedType("nStructXYZEmpty", vdl.StructType(vdl.Field{Name: "X", Type: emptyTypeN}, vdl.Field{Name: "Y", Type: emptyTypeN}, vdl.Field{Name: "Z", Type: emptyTypeN}))
)

func setStringValue(t *vdl.Type, x ...string) *vdl.Value {
	res := vdl.ZeroValue(t)
	for _, vx := range x {
		key := vdl.StringValue(t.Key(), vx)
		res.AssignSetKey(key)
	}
	return res
}

type sb struct {
	s string
	b bool
}

func mapStringBoolValue(t *vdl.Type, x ...sb) *vdl.Value {
	res := vdl.ZeroValue(t)
	for _, sb := range x {
		key := vdl.StringValue(t.Key(), sb.s)
		val := vdl.BoolValue(t.Elem(), sb.b)
		res.AssignMapIndex(key, val)
	}
	return res
}

func mapStringEmptyValue(t *vdl.Type, x ...string) *vdl.Value {
	res := vdl.ZeroValue(t)
	for _, vx := range x {
		key := vdl.StringValue(t.Key(), vx)
		val := vdl.ZeroValue(t.Elem())
		res.AssignMapIndex(key, val)
	}
	return res
}

func structBoolValue(t *vdl.Type, x ...sb) *vdl.Value {
	res := vdl.ZeroValue(t)
	for _, sb := range x {
		_, index := t.FieldByName(sb.s)
		res.StructField(index).AssignBool(sb.b)
	}
	return res
}

func assignNum(v *vdl.Value, num float64) *vdl.Value {
	switch v.Kind() {
	case vdl.Byte, vdl.Uint16, vdl.Uint32, vdl.Uint64:
		v.AssignUint(uint64(num))
	case vdl.Int8, vdl.Int16, vdl.Int32, vdl.Int64:
		v.AssignInt(int64(num))
	case vdl.Float32, vdl.Float64:
		v.AssignFloat(num)
	default:
		panic(fmt.Errorf("val: assignNum unhandled %v", v.Type()))
	}
	return v
}

func seqNumValue(t *vdl.Type, x ...float64) *vdl.Value {
	res := vdl.ZeroValue(t)
	if t.Kind() == vdl.List {
		res.AssignLen(len(x))
	}
	for index, n := range x {
		assignNum(res.Index(index), n)
	}
	return res
}

func setNumValue(t *vdl.Type, x ...float64) *vdl.Value {
	res := vdl.ZeroValue(t)
	for _, n := range x {
		res.AssignSetKey(assignNum(vdl.ZeroValue(t.Key()), n))
	}
	return res
}

type nb struct {
	n float64
	b bool
}

func mapNumBoolValue(t *vdl.Type, x ...nb) *vdl.Value {
	res := vdl.ZeroValue(t)
	for _, nb := range x {
		key := assignNum(vdl.ZeroValue(t.Key()), nb.n)
		val := vdl.BoolValue(t.Elem(), nb.b)
		res.AssignMapIndex(key, val)
	}
	return res
}

type sn struct {
	s string
	n float64
}

func mapStringNumValue(t *vdl.Type, x ...sn) *vdl.Value {
	res := vdl.ZeroValue(t)
	for _, sn := range x {
		key := vdl.StringValue(t.Key(), sn.s)
		val := assignNum(vdl.ZeroValue(t.Elem()), sn.n)
		res.AssignMapIndex(key, val)
	}
	return res
}

func structNumValue(t *vdl.Type, x ...sn) *vdl.Value {
	res := vdl.ZeroValue(t)
	for _, sn := range x {
		_, index := t.FieldByName(sn.s)
		assignNum(res.StructField(index), sn.n)
	}
	return res
}