package validation_test

import (
	"queryorchestration/internal/validation"
	"testing"

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

func TestGetUpdatedValue(t *testing.T) {
	assert.Equal(t, 1, validation.GetUpdatedValue(1, nil))
	val := 3
	assert.Equal(t, 3, validation.GetUpdatedValue(1, &val))

	assert.Equal(t, "hello", validation.GetUpdatedValue("hello", nil))
	valstr := "byebye"
	assert.Equal(t, "byebye", validation.GetUpdatedValue("hello", &valstr))
}

func TestDeduplicateArray(t *testing.T) {
	assert.ElementsMatch(t, []int{}, validation.DeduplicateArray([]int{}))
	assert.ElementsMatch(t, []int{1, 2, 3}, validation.DeduplicateArray([]int{1, 2, 3}))
	assert.ElementsMatch(t, []int{1, 2, 3}, validation.DeduplicateArray([]int{1, 2, 1, 3}))
	assert.ElementsMatch(t, []int{1}, validation.DeduplicateArray([]int{1, 1, 1, 1}))
	id := uuid.New()
	assert.ElementsMatch(t, []uuid.UUID{id}, validation.DeduplicateArray([]uuid.UUID{id, id, id}))
}

func TestNormalizeInClosedInterval(t *testing.T) {
	err := validation.NormalizeInClosedInterval(nil, 1, 1, 1)
	assert.NoError(t, err)

	var param *int32
	err = validation.NormalizeInClosedInterval(&param, 1, 1, 1)
	assert.NoError(t, err)
	assert.Nil(t, param)

	updated := int32(1)
	param = &updated
	err = validation.NormalizeInClosedInterval(&param, 1, 1, 1)
	assert.NoError(t, err)
	assert.Nil(t, param)
	assert.Equal(t, int32(1), updated)

	updated = -1
	param = &updated
	err = validation.NormalizeInClosedInterval(&param, 1, 1, 1)
	assert.Error(t, err)

	updated = 2
	param = &updated
	err = validation.NormalizeInClosedInterval(&param, 1, 1, 1)
	assert.Error(t, err)

	updated = 2
	param = &updated
	err = validation.NormalizeInClosedInterval(&param, 1, 1, 3)
	assert.NoError(t, err)
	assert.Equal(t, int32(2), updated)
}

func TestAreAllPointersNilExcept(t *testing.T) {
	t.Run("empty", func(t *testing.T) {
		assert.True(t, validation.AreAllPointersNilExcept(struct{}{}))
	})
	t.Run("no pointers", func(t *testing.T) {
		assert.True(t, validation.AreAllPointersNilExcept(struct{ field string }{field: "example_string"}))
	})
	t.Run("nil pointer", func(t *testing.T) {
		assert.True(t, validation.AreAllPointersNilExcept(struct{ field *string }{field: nil}))
	})
	t.Run("not nil pointer", func(t *testing.T) {
		field := "example string"
		assert.False(t, validation.AreAllPointersNilExcept(struct{ field *string }{field: &field}))
	})
	t.Run("multiple mixed pointers", func(t *testing.T) {
		fieldone := "example string"
		assert.False(t, validation.AreAllPointersNilExcept(struct {
			fieldone *string
			fieldtwo *string
		}{
			fieldone: &fieldone,
			fieldtwo: nil,
		}))
	})
	t.Run("multiple filled pointers", func(t *testing.T) {
		fieldone := "example string"
		assert.False(t, validation.AreAllPointersNilExcept(struct {
			fieldone *string
			fieldtwo *string
		}{
			fieldone: &fieldone,
			fieldtwo: &fieldone,
		}))
	})
	t.Run("multiple nil pointers", func(t *testing.T) {
		assert.True(t, validation.AreAllPointersNilExcept(struct {
			fieldone *string
			fieldtwo *string
		}{
			fieldone: nil,
			fieldtwo: nil,
		}))
	})
	t.Run("multiple pointers with exception", func(t *testing.T) {
		fieldone := "example string"
		type TestStruct struct {
			fieldone *string
			fieldtwo *string
		}
		val := TestStruct{
			fieldone: &fieldone,
			fieldtwo: nil,
		}
		assert.True(t, validation.AreAllPointersNilExcept(val, "fieldone"))
	})
	t.Run("multiple pointers with exception", func(t *testing.T) {
		fieldone := "example string"
		type TestStruct struct {
			fieldone   *string
			fieldtwo   *string
			fieldthree *string
		}
		val := TestStruct{
			fieldone:   &fieldone,
			fieldtwo:   &fieldone,
			fieldthree: nil,
		}
		assert.False(t, validation.AreAllPointersNilExcept(val, "fieldone"))
	})
	t.Run("invalid field name", func(t *testing.T) {
		type TestStruct struct {
			fieldone   *string
			fieldtwo   *string
			fieldthree *string
		}
		val := TestStruct{
			fieldone:   nil,
			fieldtwo:   nil,
			fieldthree: nil,
		}
		assert.True(t, validation.AreAllPointersNilExcept(val, "invalid_field"))
	})
}

func TestGetFieldName(t *testing.T) {
	t.Run("empty", func(t *testing.T) {
		name, err := validation.GetFieldName(struct{}{}, "")
		assert.EqualError(t, err, "field not found")
		assert.Empty(t, name)
	})
	t.Run("invalid field", func(t *testing.T) {
		name, err := validation.GetFieldName(struct{ field string }{field: ""}, "invalid_field")
		assert.EqualError(t, err, "field not found")
		assert.Empty(t, name)
	})
	t.Run("invalid field name", func(t *testing.T) {
		type TestStruct struct {
			fieldone *string
		}
		val := TestStruct{
			fieldone: nil,
		}
		name, err := validation.GetFieldName(val, "invalid_field")
		assert.EqualError(t, err, "field not found")
		assert.Empty(t, name)
	})
	t.Run("valid field is nil", func(t *testing.T) {
		type TestStruct struct {
			fieldone *string
		}
		val := TestStruct{
			fieldone: nil,
		}
		name, err := validation.GetFieldName(val, val.fieldone)
		assert.NoError(t, err)
		assert.Equal(t, "fieldone", name)
	})
	t.Run("valid field is populated", func(t *testing.T) {
		type TestStruct struct {
			fieldone *string
		}
		strval := "example_value"
		val := TestStruct{
			fieldone: &strval,
		}
		name, err := validation.GetFieldName(val, val.fieldone)
		assert.NoError(t, err)
		assert.Equal(t, "fieldone", name)
	})
}