package db

import (
	"database/sql"
	"me-fit/types"
	"testing"
	"time"

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

func setupDb(t *testing.T) *sql.DB {
	db, err := sql.Open("sqlite3", ":memory:")
	if err != nil {
		t.Fatalf("Error opening database: %v", err)
	}
	t.Cleanup(func() {
		db.Close()
	})

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

	return db
}

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

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

		underTest := AuthSqlite{db: db}

		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 := NewUser(uuid.New(), "some@email.de", true, &verifiedAt, false, []byte("somePass"), []byte("someSalt"), createAt)

		err := underTest.InsertUser(expected)
		assert.Nil(t, err)

		actual, err := underTest.GetUser(expected.Id)
		assert.Nil(t, err)
		assert.Equal(t, expected, actual)

		actual, err = underTest.GetUserByEmail(expected.Email)
		assert.Nil(t, err)
		assert.Equal(t, expected, actual)
	})
	t.Run("should return UserNotFound", func(t *testing.T) {
		t.Parallel()
		db := setupDb(t)

		underTest := AuthSqlite{db: db}

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

		underTest := AuthSqlite{db: db}

		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 := NewUser(uuid.New(), "some@email.de", true, &verifiedAt, false, []byte("somePass"), []byte("someSalt"), createAt)

		err := underTest.InsertUser(user)
		assert.Nil(t, err)

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

		underTest := AuthSqlite{db: db}

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

		err := underTest.InsertUser(user)
		assert.Equal(t, types.ErrInternal, err)
	})
}

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

	t.Run("should return NotFound", func(t *testing.T) {
		t.Parallel()
		db := setupDb(t)

		underTest := AuthSqlite{db: db}

		token, err := underTest.GetToken("someNonExistentToken")

		assert.Equal(t, ErrNotFound, err)
		assert.Nil(t, token)
	})
	t.Run("should insert and return token", func(t *testing.T) {
		t.Parallel()
		db := setupDb(t)

		underTest := AuthSqlite{db: db}
		tokenStr := "some secure token"
		createdAt := time.Date(2020, 1, 5, 13, 0, 0, 0, time.UTC)

		expectedToken := NewToken(uuid.New(), tokenStr, TokenTypeEmailVerify, createdAt, createdAt.Add(24*time.Hour))

		err := underTest.InsertToken(expectedToken)
		assert.Nil(t, err)

		actualToken, err := underTest.GetToken(tokenStr)
		assert.Nil(t, err)

		t.Logf("expectedToken: %v", expectedToken)
		t.Logf("actualToken: %v", actualToken)
		assert.Equal(t, expectedToken, actualToken)
	})
}