package test_test

import (
	"context"
	"spend-sparrow/internal/auth_types"
	"spend-sparrow/internal/authentication"
	"spend-sparrow/internal/core"
	"testing"
	"time"

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

func setupDb(t *testing.T) *sqlx.DB {
	t.Helper()

	d, err := sqlx.Open("sqlite3", ":memory:")
	if err != nil {
		t.Fatalf("Error opening database: %v", err)
	}
	t.Cleanup(func() {
		err := d.Close()
		if err != nil {
			panic(err)
		}
	})

	err = core.RunMigrations(context.Background(), d, "../")
	if err != nil {
		t.Fatalf("Error running migrations: %v", err)
	}

	return d
}

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

	t.Run("should insert and get the same", func(t *testing.T) {
		t.Parallel()
		d := setupDb(t)

		underTest := authentication.NewDbSqlite(d)

		verifiedAt := time.Date(2020, 1, 5, 13, 0, 0, 0, time.UTC)
		createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
		expected := auth_types.NewUser(uuid.New(), "some@email.de", true, &verifiedAt, false, []byte("somePass"), []byte("someSalt"), createAt)

		err := underTest.InsertUser(context.Background(), expected)
		require.NoError(t, err)

		actual, err := underTest.GetUser(context.Background(), expected.Id)
		require.NoError(t, err)
		assert.Equal(t, expected, actual)

		actual, err = underTest.GetUserByEmail(context.Background(), expected.Email)
		require.NoError(t, err)
		assert.Equal(t, expected, actual)
	})
	t.Run("should return ErrNotFound", func(t *testing.T) {
		t.Parallel()
		d := setupDb(t)

		underTest := authentication.NewDbSqlite(d)

		_, err := underTest.GetUserByEmail(context.Background(), "nonExistentEmail")
		assert.Equal(t, core.ErrNotFound, err)
	})
	t.Run("should return ErrUserExist", func(t *testing.T) {
		t.Parallel()
		d := setupDb(t)

		underTest := authentication.NewDbSqlite(d)

		verifiedAt := time.Date(2020, 1, 5, 13, 0, 0, 0, time.UTC)
		createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
		user := auth_types.NewUser(uuid.New(), "some@email.de", true, &verifiedAt, false, []byte("somePass"), []byte("someSalt"), createAt)

		err := underTest.InsertUser(context.Background(), user)
		require.NoError(t, err)

		err = underTest.InsertUser(context.Background(), user)
		assert.Equal(t, core.ErrAlreadyExists, err)
	})
	t.Run("should return ErrInternal on missing NOT NULL fields", func(t *testing.T) {
		t.Parallel()
		d := setupDb(t)

		underTest := authentication.NewDbSqlite(d)

		createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
		user := auth_types.NewUser(uuid.New(), "some@email.de", false, nil, false, []byte("somePass"), nil, createAt)

		err := underTest.InsertUser(context.Background(), user)
		assert.Equal(t, core.ErrInternal, err)
	})
}

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

	t.Run("should insert and get the same", func(t *testing.T) {
		t.Parallel()
		d := setupDb(t)

		underTest := authentication.NewDbSqlite(d)

		createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
		expiresAt := createAt.Add(24 * time.Hour)
		expected := auth_types.NewToken(uuid.New(), "sessionId", "token", auth_types.TokenTypeCsrf, createAt, expiresAt)

		err := underTest.InsertToken(context.Background(), expected)
		require.NoError(t, err)

		actual, err := underTest.GetToken(context.Background(), expected.Token)
		require.NoError(t, err)
		assert.Equal(t, expected, actual)

		expected.SessionId = ""
		actuals, err := underTest.GetTokensByUserIdAndType(context.Background(), expected.UserId, expected.Type)
		require.NoError(t, err)
		assert.Equal(t, []*auth_types.Token{expected}, actuals)

		expected.SessionId = "sessionId"
		expected.UserId = uuid.Nil
		actuals, err = underTest.GetTokensBySessionIdAndType(context.Background(), expected.SessionId, expected.Type)
		require.NoError(t, err)
		assert.Equal(t, []*auth_types.Token{expected}, actuals)
	})
	t.Run("should insert and return multiple tokens", func(t *testing.T) {
		t.Parallel()
		d := setupDb(t)

		underTest := authentication.NewDbSqlite(d)

		createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
		expiresAt := createAt.Add(24 * time.Hour)
		userId := uuid.New()
		expected1 := auth_types.NewToken(userId, "sessionId", "token1", auth_types.TokenTypeCsrf, createAt, expiresAt)
		expected2 := auth_types.NewToken(userId, "sessionId", "token2", auth_types.TokenTypeCsrf, createAt, expiresAt)

		err := underTest.InsertToken(context.Background(), expected1)
		require.NoError(t, err)
		err = underTest.InsertToken(context.Background(), expected2)
		require.NoError(t, err)

		expected1.UserId = uuid.Nil
		expected2.UserId = uuid.Nil
		actuals, err := underTest.GetTokensBySessionIdAndType(context.Background(), expected1.SessionId, expected1.Type)
		require.NoError(t, err)
		assert.Equal(t, []*auth_types.Token{expected1, expected2}, actuals)

		expected1.SessionId = ""
		expected2.SessionId = ""
		expected1.UserId = userId
		expected2.UserId = userId
		actuals, err = underTest.GetTokensByUserIdAndType(context.Background(), userId, expected1.Type)
		require.NoError(t, err)
		assert.Equal(t, []*auth_types.Token{expected1, expected2}, actuals)
	})
	t.Run("should return ErrNotFound", func(t *testing.T) {
		t.Parallel()
		d := setupDb(t)

		underTest := authentication.NewDbSqlite(d)

		_, err := underTest.GetToken(context.Background(), "nonExistent")
		assert.Equal(t, core.ErrNotFound, err)

		_, err = underTest.GetTokensByUserIdAndType(context.Background(), uuid.New(), auth_types.TokenTypeEmailVerify)
		assert.Equal(t, core.ErrNotFound, err)

		_, err = underTest.GetTokensBySessionIdAndType(context.Background(), "sessionId", auth_types.TokenTypeEmailVerify)
		assert.Equal(t, core.ErrNotFound, err)
	})
	t.Run("should return ErrAlreadyExists", func(t *testing.T) {
		t.Parallel()
		d := setupDb(t)

		underTest := authentication.NewDbSqlite(d)

		verifiedAt := time.Date(2020, 1, 5, 13, 0, 0, 0, time.UTC)
		createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
		user := auth_types.NewUser(uuid.New(), "some@email.de", true, &verifiedAt, false, []byte("somePass"), []byte("someSalt"), createAt)

		err := underTest.InsertUser(context.Background(), user)
		require.NoError(t, err)

		err = underTest.InsertUser(context.Background(), user)
		assert.Equal(t, core.ErrAlreadyExists, err)
	})
	t.Run("should return ErrInternal on missing NOT NULL fields", func(t *testing.T) {
		t.Parallel()
		d := setupDb(t)

		underTest := authentication.NewDbSqlite(d)

		createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
		user := auth_types.NewUser(uuid.New(), "some@email.de", false, nil, false, []byte("somePass"), nil, createAt)

		err := underTest.InsertUser(context.Background(), user)
		assert.Equal(t, core.ErrInternal, err)
	})
}