package test_test

import (
	"context"
	"spend-sparrow/internal/db"
	"spend-sparrow/internal/service"
	"spend-sparrow/internal/types"
	"spend-sparrow/mocks"
	"strings"
	"testing"
	"time"

	"github.com/google/uuid"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/mock"
	"github.com/stretchr/testify/require"
)

var (
	settings = types.Settings{
		Port:        "",
		BaseUrl:     "",
		Environment: "test",
		Smtp:        nil,
	}
)

func TestSignUp(t *testing.T) {
	t.Parallel()
	t.Run("should check for correct email address", func(t *testing.T) {
		t.Parallel()

		mockAuthDb := mocks.NewMockAuth(t)
		mockRandom := mocks.NewMockRandom(t)
		mockClock := mocks.NewMockClock(t)
		mockMail := mocks.NewMockMail(t)

		underTest := service.NewAuth(mockAuthDb, mockRandom, mockClock, mockMail, &settings)

		_, err := underTest.SignUp(context.Background(), "invalid email address", "SomeStrongPassword123!")

		assert.Equal(t, service.ErrInvalidEmail, err)
	})
	t.Run("should check for password complexity", func(t *testing.T) {
		t.Parallel()

		mockAuthDb := mocks.NewMockAuth(t)
		mockRandom := mocks.NewMockRandom(t)
		mockClock := mocks.NewMockClock(t)
		mockMail := mocks.NewMockMail(t)

		underTest := service.NewAuth(mockAuthDb, mockRandom, mockClock, mockMail, &settings)

		weakPasswords := []string{
			"123!ab", // too short
			"no_upper_case_123",
			"NO_LOWER_CASE_123",
			"noSpecialChar123",
		}

		for _, password := range weakPasswords {
			_, err := underTest.SignUp(context.Background(), "some@valid.email", password)
			assert.Equal(t, service.ErrInvalidPassword, err)
		}
	})
	t.Run("should signup correctly", func(t *testing.T) {
		t.Parallel()

		mockAuthDb := mocks.NewMockAuth(t)
		mockRandom := mocks.NewMockRandom(t)
		mockClock := mocks.NewMockClock(t)
		mockMail := mocks.NewMockMail(t)

		userId := uuid.New()
		email := "mail@mail.de"
		password := "SomeStrongPassword123!"
		salt := []byte("salt")
		createTime := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)

		expected := types.NewUser(userId, email, false, nil, false, service.GetHashPassword(password, salt), salt, createTime)

		ctx := context.Background()

		mockRandom.EXPECT().UUID(ctx).Return(userId, nil)
		mockRandom.EXPECT().Bytes(ctx, 16).Return(salt, nil)
		mockClock.EXPECT().Now().Return(createTime)
		mockAuthDb.EXPECT().InsertUser(context.Background(), expected).Return(nil)

		underTest := service.NewAuth(mockAuthDb, mockRandom, mockClock, mockMail, &settings)
		actual, err := underTest.SignUp(context.Background(), email, password)

		require.NoError(t, err)

		assert.Equal(t, expected, actual)
	})
	t.Run("should return ErrAccountExists", func(t *testing.T) {
		t.Parallel()

		mockAuthDb := mocks.NewMockAuth(t)
		mockRandom := mocks.NewMockRandom(t)
		mockClock := mocks.NewMockClock(t)
		mockMail := mocks.NewMockMail(t)

		userId := uuid.New()
		email := "some@valid.email"
		createTime := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
		password := "SomeStrongPassword123!"
		salt := []byte("salt")
		user := types.NewUser(userId, email, false, nil, false, service.GetHashPassword(password, salt), salt, createTime)

		ctx := context.Background()
		mockRandom.EXPECT().UUID(ctx).Return(user.Id, nil)
		mockRandom.EXPECT().Bytes(ctx, 16).Return(salt, nil)
		mockClock.EXPECT().Now().Return(createTime)

		mockAuthDb.EXPECT().InsertUser(context.Background(), user).Return(db.ErrAlreadyExists)

		underTest := service.NewAuth(mockAuthDb, mockRandom, mockClock, mockMail, &settings)

		_, err := underTest.SignUp(context.Background(), user.Email, password)
		assert.Equal(t, service.ErrAccountExists, err)
	})
}

func TestSendVerificationMail(t *testing.T) {
	t.Parallel()
	t.Run("should use stored token and send mail", func(t *testing.T) {
		t.Parallel()

		token := types.NewToken(
			uuid.New(),
			"sessionId",
			"someRandomTokenToUse",
			types.TokenTypeEmailVerify,
			time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC),
			time.Date(2020, 1, 2, 0, 0, 0, 0, time.UTC))
		tokens := []*types.Token{token}

		email := "some@email.de"
		userId := uuid.New()

		mockAuthDb := mocks.NewMockAuth(t)
		mockRandom := mocks.NewMockRandom(t)
		mockClock := mocks.NewMockClock(t)
		mockMail := mocks.NewMockMail(t)

		ctx := context.Background()
		mockAuthDb.EXPECT().GetTokensByUserIdAndType(context.Background(), userId, types.TokenTypeEmailVerify).Return(tokens, nil)
		mockMail.EXPECT().SendMail(ctx, email, "Welcome to spend-sparrow", mock.MatchedBy(func(message string) bool {
			return strings.Contains(message, token.Token)
		})).Return()

		underTest := service.NewAuth(mockAuthDb, mockRandom, mockClock, mockMail, &settings)

		underTest.SendVerificationMail(context.Background(), userId, email)
	})
}