package proptools

import (
	"strings"
	"testing"
)

func mustHash(t *testing.T, provider interface{}) uint64 {
	t.Helper()
	result, err := HashProvider(provider)
	if err != nil {
		t.Fatal(err)
	}
	return result
}

func TestHashingMapGetsSameResults(t *testing.T) {
	provider := map[string]string{"foo": "bar", "baz": "qux"}
	first := mustHash(t, provider)
	second := mustHash(t, provider)
	third := mustHash(t, provider)
	fourth := mustHash(t, provider)
	if first != second || second != third || third != fourth {
		t.Fatal("Did not get the same result every time for a map")
	}
}

func TestHashingNonSerializableTypesFails(t *testing.T) {
	testCases := []struct {
		name     string
		provider interface{}
	}{
		{
			name:     "function pointer",
			provider: []func(){nil},
		},
		{
			name:     "channel",
			provider: []chan int{make(chan int)},
		},
		{
			name:     "list with non-serializable type",
			provider: []interface{}{"foo", make(chan int)},
		},
	}
	for _, testCase := range testCases {
		t.Run(testCase.name, func(t *testing.T) {
			_, err := HashProvider(testCase)
			if err == nil {
				t.Fatal("Expected hashing error but didn't get one")
			}
			expected := "providers may only contain primitives, strings, arrays, slices, structs, maps, and pointers"
			if !strings.Contains(err.Error(), expected) {
				t.Fatalf("Expected %q, got %q", expected, err.Error())
			}
		})
	}
}

func TestHashSuccessful(t *testing.T) {
	testCases := []struct {
		name     string
		provider interface{}
	}{
		{
			name:     "int",
			provider: 5,
		},
		{
			name:     "string",
			provider: "foo",
		},
		{
			name:     "*string",
			provider: StringPtr("foo"),
		},
		{
			name:     "array",
			provider: [3]string{"foo", "bar", "baz"},
		},
		{
			name:     "slice",
			provider: []string{"foo", "bar", "baz"},
		},
		{
			name: "struct",
			provider: struct {
				foo string
				bar int
			}{
				foo: "foo",
				bar: 3,
			},
		},
		{
			name: "map",
			provider: map[string]int{
				"foo": 3,
				"bar": 4,
			},
		},
		{
			name:     "list of interfaces with different types",
			provider: []interface{}{"foo", 3, []string{"bar", "baz"}},
		},
	}
	for _, testCase := range testCases {
		t.Run(testCase.name, func(t *testing.T) {
			mustHash(t, testCase.provider)
		})
	}
}