package bind_test

import (
	"code.squareroundforest.org/arpio/bind"
	"testing"
)

func TestTypeChecks(t *testing.T) {
	t.Run("accepts scalar", func(t *testing.T) {
		t.Run("bool", func(t *testing.T) {
			if !bind.AcceptsScalar[bool]() {
				t.Fatal()
			}
		})

		t.Run("int", func(t *testing.T) {
			if !bind.AcceptsScalar[int]() {
				t.Fatal()
			}
		})

		t.Run("uint", func(t *testing.T) {
			if !bind.AcceptsScalar[uint]() {
				t.Fatal()
			}
		})

		t.Run("float", func(t *testing.T) {
			if !bind.AcceptsScalar[int]() {
				t.Fatal()
			}
		})

		t.Run("string", func(t *testing.T) {
			if !bind.AcceptsScalar[bool]() {
				t.Fatal()
			}
		})

		t.Run("any", func(t *testing.T) {
			if !bind.AcceptsScalar[any]() {
				t.Fatal()
			}
		})

		t.Run("pointer", func(t *testing.T) {
			type p *int
			if !bind.AcceptsScalar[p]() {
				t.Fatal()
			}
		})

		t.Run("slice", func(t *testing.T) {
			type s []int
			if !bind.AcceptsScalar[s]() {
				t.Fatal()
			}
		})

		t.Run("pointer and slice combined", func(t *testing.T) {
			type c *[]*[]int
			if !bind.AcceptsScalar[c]() {
				t.Fatal()
			}
		})

		t.Run("struct", func(t *testing.T) {
			type s struct{ Foo int }
			if bind.AcceptsScalar[s]() {
				t.Fatal()
			}
		})

		t.Run("map", func(t *testing.T) {
			if bind.AcceptsScalar[map[string]int]() {
				t.Fatal()
			}
		})

		t.Run("interface with methods", func(t *testing.T) {
			type i interface{ Foo(int) }
			if bind.AcceptsScalar[i]() {
				t.Fatal()
			}
		})

		t.Run("func", func(t *testing.T) {
			if bind.AcceptsScalar[func(int)]() {
				t.Fatal()
			}
		})

		t.Run("chan", func(t *testing.T) {
			if bind.AcceptsScalar[chan int]() {
				t.Fatal()
			}
		})
	})

	t.Run("accepts fields", func(t *testing.T) {
		t.Run("struct", func(t *testing.T) {
			type s struct{ Foo int }
			if !bind.AcceptsFields[s]() {
				t.Fatal()
			}
		})

		t.Run("map", func(t *testing.T) {
			if !bind.AcceptsFields[map[string]int]() {
				t.Fatal()
			}
		})

		t.Run("map with interface fields", func(t *testing.T) {
			if !bind.AcceptsFields[map[string]any]() {
				t.Fatal()
			}
		})

		t.Run("map with list fields", func(t *testing.T) {
			if !bind.AcceptsFields[map[string][]int]() {
				t.Fatal()
			}
		})

		t.Run("pointer", func(t *testing.T) {
			type p *struct{ Foo int }
			if !bind.AcceptsFields[p]() {
				t.Fatal()
			}
		})

		t.Run("slice", func(t *testing.T) {
			type s []struct{ Foo int }
			if !bind.AcceptsFields[s]() {
				t.Fatal()
			}
		})

		t.Run("pointer and slice combined", func(t *testing.T) {
			type c *[]*[]struct{ Foo int }
			if !bind.AcceptsFields[c]() {
				t.Fatal()
			}
		})

		t.Run("wrong map key", func(t *testing.T) {
			if bind.AcceptsFields[map[int]int]() {
				t.Fatal()
			}
		})

		t.Run("wrong map value", func(t *testing.T) {
			if bind.AcceptsFields[map[string]struct{ Foo int }]() {
				t.Fatal()
			}
		})

		t.Run("scalar", func(t *testing.T) {
			if bind.AcceptsFields[int]() {
				t.Fatal()
			}
		})

		t.Run("interface", func(t *testing.T) {
			type i interface{ Foo(int) }
			if bind.AcceptsFields[i]() {
				t.Fatal()
			}
		})

		t.Run("any type", func(t *testing.T) {
			if bind.AcceptsFields[any]() {
				t.Fatal()
			}
		})

		t.Run("func", func(t *testing.T) {
			if bind.AcceptsFields[func(int)]() {
				t.Fatal()
			}
		})

		t.Run("chan", func(t *testing.T) {
			if bind.AcceptsFields[chan int]() {
				t.Fatal()
			}
		})
	})

	t.Run("accepts list", func(t *testing.T) {
		t.Run("scalars", func(t *testing.T) {
			if !bind.AcceptsList[[]int]() {
				t.Fatal()
			}
		})

		t.Run("structs", func(t *testing.T) {
			if !bind.AcceptsList[[]struct{ Foo int }]() {
				t.Fatal()
			}
		})

		t.Run("maps", func(t *testing.T) {
			if !bind.AcceptsList[[]map[string]int]() {
				t.Fatal()
			}
		})

		t.Run("pointer to list", func(t *testing.T) {
			if !bind.AcceptsList[*[]int]() {
				t.Fatal()
			}
		})

		t.Run("scalar", func(t *testing.T) {
			if bind.AcceptsList[int]() {
				t.Fatal()
			}
		})

		t.Run("struct", func(t *testing.T) {
			if bind.AcceptsList[struct{ Foo int }]() {
				t.Fatal()
			}
		})

		t.Run("map", func(t *testing.T) {
			if bind.AcceptsList[map[string]int]() {
				t.Fatal()
			}
		})

		t.Run("map", func(t *testing.T) {
			if bind.AcceptsList[map[string]int]() {
				t.Fatal()
			}
		})

		t.Run("struct pointer", func(t *testing.T) {
			if bind.AcceptsList[*struct{ Foo int }]() {
				t.Fatal()
			}
		})

		t.Run("wrong elem type", func(t *testing.T) {
			if bind.AcceptsList[map[string]struct{ Foo int }]() {
				t.Fatal()
			}
		})
	})

	t.Run("bindable", func(t *testing.T) {
		t.Run("scalar", func(t *testing.T) {
			if !bind.Bindable[int]() {
				t.Fatal()
			}
		})

		t.Run("struct", func(t *testing.T) {
			if !bind.Bindable[struct{ Foo int }]() {
				t.Fatal()
			}
		})

		t.Run("func", func(t *testing.T) {
			if bind.Bindable[func()]() {
				t.Fatal()
			}
		})

		t.Run("chan", func(t *testing.T) {
			if bind.Bindable[chan int]() {
				t.Fatal()
			}
		})
	})
}