// Copyright 2024 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 reflect_test

import (
	"iter"
	"maps"
	"reflect"
	. "reflect"
	"testing"
)

type N int8

func TestValueSeq(t *testing.T) {
	m := map[string]int{
		"1": 1,
		"2": 2,
		"3": 3,
		"4": 4,
	}
	c := make(chan int, 3)
	for i := range 3 {
		c <- i
	}
	close(c)
	tests := []struct {
		name  string
		val   Value
		check func(*testing.T, iter.Seq[Value])
	}{
		{"int", ValueOf(4), func(t *testing.T, s iter.Seq[Value]) {
			i := int64(0)
			for v := range s {
				if v.Int() != i {
					t.Fatalf("got %d, want %d", v.Int(), i)
				}
				i++
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},
		{"int8", ValueOf(int8(4)), func(t *testing.T, s iter.Seq[Value]) {
			i := int8(0)
			for v := range s {
				if v.Interface().(int8) != i {
					t.Fatalf("got %d, want %d", v.Int(), i)
				}
				i++
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},
		{"uint", ValueOf(uint64(4)), func(t *testing.T, s iter.Seq[Value]) {
			i := uint64(0)
			for v := range s {
				if v.Uint() != i {
					t.Fatalf("got %d, want %d", v.Uint(), i)
				}
				i++
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},
		{"uint8", ValueOf(uint8(4)), func(t *testing.T, s iter.Seq[Value]) {
			i := uint8(0)
			for v := range s {
				if v.Interface().(uint8) != i {
					t.Fatalf("got %d, want %d", v.Int(), i)
				}
				i++
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},
		{"*[4]int", ValueOf(&[4]int{1, 2, 3, 4}), func(t *testing.T, s iter.Seq[Value]) {
			i := int64(0)
			for v := range s {
				if v.Int() != i {
					t.Fatalf("got %d, want %d", v.Int(), i)
				}
				i++
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},
		// Regression: Value.Seq on a nil *[n]int must not panic (Elem of nil ptr is invalid).
		{"nil *[3]int", ValueOf((*[3]int)(nil)), func(t *testing.T, s iter.Seq[Value]) {
			i := int64(0)
			for v := range s {
				if v.Int() != i {
					t.Fatalf("got %d, want %d", v.Int(), i)
				}
				i++
			}
			if i != 3 {
				t.Fatalf("should loop three times, got %d", i)
			}
		}},
		{"[4]int", ValueOf([4]int{1, 2, 3, 4}), func(t *testing.T, s iter.Seq[Value]) {
			i := int64(0)
			for v := range s {
				if v.Int() != i {
					t.Fatalf("got %d, want %d", v.Int(), i)
				}
				i++
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},
		{"[]int", ValueOf([]int{1, 2, 3, 4}), func(t *testing.T, s iter.Seq[Value]) {
			i := int64(0)
			for v := range s {
				if v.Int() != i {
					t.Fatalf("got %d, want %d", v.Int(), i)
				}
				i++
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},
		{"string", ValueOf("12语言"), func(t *testing.T, s iter.Seq[Value]) {
			i := int64(0)
			indexes := []int64{0, 1, 2, 5}
			for v := range s {
				if v.Int() != indexes[i] {
					t.Fatalf("got %d, want %d", v.Int(), indexes[i])
				}
				i++
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},
		{"map[string]int", ValueOf(m), func(t *testing.T, s iter.Seq[Value]) {
			copy := maps.Clone(m)
			for v := range s {
				if _, ok := copy[v.String()]; !ok {
					t.Fatalf("unexpected %v", v.Interface())
				}
				delete(copy, v.String())
			}
			if len(copy) != 0 {
				t.Fatalf("should loop four times")
			}
		}},
		{"chan int", ValueOf(c), func(t *testing.T, s iter.Seq[Value]) {
			i := 0
			m := map[int64]bool{
				0: false,
				1: false,
				2: false,
			}
			for v := range s {
				if b, ok := m[v.Int()]; !ok || b {
					t.Fatalf("unexpected %v", v.Interface())
				}
				m[v.Int()] = true
				i++
			}
			if i != 3 {
				t.Fatalf("should loop three times")
			}
		}},
		{"func", ValueOf(func(yield func(int) bool) {
			for i := range 4 {
				if !yield(i) {
					return
				}
			}
		}), func(t *testing.T, s iter.Seq[Value]) {
			i := int64(0)
			for v := range s {
				if v.Int() != i {
					t.Fatalf("got %d, want %d", v.Int(), i)
				}
				i++
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},
		{"method", ValueOf(methodIter{}).MethodByName("Seq"), func(t *testing.T, s iter.Seq[Value]) {
			i := int64(0)
			for v := range s {
				if v.Int() != i {
					t.Fatalf("got %d, want %d", v.Int(), i)
				}
				i++
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},
		{"type N int8", ValueOf(N(4)), func(t *testing.T, s iter.Seq[Value]) {
			i := N(0)
			for v := range s {
				if v.Int() != int64(i) {
					t.Fatalf("got %d, want %d", v.Int(), i)
				}
				i++
				if v.Type() != reflect.TypeOf(i) {
					t.Fatalf("got %s, want %s", v.Type(), reflect.TypeOf(i))
				}
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},
	}
	for _, tc := range tests {
		seq := tc.val.Seq()
		tc.check(t, seq)
	}
}

func TestValueSeq2(t *testing.T) {
	m := map[string]int{
		"1": 1,
		"2": 2,
		"3": 3,
		"4": 4,
	}
	tests := []struct {
		name  string
		val   Value
		check func(*testing.T, iter.Seq2[Value, Value])
	}{
		{"*[4]int", ValueOf(&[4]int{1, 2, 3, 4}), func(t *testing.T, s iter.Seq2[Value, Value]) {
			i := int64(0)
			for v1, v2 := range s {
				if v1.Int() != i {
					t.Fatalf("got %d, want %d", v1.Int(), i)
				}
				i++
				if v2.Int() != i {
					t.Fatalf("got %d, want %d", v2.Int(), i)
				}
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},
		{"[4]int", ValueOf([4]int{1, 2, 3, 4}), func(t *testing.T, s iter.Seq2[Value, Value]) {
			i := int64(0)
			for v1, v2 := range s {
				if v1.Int() != i {
					t.Fatalf("got %d, want %d", v1.Int(), i)
				}
				i++
				if v2.Int() != i {
					t.Fatalf("got %d, want %d", v2.Int(), i)
				}
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},
		{"[]int", ValueOf([]int{1, 2, 3, 4}), func(t *testing.T, s iter.Seq2[Value, Value]) {
			i := int64(0)
			for v1, v2 := range s {
				if v1.Int() != i {
					t.Fatalf("got %d, want %d", v1.Int(), i)
				}
				i++
				if v2.Int() != i {
					t.Fatalf("got %d, want %d", v2.Int(), i)
				}
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},
		{"string", ValueOf("12语言"), func(t *testing.T, s iter.Seq2[Value, Value]) {
			next, stop := iter.Pull2(s)
			defer stop()
			i := int64(0)
			for j, s := range "12语言" {
				v1, v2, ok := next()
				if !ok {
					t.Fatalf("should loop four times")
				}
				if v1.Int() != int64(j) {
					t.Fatalf("got %d, want %d", v1.Int(), j)
				}
				if v2.Interface() != s {
					t.Fatalf("got %v, want %v", v2.Interface(), s)
				}
				i++
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},
		{"map[string]int", ValueOf(m), func(t *testing.T, s iter.Seq2[Value, Value]) {
			copy := maps.Clone(m)
			for v1, v2 := range s {
				v, ok := copy[v1.String()]
				if !ok {
					t.Fatalf("unexpected %v", v1.String())
				}
				if v != v2.Interface() {
					t.Fatalf("got %v, want %d", v2.Interface(), v)
				}
				delete(copy, v1.String())
			}
			if len(copy) != 0 {
				t.Fatalf("should loop four times")
			}
		}},
		{"func", ValueOf(func(f func(int, int) bool) {
			for i := range 4 {
				f(i, i+1)
			}
		}), func(t *testing.T, s iter.Seq2[Value, Value]) {
			i := int64(0)
			for v1, v2 := range s {
				if v1.Int() != i {
					t.Fatalf("got %d, want %d", v1.Int(), i)
				}
				i++
				if v2.Int() != i {
					t.Fatalf("got %d, want %d", v2.Int(), i)
				}
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},
		{"method", ValueOf(methodIter2{}).MethodByName("Seq2"), func(t *testing.T, s iter.Seq2[Value, Value]) {
			i := int64(0)
			for v1, v2 := range s {
				if v1.Int() != i {
					t.Fatalf("got %d, want %d", v1.Int(), i)
				}
				i++
				if v2.Int() != i {
					t.Fatalf("got %d, want %d", v2.Int(), i)
				}
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},
		{"[4]N", ValueOf([4]N{0, 1, 2, 3}), func(t *testing.T, s iter.Seq2[Value, Value]) {
			i := N(0)
			for v1, v2 := range s {
				if v1.Int() != int64(i) {
					t.Fatalf("got %d, want %d", v1.Int(), i)
				}
				if v2.Int() != int64(i) {
					t.Fatalf("got %d, want %d", v2.Int(), i)
				}
				i++
				if v2.Type() != reflect.TypeOf(i) {
					t.Fatalf("got %s, want %s", v2.Type(), reflect.TypeOf(i))
				}
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},
		{"[]N", ValueOf([]N{1, 2, 3, 4}), func(t *testing.T, s iter.Seq2[Value, Value]) {
			i := N(0)
			for v1, v2 := range s {
				if v1.Int() != int64(i) {
					t.Fatalf("got %d, want %d", v1.Int(), i)
				}
				i++
				if v2.Int() != int64(i) {
					t.Fatalf("got %d, want %d", v2.Int(), i)
				}
				if v2.Type() != reflect.TypeOf(i) {
					t.Fatalf("got %s, want %s", v2.Type(), reflect.TypeOf(i))
				}
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},
	}
	for _, tc := range tests {
		seq := tc.val.Seq2()
		tc.check(t, seq)
	}
}

// methodIter is a type from which we can derive a method
// value that is an iter.Seq.
type methodIter struct{}

func (methodIter) Seq(yield func(int) bool) {
	for i := range 4 {
		if !yield(i) {
			return
		}
	}
}

// For Type.CanSeq test.
func (methodIter) NonSeq(yield func(int)) {}

// methodIter2 is a type from which we can derive a method
// value that is an iter.Seq2.
type methodIter2 struct{}

func (methodIter2) Seq2(yield func(int, int) bool) {
	for i := range 4 {
		if !yield(i, i+1) {
			return
		}
	}
}

// For Type.CanSeq2 test.
func (methodIter2) NonSeq2(yield func(int, int)) {}

func TestSeqRetNamedBool(t *testing.T) {
	type Bool bool
	// Note: Type.Name() == "bool" is a incorrect check,
	// the named boolean type below will pass the incorrect check.
	type bool Bool
	v := ValueOf(func(func(int) bool) {})
	if v.Type().CanSeq() {
		t.Fatal("got true, want false")
	}
	shouldPanic("reflect: func(func(int) reflect_test.bool) cannot produce iter.Seq[Value]", func() { v.Seq() })
	v2 := ValueOf(func(func(int, int) bool) {})
	if v2.Type().CanSeq() {
		t.Fatal("got true, want false")
	}
	shouldPanic("func(func(int, int) reflect_test.bool) cannot produce iter.Seq2[Value, Value]", func() { v2.Seq2() })
}