package repository_test

import (
	"codeword/internal/models"
	"codeword/internal/repository"
	"context"
	"fmt"
	"github.com/stretchr/testify/require"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
	"testing"
	"time"

	"github.com/pioz/faker"
	"github.com/stretchr/testify/assert"
)

// todo add another tests

const mongoURI = "mongodb://test:test@127.0.0.1:27020/?authMechanism=SCRAM-SHA-256&authSource=admin&directConnection=true"

// codeword unit tests
func TestFindByEmail(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	client, err := mongo.Connect(ctx, options.Client().ApplyURI(mongoURI))
	if err != nil {
		log.Fatalf("Failed to connect to MongoDB: %v", err)
	}

	defer func() {
		if err := client.Disconnect(ctx); err != nil {
			log.Fatalf("Failed to disconnect MongoDB client: %v", err)
		}
	}()

	if err := client.Ping(ctx, nil); err != nil {
		log.Fatalf("Failed to ping MongoDB: %v", err)
	}

	db := client.Database("admin")

	userRepo := repository.NewUserRepository(repository.Deps{Rdb: nil, Mdb: db.Collection("users")})

	t.Run("FindByEmail - existing user", func(t *testing.T) {
		user, err := userRepo.FindByEmail(ctx, "admin")
		assert.NoError(t, err)
		assert.NotNil(t, user)
		fmt.Println(user.Email)
		assert.Equal(t, "admin", user.Login)
	})

	t.Run("FindByEmail - non-existing user", func(t *testing.T) {
		user, err := userRepo.FindByEmail(ctx, "neadmin")
		assert.NoError(t, err)
		assert.Nil(t, user)
	})

}

func TestStoreRecoveryRecord(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	mongoClient, err := mongo.Connect(ctx, options.Client().ApplyURI(mongoURI))
	require.NoError(t, err)

	defer func() {
		_ = mongoClient.Disconnect(ctx)
	}()

	database := mongoClient.Database("admin")
	codeword := database.Collection("codeword")
	_ = codeword.Drop(ctx)

	userRepo := repository.NewCodewordRepository(repository.Deps{Rdb: nil, Mdb: codeword})

	for i := 0; i < 10; i++ {
		userID := faker.String()
		email := faker.Email()
		key := "test_recovery_key"

		id, err := userRepo.StoreRecoveryRecord(ctx, models.StoreRecDeps{UserID: userID, Email: email, Key: key, Url: "def.url"})
		assert.NoError(t, err)
		fmt.Println(id)

		var storedRecord models.RestoreRequest
		err = codeword.FindOne(ctx, bson.M{"user_id": userID}).Decode(&storedRecord)
		assert.NoError(t, err)
		assert.Equal(t, email, storedRecord.Email)
		assert.Equal(t, key, storedRecord.Sign)
	}

	_ = database.Drop(ctx)
}

func TestGetRecoveryRecord(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	mongoClient, err := mongo.Connect(ctx, options.Client().ApplyURI(mongoURI))
	require.NoError(t, err)

	defer func() {
		_ = mongoClient.Disconnect(ctx)
	}()

	database := mongoClient.Database("admin")
	codeword := database.Collection("codeword")
	_ = codeword.Drop(ctx)

	userRepo := repository.NewCodewordRepository(repository.Deps{Rdb: nil, Mdb: codeword})

	ID := primitive.NewObjectID()
	userID := "6597babdd1ba7e2dbd32d7e3"
	email := "test@mail.ru"
	key := "test_recovery_key"

	record := models.RestoreRequest{
		ID:        ID,
		UserID:    userID,
		Email:     email,
		Sign:      key,
		SignUrl:   "def.url",
		SignID:    key + userID,
		CreatedAt: time.Now(),
	}

	_, err = codeword.InsertOne(ctx, record)
	assert.NoError(t, err)

	result, err := userRepo.GetRecoveryRecord(ctx, key+userID)
	assert.NoError(t, err)
	assert.Equal(t, userID, result.UserID)
	assert.Equal(t, email, result.Email)
	assert.Equal(t, key, result.Sign)

	_ = database.Drop(ctx)
}

// promocode unit tests