package repository_test

import (
	"context"
	"os"
	"path"
	"queryorchestration/internal/database"
	"queryorchestration/internal/database/repository"
	"queryorchestration/internal/test"
	"testing"

	"github.com/google/uuid"
	"github.com/jackc/pgx/v5/pgtype"
	"github.com/stretchr/testify/assert"
)

func TestQueries(t *testing.T) {
	ctx := context.Background()

	db, cleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{
		Migrations: &database.MigrationConfig{
			BasePath: path.Join(os.Getenv("PWD"), "../../.."),
		}})
	defer cleanup()

	queries := repository.New(db.Pool)

	contextQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeContextFull))
	assert.Nil(t, err)
	assert.True(t, contextQueryID.Valid)

	jsonQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeJsonExtractor))
	assert.Nil(t, err)
	assert.True(t, jsonQueryID.Valid)

	jsonQuery, err := queries.GetQuery(ctx, jsonQueryID)
	assert.Nil(t, err)
	assert.EqualExportedValues(t, &repository.Fullactivequery{
		ID:            jsonQueryID,
		Type:          repository.QuerytypeJsonExtractor,
		Activeversion: 1,
		Latestversion: 1,
		Config:        nil,
		Requiredids:   []pgtype.UUID{database.MustToDBUUID(uuid.Nil)},
	}, jsonQuery)

	err = queries.UpdateQuery(ctx, &repository.UpdateQueryParams{
		Latestversion: 2,
		Activeversion: 1,
		ID:            jsonQueryID,
	})
	assert.Nil(t, err)

	jsonConfig := []byte("{\"path\": \"example_path\"}")

	err = queries.AddRequiredQuery(ctx, &repository.AddRequiredQueryParams{
		Queryid:         jsonQueryID,
		Requiredqueryid: contextQueryID,
		Addedversion:    1,
	})
	assert.Nil(t, err)

	removeV := int32(2)
	err = queries.RemoveRequiredQuery(ctx, &repository.RemoveRequiredQueryParams{
		Queryid:         jsonQueryID,
		Requiredqueryid: contextQueryID,
		Removedversion:  &removeV,
	})
	assert.Nil(t, err)

	err = queries.AddQueryConfig(ctx, &repository.AddQueryConfigParams{
		Queryid:      jsonQueryID,
		Config:       jsonConfig,
		Addedversion: 1,
	})
	assert.Nil(t, err)

	jsonQueryConfig, err := queries.GetQueryConfig(ctx, &repository.GetQueryConfigParams{
		Queryid:      jsonQueryID,
		Addedversion: jsonQuery.Activeversion,
	})
	assert.Nil(t, err)
	assert.Equal(t, jsonConfig, jsonQueryConfig.Config)

	removeV = 2
	err = queries.RemoveQueryConfig(ctx, &repository.RemoveQueryConfigParams{
		Queryid:        jsonQueryID,
		Removedversion: &removeV,
	})
	assert.Nil(t, err)

	_, err = queries.GetQueryConfig(ctx, &repository.GetQueryConfigParams{
		Queryid:      jsonQueryID,
		Addedversion: jsonQuery.Activeversion,
	})
	assert.EqualError(t, err, "no rows in result set")

	jsonQuery, err = queries.GetQuery(ctx, jsonQueryID)
	assert.Nil(t, err)
	assert.EqualExportedValues(t, &repository.Fullactivequery{
		ID:            jsonQueryID,
		Type:          repository.QuerytypeJsonExtractor,
		Activeversion: 1,
		Latestversion: 2,
		Config:        jsonConfig,
		Requiredids:   []pgtype.UUID{contextQueryID},
	}, jsonQuery)

	err = queries.UpdateQuery(ctx, &repository.UpdateQueryParams{
		Activeversion: 2,
		Latestversion: 2,
		ID:            jsonQueryID,
	})
	assert.Nil(t, err)

	jsonQuery, err = queries.GetQuery(ctx, jsonQueryID)
	assert.Nil(t, err)
	assert.EqualExportedValues(t, &repository.Fullactivequery{
		ID:            jsonQueryID,
		Type:          repository.QuerytypeJsonExtractor,
		Activeversion: 2,
		Latestversion: 2,
		Config:        nil,
		Requiredids:   []pgtype.UUID{database.MustToDBUUID(uuid.Nil)},
	}, jsonQuery)

	all_exist, err := queries.AllQueriesExist(ctx, []pgtype.UUID{})
	assert.Nil(t, err)
	assert.True(t, all_exist)

	all_exist, err = queries.AllQueriesExist(ctx, []pgtype.UUID{database.MustToDBUUID(uuid.New())})
	assert.Nil(t, err)
	assert.False(t, all_exist)

	all_exist, err = queries.AllQueriesExist(ctx, []pgtype.UUID{jsonQueryID})
	assert.Nil(t, err)
	assert.True(t, all_exist)

	all_exist, err = queries.AllQueriesExist(ctx, []pgtype.UUID{jsonQueryID, contextQueryID})
	assert.Nil(t, err)
	assert.True(t, all_exist)

	all_exist, err = queries.AllQueriesExist(ctx, []pgtype.UUID{jsonQueryID, database.MustToDBUUID(uuid.New())})
	assert.Nil(t, err)
	assert.False(t, all_exist)
}

func TestQueryDependencyTree(t *testing.T) {
	ctx := context.Background()

	db, cleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{
		Migrations: &database.MigrationConfig{
			BasePath: path.Join(os.Getenv("PWD"), "../../.."),
		}})
	defer cleanup()

	queries := repository.New(db.Pool)

	contextQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeContextFull))
	assert.Nil(t, err)

	jsonQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeJsonExtractor))
	assert.Nil(t, err)
	err = queries.AddRequiredQuery(ctx, &repository.AddRequiredQueryParams{
		Queryid:         jsonQueryID,
		Requiredqueryid: contextQueryID,
		Addedversion:    1,
	})
	assert.Nil(t, err)

	secondJsonQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeJsonExtractor))
	assert.Nil(t, err)
	err = queries.AddRequiredQuery(ctx, &repository.AddRequiredQueryParams{
		Queryid:         secondJsonQueryID,
		Requiredqueryid: jsonQueryID,
		Addedversion:    1,
	})
	assert.Nil(t, err)

	isdependent, err := queries.IsQueryInDependencyTree(ctx, &repository.IsQueryInDependencyTreeParams{
		Requiredqueryid: jsonQueryID,
		ID:              []pgtype.UUID{contextQueryID},
	})
	assert.Nil(t, err)
	assert.False(t, isdependent)

	isdependent, err = queries.IsQueryInDependencyTree(ctx, &repository.IsQueryInDependencyTreeParams{
		Requiredqueryid: jsonQueryID,
		ID:              []pgtype.UUID{secondJsonQueryID},
	})
	assert.Nil(t, err)
	assert.True(t, isdependent)

	isdependent, err = queries.IsQueryInDependencyTree(ctx, &repository.IsQueryInDependencyTreeParams{
		Requiredqueryid: jsonQueryID,
		ID:              []pgtype.UUID{jsonQueryID},
	})
	assert.Nil(t, err)
	assert.True(t, isdependent)

	isdependent, err = queries.IsQueryInDependencyTree(ctx, &repository.IsQueryInDependencyTreeParams{
		Requiredqueryid: secondJsonQueryID,
		ID:              []pgtype.UUID{jsonQueryID, contextQueryID},
	})
	assert.Nil(t, err)
	assert.False(t, isdependent)

	isdependent, err = queries.IsQueryInDependencyTree(ctx, &repository.IsQueryInDependencyTreeParams{
		Requiredqueryid: contextQueryID,
		ID:              []pgtype.UUID{jsonQueryID, secondJsonQueryID},
	})
	assert.Nil(t, err)
	assert.True(t, isdependent)
}

func TestQueriesList(t *testing.T) {
	ctx := context.Background()

	db, cleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{
		Migrations: &database.MigrationConfig{
			BasePath: "../../..",
		}})
	defer cleanup()

	queries := repository.New(db.Pool)

	contextQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeContextFull))
	assert.Nil(t, err)

	jsonQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeJsonExtractor))
	assert.Nil(t, err)

	qs, err := queries.ListQueries(ctx)
	assert.Nil(t, err)
	assert.Len(t, qs, 2)
	assert.ElementsMatch(t, []*repository.Fullactivequery{
		{
			ID:            jsonQueryID,
			Type:          repository.QuerytypeJsonExtractor,
			Activeversion: 1,
			Latestversion: 1,
			Config:        nil,
			Requiredids:   []pgtype.UUID{{}},
		},
		{
			ID:            contextQueryID,
			Type:          repository.QuerytypeContextFull,
			Activeversion: 1,
			Latestversion: 1,
			Config:        nil,
			Requiredids:   []pgtype.UUID{{}},
		},
	}, qs)
}