package racename

import (
	"testing"

	"github.com/stretchr/testify/require"
)

func TestPolicyCanonicalCollisions(t *testing.T) {
	t.Parallel()

	policy, err := NewPolicy()
	require.NoError(t, err)

	tests := []struct {
		name  string
		left  string
		right string
	}{
		{
			name:  "case insensitive collision",
			left:  "Pilot Nova",
			right: "pilot nova",
		},
		{
			name:  "ascii anti fraud collision",
			left:  "Pilot Nova",
			right: "P1lot N0va",
		},
		{
			name:  "unicode confusable collision",
			left:  "paypal",
			right: "раураl",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			leftKey, err := policy.Canonical(tt.left)
			require.NoError(t, err)
			rightKey, err := policy.Canonical(tt.right)
			require.NoError(t, err)
			require.Equal(t, rightKey, leftKey)
		})
	}
}

func TestPolicyCanonicalRejectsEmpty(t *testing.T) {
	t.Parallel()

	policy, err := NewPolicy()
	require.NoError(t, err)

	_, err = policy.Canonical("")
	require.Error(t, err)

	_, err = policy.Canonical("   ")
	require.Error(t, err)
}

func TestPolicyCanonicalTrimsWhitespace(t *testing.T) {
	t.Parallel()

	policy, err := NewPolicy()
	require.NoError(t, err)

	trimmed, err := policy.Canonical("Pilot Nova")
	require.NoError(t, err)
	padded, err := policy.Canonical("  Pilot Nova  ")
	require.NoError(t, err)
	require.Equal(t, trimmed, padded)
}

func TestValidateNameDelegatesToUtil(t *testing.T) {
	t.Parallel()

	trimmed, err := ValidateName("  PilotNova  ")
	require.NoError(t, err)
	require.Equal(t, "PilotNova", trimmed)

	_, err = ValidateName("")
	require.Error(t, err)

	_, err = ValidateName("   ")
	require.Error(t, err)

	// Internal whitespace is rejected by util.ValidateTypeName.
	_, err = ValidateName("Pilot Nova")
	require.Error(t, err)
}

func TestCanonicalKeyValidate(t *testing.T) {
	t.Parallel()

	require.Error(t, CanonicalKey("").Validate())
	require.Error(t, CanonicalKey(" abc").Validate())
	require.Error(t, CanonicalKey("abc ").Validate())
	require.NoError(t, CanonicalKey("abc").Validate())
	require.True(t, CanonicalKey("").IsZero())
	require.False(t, CanonicalKey("abc").IsZero())
	require.Equal(t, "abc", CanonicalKey("abc").String())
}

func TestPolicyCanonicalizeValid(t *testing.T) {
	t.Parallel()

	policy, err := NewPolicy()
	require.NoError(t, err)

	key, err := policy.Canonicalize("  PilotNova  ")
	require.NoError(t, err)
	require.NoError(t, key.Validate())
	require.False(t, key.IsZero())

	paddedKey, err := policy.Canonicalize("PilotNova")
	require.NoError(t, err)
	require.Equal(t, paddedKey, key)
}

func TestPolicyCanonicalizeEquivalences(t *testing.T) {
	t.Parallel()

	policy, err := NewPolicy()
	require.NoError(t, err)

	cases := []struct {
		name  string
		left  string
		right string
	}{
		{
			name:  "case insensitive collision",
			left:  "PilotNova",
			right: "pilotnova",
		},
		{
			name:  "ascii anti fraud collision",
			left:  "PilotNova",
			right: "P1l0tN0va",
		},
		{
			name:  "unicode confusable collision",
			left:  "paypal",
			right: "раураl",
		},
	}

	for _, tt := range cases {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			leftKey, err := policy.Canonicalize(tt.left)
			require.NoError(t, err)
			rightKey, err := policy.Canonicalize(tt.right)
			require.NoError(t, err)
			require.Equal(t, leftKey, rightKey)
		})
	}
}

func TestPolicyCanonicalizeRejectsInvalid(t *testing.T) {
	t.Parallel()

	policy, err := NewPolicy()
	require.NoError(t, err)

	invalid := []struct {
		name  string
		input string
	}{
		{name: "empty", input: ""},
		{name: "whitespace only", input: "   "},
		{name: "internal space", input: "Pilot Nova"},
		{name: "leading dash", input: "-Pilot"},
		{name: "trailing dash", input: "Pilot-"},
	}

	for _, tt := range invalid {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			_, err := policy.Canonicalize(tt.input)
			require.Error(t, err)
		})
	}
}