package utils

import (
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestToPtr(t *testing.T) {
	t.Run("ToPtr with int", func(t *testing.T) {
		value := 42
		ptr := ToPtr(value)

		require.NotNil(t, ptr)
		assert.Equal(t, value, *ptr)
		assert.NotSame(t, &value, ptr, "Should return a new pointer")
	})

	t.Run("ToPtr with string", func(t *testing.T) {
		value := "test string"
		ptr := ToPtr(value)

		require.NotNil(t, ptr)
		assert.Equal(t, value, *ptr)
	})

	t.Run("ToPtr with bool", func(t *testing.T) {
		value := true
		ptr := ToPtr(value)

		require.NotNil(t, ptr)
		assert.Equal(t, value, *ptr)
	})

	t.Run("ToPtr with float64", func(t *testing.T) {
		value := 3.14159
		ptr := ToPtr(value)

		require.NotNil(t, ptr)
		assert.InEpsilon(t, value, *ptr, 0.0001)
	})

	t.Run("ToPtr with struct", func(t *testing.T) {
		type TestStruct struct {
			Field1 string
			Field2 int
		}

		value := TestStruct{Field1: "test", Field2: 123}
		ptr := ToPtr(value)

		require.NotNil(t, ptr)
		assert.Equal(t, value, *ptr)
		assert.Equal(t, "test", ptr.Field1)
		assert.Equal(t, 123, ptr.Field2)
	})

	t.Run("ToPtr with slice", func(t *testing.T) {
		value := []int{1, 2, 3}
		ptr := ToPtr(value)

		require.NotNil(t, ptr)
		assert.Equal(t, value, *ptr)
		assert.Len(t, *ptr, 3)
	})

	t.Run("ToPtr with map", func(t *testing.T) {
		value := map[string]int{"one": 1, "two": 2}
		ptr := ToPtr(value)

		require.NotNil(t, ptr)
		assert.Equal(t, value, *ptr)
		assert.Len(t, *ptr, 2)
	})

	t.Run("ToPtr with nil interface", func(t *testing.T) {
		var value any = nil
		ptr := ToPtr(value)

		require.NotNil(t, ptr)
		assert.Nil(t, *ptr)
	})

	t.Run("ToPtr with pointer", func(t *testing.T) {
		originalValue := 42
		originalPtr := &originalValue
		ptr := ToPtr(originalPtr)

		require.NotNil(t, ptr)
		assert.Equal(t, originalPtr, *ptr)
		assert.NotSame(t, originalPtr, ptr, "Should return a pointer to pointer")
	})

	t.Run("ToPtr with uint", func(t *testing.T) {
		value := uint(100)
		ptr := ToPtr(value)

		require.NotNil(t, ptr)
		assert.Equal(t, value, *ptr)
	})

	t.Run("ToPtr modification safety", func(t *testing.T) {
		value := 10
		ptr := ToPtr(value)

		*ptr = 20
		assert.Equal(t, 10, value, "Original value should not be modified")
		assert.Equal(t, 20, *ptr, "Pointer value should be modified")
	})

	t.Run("ToPtr with byte array", func(t *testing.T) {
		value := [3]byte{1, 2, 3}
		ptr := ToPtr(value)

		require.NotNil(t, ptr)
		assert.Equal(t, value, *ptr)
	})

	t.Run("ToPtr with rune", func(t *testing.T) {
		value := 'A'
		ptr := ToPtr(value)

		require.NotNil(t, ptr)
		assert.Equal(t, value, *ptr)
		assert.Equal(t, int32(65), *ptr)
	})

	t.Run("ToPtr with empty string", func(t *testing.T) {
		value := ""
		ptr := ToPtr(value)

		require.NotNil(t, ptr)
		assert.Equal(t, value, *ptr)
		assert.Empty(t, *ptr)
	})

	t.Run("ToPtr with zero values", func(t *testing.T) {
		// Test with various zero values
		intZero := 0
		intPtr := ToPtr(intZero)
		require.NotNil(t, intPtr)
		assert.Equal(t, 0, *intPtr)

		boolZero := false
		boolPtr := ToPtr(boolZero)
		require.NotNil(t, boolPtr)
		assert.False(t, *boolPtr)

		floatZero := 0.0
		floatPtr := ToPtr(floatZero)
		require.NotNil(t, floatPtr)
		assert.Equal(t, 0.0, *floatPtr) //nolint:testifylint
	})
}