// Copyright (C) 2019 Storj Labs, Inc.
// See LICENSE for copying information.

package console_test

import (
	"testing"
	"time"

	"github.com/skyrings/skyring-common/tools/uuid"
	"github.com/stretchr/testify/assert"

	"storj.io/storj/internal/testcontext"
	"storj.io/storj/satellite"
	"storj.io/storj/satellite/console"
	"storj.io/storj/satellite/satellitedb/satellitedbtest"
)

func TestUserRepository(t *testing.T) {
	//testing constants
	const (
		lastName    = "lastName"
		email       = "email@ukr.net"
		passValid   = "123456"
		name        = "name"
		newName     = "newName"
		newLastName = "newLastName"
		newEmail    = "newEmail@ukr.net"
		newPass     = "newPass1234567890123456789012345"
	)

	satellitedbtest.Run(t, func(t *testing.T, db satellite.DB) {
		ctx := testcontext.New(t)
		defer ctx.Cleanup()

		repository := db.Console().Users()

		t.Run("User insertion success", func(t *testing.T) {
			id, err := uuid.New()
			assert.NoError(t, err)

			user := &console.User{
				ID:           *id,
				FirstName:    name,
				LastName:     lastName,
				Email:        email,
				PasswordHash: []byte(passValid),
				CreatedAt:    time.Now(),
			}

			_, err = repository.Insert(ctx, user)
			assert.NoError(t, err)
		})

		t.Run("Can't insert user with same email twice", func(t *testing.T) {
			user := &console.User{
				FirstName:    name,
				LastName:     lastName,
				Email:        email,
				PasswordHash: []byte(passValid),
				CreatedAt:    time.Now(),
			}

			_, err := repository.Insert(ctx, user)
			assert.Error(t, err)
		})

		t.Run("Get user success", func(t *testing.T) {
			userByEmail, err := repository.GetByEmail(ctx, email)
			assert.Equal(t, userByEmail.FirstName, name)
			assert.Equal(t, userByEmail.LastName, lastName)
			assert.NoError(t, err)

			userByID, err := repository.Get(ctx, userByEmail.ID)
			assert.Equal(t, userByID.FirstName, name)
			assert.Equal(t, userByID.LastName, lastName)
			assert.NoError(t, err)

			assert.Equal(t, userByID.ID, userByEmail.ID)
			assert.Equal(t, userByID.FirstName, userByEmail.FirstName)
			assert.Equal(t, userByID.LastName, userByEmail.LastName)
			assert.Equal(t, userByID.Email, userByEmail.Email)
			assert.Equal(t, userByID.PasswordHash, userByEmail.PasswordHash)
			assert.Equal(t, userByID.CreatedAt, userByEmail.CreatedAt)
		})

		t.Run("Update user success", func(t *testing.T) {
			oldUser, err := repository.GetByEmail(ctx, email)
			assert.NoError(t, err)

			newUser := &console.User{
				ID:           oldUser.ID,
				FirstName:    newName,
				LastName:     newLastName,
				Email:        newEmail,
				PasswordHash: []byte(newPass),
			}

			err = repository.Update(ctx, newUser)
			assert.NoError(t, err)

			newUser, err = repository.Get(ctx, oldUser.ID)
			assert.NoError(t, err)
			assert.Equal(t, newUser.ID, oldUser.ID)
			assert.Equal(t, newUser.FirstName, newName)
			assert.Equal(t, newUser.LastName, newLastName)
			assert.Equal(t, newUser.Email, newEmail)
			assert.Equal(t, newUser.PasswordHash, []byte(newPass))
			assert.Equal(t, newUser.CreatedAt, oldUser.CreatedAt)
		})

		t.Run("Delete user success", func(t *testing.T) {
			oldUser, err := repository.GetByEmail(ctx, newEmail)
			assert.NoError(t, err)

			err = repository.Delete(ctx, oldUser.ID)
			assert.NoError(t, err)

			_, err = repository.Get(ctx, oldUser.ID)
			assert.Error(t, err)
		})
	})
}