package processor

import (
	"testing"

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

func TestDeepEqual(t *testing.T) {
	tests := []struct {
		name     string
		a        interface{}
		b        interface{}
		expected bool
	}{
		{
			name:     "both nil",
			a:        nil,
			b:        nil,
			expected: true,
		},
		{
			name:     "first nil",
			a:        nil,
			b:        "something",
			expected: false,
		},
		{
			name:     "second nil",
			a:        "something",
			b:        nil,
			expected: false,
		},
		{
			name:     "equal primitives",
			a:        42,
			b:        42,
			expected: true,
		},
		{
			name:     "different primitives",
			a:        42,
			b:        43,
			expected: false,
		},
		{
			name:     "equal strings",
			a:        "hello",
			b:        "hello",
			expected: true,
		},
		{
			name: "equal maps",
			a: map[string]interface{}{
				"key1": "value1",
				"key2": 42,
			},
			b: map[string]interface{}{
				"key1": "value1",
				"key2": 42,
			},
			expected: true,
		},
		{
			name: "maps different lengths",
			a: map[string]interface{}{
				"key1": "value1",
			},
			b: map[string]interface{}{
				"key1": "value1",
				"key2": 42,
			},
			expected: false,
		},
		{
			name: "maps different values",
			a: map[string]interface{}{
				"key1": "value1",
			},
			b: map[string]interface{}{
				"key1": "value2",
			},
			expected: false,
		},
		{
			name: "map vs non-map",
			a: map[string]interface{}{
				"key1": "value1",
			},
			b:        "not a map",
			expected: false,
		},
		{
			name:     "equal arrays",
			a:        []interface{}{1, 2, 3},
			b:        []interface{}{1, 2, 3},
			expected: true,
		},
		{
			name:     "arrays different lengths",
			a:        []interface{}{1, 2},
			b:        []interface{}{1, 2, 3},
			expected: false,
		},
		{
			name:     "arrays different values",
			a:        []interface{}{1, 2, 3},
			b:        []interface{}{1, 2, 4},
			expected: false,
		},
		{
			name:     "array vs non-array",
			a:        []interface{}{1, 2, 3},
			b:        "not an array",
			expected: false,
		},
		{
			name: "nested equal structures",
			a: map[string]interface{}{
				"outer": map[string]interface{}{
					"inner": []interface{}{1, 2, 3},
				},
			},
			b: map[string]interface{}{
				"outer": map[string]interface{}{
					"inner": []interface{}{1, 2, 3},
				},
			},
			expected: true,
		},
		{
			name: "nested different structures",
			a: map[string]interface{}{
				"outer": map[string]interface{}{
					"inner": []interface{}{1, 2, 3},
				},
			},
			b: map[string]interface{}{
				"outer": map[string]interface{}{
					"inner": []interface{}{1, 2, 4},
				},
			},
			expected: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := deepEqual(tt.a, tt.b)
			assert.Equal(t, tt.expected, result)
		})
	}
}