package shared

import (
	"errors"
	"testing"

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

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

	require.True(t, ActorKindAdmin.IsKnown())
	require.True(t, ActorKindUser.IsKnown())
	require.False(t, ActorKind("").IsKnown())
	require.False(t, ActorKind("other").IsKnown())
}

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

	admin := NewAdminActor()
	require.True(t, admin.IsAdmin())
	require.False(t, admin.IsUser())
	require.Equal(t, "", admin.UserID)

	user := NewUserActor("user-123")
	require.True(t, user.IsUser())
	require.False(t, user.IsAdmin())
	require.Equal(t, "user-123", user.UserID)
}

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

	tests := []struct {
		name    string
		actor   Actor
		wantErr string
	}{
		{name: "admin ok", actor: NewAdminActor()},
		{name: "user ok", actor: NewUserActor("user-42")},
		{name: "unknown kind", actor: Actor{Kind: "ghost"}, wantErr: "actor kind"},
		{name: "admin with user id", actor: Actor{Kind: ActorKindAdmin, UserID: "user-1"}, wantErr: "admin actor must not carry"},
		{name: "user without id", actor: Actor{Kind: ActorKindUser}, wantErr: "user actor must carry"},
		{name: "user id with whitespace", actor: Actor{Kind: ActorKindUser, UserID: " user-1 "}, wantErr: "whitespace"},
		{name: "user id empty trimmed", actor: Actor{Kind: ActorKindUser, UserID: "  "}, wantErr: "user actor must carry"},
	}

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

			err := tt.actor.Validate()
			if tt.wantErr == "" {
				require.NoError(t, err)
				return
			}
			require.Error(t, err)
			require.Contains(t, err.Error(), tt.wantErr)
		})
	}
}

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

	wrapped := errors.New("forbidden: actor kind is admin; private games require user caller")
	require.False(t, errors.Is(wrapped, ErrForbidden))

	wrapped = errInvalid("forbidden: not owner")
	require.True(t, errors.Is(wrapped, ErrForbidden))
}

func errInvalid(msg string) error {
	return wrappedError{msg: msg, base: ErrForbidden}
}

type wrappedError struct {
	msg  string
	base error
}

func (err wrappedError) Error() string { return err.msg }
func (err wrappedError) Unwrap() error { return err.base }