package domain_test

import (
	"fmt"
	"math/rand"
	"testing"

	"gitea.dwysokinski.me/twhelp/sessions/internal/domain"
	"github.com/stretchr/testify/assert"
)

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

	tests := []struct {
		name        string
		username    string
		expectedErr error
	}{
		{
			name:        "OK",
			username:    "testTEST-test-2",
			expectedErr: nil,
		},
		{
			name:     "ERR: username is required",
			username: "",
			expectedErr: domain.ValidationError{
				Field: "Name",
				Err:   domain.ErrRequired,
			},
		},
		{
			name:     "ERR: len(username) < 2",
			username: "u",
			expectedErr: domain.ValidationError{
				Field: "Name",
				Err: domain.MinLengthError{
					Min: 2,
				},
			},
		},
		{
			name:     "ERR: len(username) > 40",
			username: randString(41),
			expectedErr: domain.ValidationError{
				Field: "Name",
				Err: domain.MaxLengthError{
					Max: 40,
				},
			},
		},
		{
			name:     "ERR: username - hyphen at the end",
			username: "u-",
			expectedErr: domain.ValidationError{
				Field: "Name",
				Err:   domain.ErrUsernameFormat,
			},
		},
		{
			name:     "ERR: username - hyphen at the beginning",
			username: "-u",
			expectedErr: domain.ValidationError{
				Field: "Name",
				Err:   domain.ErrUsernameFormat,
			},
		},
		{
			name:     "ERR: username - only alphanumeric 1",
			username: "userńame",
			expectedErr: domain.ValidationError{
				Field: "Name",
				Err:   domain.ErrUsernameFormat,
			},
		},
		{
			name:     "ERR: username - only alphanumeric 1",
			username: "漢字",
			expectedErr: domain.ValidationError{
				Field: "Name",
				Err:   domain.ErrUsernameFormat,
			},
		},
	}

	for _, tt := range tests {
		tt := tt

		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			params, err := domain.NewCreateUserParams(tt.username)
			if tt.expectedErr != nil {
				assert.Equal(t, tt.expectedErr, err)
				assert.Zero(t, params)
				return
			}
			assert.NoError(t, err)
			assert.Equal(t, tt.username, params.Name())
		})
	}
}

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

	err := domain.UsernameAlreadyTakenError{
		Name: "xxxx",
	}
	var _ domain.Error = err
	assert.Equal(t, fmt.Sprintf("username '%s' is already taken", err.Name), err.Error())
	assert.Equal(t, err.Error(), err.UserError())
	assert.Equal(t, domain.ErrorCodeAlreadyExists, err.Code())
}

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

	err := domain.UserDoesNotExistError{
		ID: 12345,
	}
	var _ domain.Error = err
	assert.Equal(t, fmt.Sprintf("user (ID=%d) doesn't exist", err.ID), err.Error())
	assert.Equal(t, err.Error(), err.UserError())
	assert.Equal(t, domain.ErrorCodeValidationError, err.Code())
}

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

	err := domain.UserNotFoundError{
		ID: 12345,
	}
	var _ domain.Error = err
	assert.Equal(t, fmt.Sprintf("user (ID=%d) not found", err.ID), err.Error())
	assert.Equal(t, err.Error(), err.UserError())
	assert.Equal(t, domain.ErrorCodeEntityNotFound, err.Code())
}

func randString(length int) string {
	const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
	b := make([]byte, length)
	for i := range b {
		//nolint:gosec
		b[i] = charset[rand.Intn(len(charset))]
	}
	return string(b)
}