package query

import (
	"context"
	"errors"
	"queryorchestration/internal/database"
	"queryorchestration/internal/database/repository"
	resultprocessor "queryorchestration/internal/query/result/processor"
	"queryorchestration/internal/serviceconfig"
	"testing"

	"github.com/google/uuid"
	"github.com/pashagolub/pgxmock/v3"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestNormalizeConfig(t *testing.T) {
	s := Service{}

	err := s.NormalizeConfig(nil)
	assert.NoError(t, err)

	entity := resultprocessor.Create{}

	entity.Config = nil
	err = s.NormalizeConfig(&entity)
	assert.NoError(t, err)
	assert.Nil(t, entity.Config)

	cfg := ""
	entity.Config = &cfg
	err = s.NormalizeConfig(&entity)
	assert.NoError(t, err)
	assert.Nil(t, entity.Config)

	cfg = "   	"
	entity.Config = &cfg
	err = s.NormalizeConfig(&entity)
	assert.NoError(t, err)
	assert.Nil(t, entity.Config)

	cfg = "{}"
	entity.Config = &cfg
	err = s.NormalizeConfig(&entity)
	assert.NoError(t, err)
	assert.Equal(t, "{}", *(entity.Config))

	cfg = "{\"hello\":\"bye\"}"
	entity.Config = &cfg
	err = s.NormalizeConfig(&entity)
	assert.NoError(t, err)
	assert.Equal(t, "{\"hello\":\"bye\"}", *(entity.Config))

	cfg = "		   {  \"hello\"  :  	\"bye\"   }     "
	entity.Config = &cfg
	err = s.NormalizeConfig(&entity)
	assert.NoError(t, err)
	assert.Equal(t, "{\"hello\":\"bye\"}", *(entity.Config))

	cfg = "{'hello':'bye'}"
	entity.Config = &cfg
	err = s.NormalizeConfig(&entity)
	assert.Error(t, err)

	cfg = "{\"hello\":\"}"
	entity.Config = &cfg
	err = s.NormalizeConfig(&entity)
	assert.Error(t, err)
}

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

	pool, err := pgxmock.NewPool()
	require.NoError(t, err)
	cfg := &serviceconfig.BaseConfig{}
	cfg.DBPool = pool
	cfg.DBQueries = repository.New(pool)
	s := Service{cfg: cfg}

	err = s.NormalizeQueryIDs(ctx, nil)
	assert.NoError(t, err)

	entity := resultprocessor.Create{}

	entity.RequiredQueryIDs = nil
	err = s.NormalizeQueryIDs(ctx, &entity)
	assert.NoError(t, err)
	assert.Nil(t, entity.RequiredQueryIDs)

	entity.RequiredQueryIDs = &[]uuid.UUID{}
	err = s.NormalizeQueryIDs(ctx, &entity)
	assert.NoError(t, err)
	assert.Nil(t, entity.RequiredQueryIDs)

	ids := []uuid.UUID{uuid.New()}
	entity.RequiredQueryIDs = &ids
	dbids := database.MustToDBUUIDArray(*entity.RequiredQueryIDs)

	pool.ExpectQuery("name: AllQueriesExist :one").WithArgs(dbids).WillReturnRows(
		pgxmock.NewRows([]string{"all_exist"}).
			AddRow(true),
	)

	err = s.NormalizeQueryIDs(ctx, &entity)
	assert.NoError(t, err)
	assert.ElementsMatch(t, ids, *entity.RequiredQueryIDs)

	pool.ExpectQuery("name: AllQueriesExist :one").WithArgs(dbids).WillReturnRows(
		pgxmock.NewRows([]string{"all_exist"}).
			AddRow(false),
	)

	err = s.NormalizeQueryIDs(ctx, &entity)
	assert.Error(t, err)
	assert.ElementsMatch(t, ids, *entity.RequiredQueryIDs)

	pool.ExpectQuery("name: AllQueriesExist :one").WithArgs(dbids).
		WillReturnError(errors.New("database failure"))

	err = s.NormalizeQueryIDs(ctx, &entity)
	assert.Error(t, err)
	assert.ElementsMatch(t, ids, *entity.RequiredQueryIDs)

	singleid := uuid.New()
	entity.RequiredQueryIDs = &[]uuid.UUID{singleid, singleid}
	outids := []uuid.UUID{singleid}
	dbids = database.MustToDBUUIDArray(outids)

	pool.ExpectQuery("name: AllQueriesExist :one").WithArgs(dbids).WillReturnRows(
		pgxmock.NewRows([]string{"all_exist"}).
			AddRow(true),
	)

	err = s.NormalizeQueryIDs(ctx, &entity)
	assert.NoError(t, err)
	assert.ElementsMatch(t, outids, *entity.RequiredQueryIDs)
}

func TestNormalizeActiveVersion(t *testing.T) {
	s := Service{}

	t.Run("all nil", func(t *testing.T) {
		err := s.NormalizeActiveVersion(nil, nil)
		assert.Error(t, err)
	})

	t.Run("nil current", func(t *testing.T) {
		entity := resultprocessor.Update{}

		err := s.NormalizeActiveVersion(nil, &entity)
		assert.Error(t, err)
	})

	t.Run("nil update", func(t *testing.T) {
		current := Query{
			ActiveVersion: 2,
			LatestVersion: 4,
		}
		err := s.NormalizeActiveVersion(&current, nil)
		assert.NoError(t, err)
	})

	t.Run("no update", func(t *testing.T) {
		current := Query{
			ActiveVersion: 2,
			LatestVersion: 4,
		}
		entity := resultprocessor.Update{}
		err := s.NormalizeActiveVersion(&current, &entity)
		assert.NoError(t, err)
		assert.Nil(t, entity.ActiveVersion)
	})

	t.Run("equal update to current", func(t *testing.T) {
		current := Query{
			ActiveVersion: 2,
			LatestVersion: 4,
		}
		version := int32(2)
		entity := resultprocessor.Update{
			ActiveVersion: &version,
		}
		err := s.NormalizeActiveVersion(&current, &entity)
		assert.NoError(t, err)
		assert.Nil(t, entity.ActiveVersion)
	})

	t.Run("valid update", func(t *testing.T) {
		current := Query{
			ActiveVersion: 2,
			LatestVersion: 4,
		}
		version := int32(3)
		entity := resultprocessor.Update{
			ActiveVersion: &version,
		}
		err := s.NormalizeActiveVersion(&current, &entity)
		assert.NoError(t, err)
		assert.Equal(t, version, *entity.ActiveVersion)
	})

	t.Run("update greater than latest by 1", func(t *testing.T) {
		current := Query{
			ActiveVersion: 2,
			LatestVersion: 4,
		}
		version := int32(5)
		entity := resultprocessor.Update{
			ActiveVersion: &version,
		}
		err := s.NormalizeActiveVersion(&current, &entity)
		assert.NoError(t, err)
		assert.Equal(t, version, *entity.ActiveVersion)
	})

	t.Run("update greater than latest by 2", func(t *testing.T) {
		current := Query{
			ActiveVersion: 2,
			LatestVersion: 4,
		}
		version := int32(6)
		entity := resultprocessor.Update{
			ActiveVersion: &version,
		}
		err := s.NormalizeActiveVersion(&current, &entity)
		assert.Error(t, err)
	})

	t.Run("update to 0", func(t *testing.T) {
		current := Query{
			ActiveVersion: 2,
			LatestVersion: 4,
		}
		version := int32(0)
		entity := resultprocessor.Update{
			ActiveVersion: &version,
		}
		err := s.NormalizeActiveVersion(&current, &entity)
		assert.Error(t, err)
	})
}