pointer_test.go

package jsonpointer_test

import (
	"encoding/json"
	"errors"
	"fmt"
	"reflect"
	"strings"
	"testing"

	"github.com/agentflare-ai/go-jsonpointer"
)

// rfc6901Doc is the example JSON document from RFC 6901, Section 5.
var rfc6901Doc = []byte(`
{
   "foo": ["bar", "baz"],
   "": 0,
   "a/b": 1,
   "c%d": 2,
   "e^f": 3,
   "g|h": 4,
   "i\\j": 5,
   "k\"l": 6,
   " ": 7,
   "m~n": 8
}`)

// unmarshalJSON is a helper to unmarshal JSON into an interface{}.
// It abstracts away the error handling for tests.
func unmarshalJSON(t testing.TB, data []byte) interface{} {
	var doc interface{}
	err := json.Unmarshal(data, &doc)
	if err != nil {
		t.Fatalf("Failed to unmarshal JSON: %v", err)
	}
	return doc
}

// TestNew_Valid tests the New function with various valid JSON Pointer strings.
func TestNew_Valid(t *testing.T) {
	tests := []struct {
		name       string
		pointerStr string
		expected   jsonpointer.Pointer
	}{
		{
			name:       "empty string (root)",
			pointerStr: "",
			expected:   jsonpointer.Pointer{},
		},
		{
			name:       "single token",
			pointerStr: "/foo",
			expected:   jsonpointer.Pointer{"foo"},
		},
		{
			name:       "multiple tokens",
			pointerStr: "/foo/bar/baz",
			expected:   jsonpointer.Pointer{"foo", "bar", "baz"},
		},
		{
			name:       "root with empty token (RFC example for key \"\")",
			pointerStr: "/",
			expected:   jsonpointer.Pointer{""},
		},
		{
			name:       "tilde escape (~0 -> ~)",
			pointerStr: "/m~0n",
			expected:   jsonpointer.Pointer{"m~n"},
		},
		{
			name:       "slash escape (~1 -> /)",
			pointerStr: "/a~1b",
			expected:   jsonpointer.Pointer{"a/b"},
		},
		{
			name:       "mixed escapes",
			pointerStr: "/foo~0bar~1baz",
			expected:   jsonpointer.Pointer{"foo~bar/baz"},
		},
		{
			name:       "chained escapes (RFC rule: ~1 before ~0; ~01 becomes ~1)",
			pointerStr: "/~01", // This token, per spec, becomes "~1"
			expected:   jsonpointer.Pointer{"~1"},
		},
		{
			name:       "array index 0",
			pointerStr: "/foo/0",
			expected:   jsonpointer.Pointer{"foo", "0"},
		},
		{
			name:       "array index 123",
			pointerStr: "/bar/123",
			expected:   jsonpointer.Pointer{"bar", "123"},
		},
		{
			name:       "complex token with percent (RFC example)",
			pointerStr: "/c%d",
			expected:   jsonpointer.Pointer{"c%d"},
		},
		{
			name:       "complex token with space (RFC example)",
			pointerStr: "/ ",
			expected:   jsonpointer.Pointer{" "},
		},
		{
			name:       "complex token with backslash (RFC example)",
			pointerStr: "/i\\j",
			expected:   jsonpointer.Pointer{"i\\j"},
		},
		{
			name:       "complex token with quote (RFC example)",
			pointerStr: "/k\"l",
			expected:   jsonpointer.Pointer{"k\"l"},
		},
		{
			name:       "complex token with caret (RFC example)",
			pointerStr: "/e^f",
			expected:   jsonpointer.Pointer{"e^f"},
		},
		{
			name:       "complex token with pipe (RFC example)",
			pointerStr: "/g|h",
			expected:   jsonpointer.Pointer{"g|h"},
		},
		{
			name:       "double slash (empty tokens)",
			pointerStr: "//",
			expected:   jsonpointer.Pointer{"", ""},
		},
		{
			name:       "triple slash (more empty tokens)",
			pointerStr: "///",
			expected:   jsonpointer.Pointer{"", "", ""},
		},
		{
			name:       "empty token in middle",
			pointerStr: "/a//b",
			expected:   jsonpointer.Pointer{"a", "", "b"},
		},
		{
			name:       "trailing slash (empty last token)",
			pointerStr: "/a/b/",
			expected:   jsonpointer.Pointer{"a", "b", ""},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			p, err := jsonpointer.New(tt.pointerStr)
			if err != nil {
				t.Errorf("New(%q) unexpected error: %v", tt.pointerStr, err)
			}
			if !reflect.DeepEqual(p, tt.expected) {
				t.Errorf("New(%q) got %v, want %v", tt.pointerStr, p, tt.expected)
			}
		})
	}
}

func TestNewPointer_Nested(t *testing.T) {
	data := map[string]interface{}{
		"12345": map[string]interface{}{
			"mjw": map[string]interface{}{
				"pull_tag": "mjw-pull-e7b680b8",
				"load_tag": "mjw-load-e7b680b8",
			},
		},
	}
	p, err := jsonpointer.New("/12345/mjw")
	if err != nil {
		t.Fatalf("NewPointer(%q) failed: %v", "/12345/mjw", err)
	}
	val, err := p.Get(data)
	if err != nil {
		t.Fatalf("Get(%q) failed: %v", "/12345/mjw", err)
	}
	if val, ok := val.(map[string]interface{}); !ok {
		t.Fatalf("Get(%q) got %v, want %v", "/12345/mjw", val, "mjw-pull-e7b680b8")
	}
}

// TestNew_Invalid tests the New function with various invalid JSON Pointer strings.
func TestNew_Invalid(t *testing.T) {
	tests := []struct {
		name        string
		pointerStr  string
		expectedErr error
	}{
		{
			name:        "starts without slash",
			pointerStr:  "foo",
			expectedErr: jsonpointer.ErrInvalidSyntax,
		},
		{
			name:        "invalid escape sequence (tilde alone at end)",
			pointerStr:  "/foo/~",
			expectedErr: jsonpointer.ErrInvalidSyntax,
		},
		{
			name:        "invalid escape sequence (tilde alone in middle)",
			pointerStr:  "/foo~/bar",
			expectedErr: jsonpointer.ErrInvalidSyntax,
		},
		{
			name:        "invalid escape sequence (tilde followed by non-0/1)",
			pointerStr:  "/foo/~2",
			expectedErr: jsonpointer.ErrInvalidSyntax,
		},
		{
			name:        "invalid escape sequence (tilde followed by arbitrary char)",
			pointerStr:  "/foo/~x",
			expectedErr: jsonpointer.ErrInvalidSyntax,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			p, err := jsonpointer.New(tt.pointerStr)
			if err == nil {
				t.Errorf("New(%q) expected an error, got %v", tt.pointerStr, p)
			} else if !errors.Is(err, tt.expectedErr) {
				t.Errorf("New(%q) expected error type %v, got %v (actual: %v)", tt.pointerStr, tt.expectedErr, err, err)
			}
		})
	}
}

// TestGet_RFC6901Examples tests the Get function against the examples provided in RFC 6901.
func TestGet_RFC6901Examples(t *testing.T) {
	doc := unmarshalJSON(t, rfc6901Doc)

	tests := []struct {
		name        string
		pointerStr  string
		docOverride interface{} // Allows using a custom document for this test case
		expectedVal interface{}
		expectedErr error
	}{
		{
			name:        "RFC: empty pointer (root)",
			pointerStr:  "",
			expectedVal: doc,
		},
		{
			name:        "RFC: /foo",
			pointerStr:  "/foo",
			expectedVal: []interface{}{"bar", "baz"},
		},
		{
			name:        "RFC: /foo/0",
			pointerStr:  "/foo/0",
			expectedVal: "bar",
		},
		{
			name:        "RFC: /",
			pointerStr:  "/",
			expectedVal: float64(0), // json.Unmarshal converts numbers to float64
		},
		{
			name:        "RFC: /a~1b",
			pointerStr:  "/a~1b",
			expectedVal: float64(1),
		},
		{
			name:        "RFC: /c%d",
			pointerStr:  "/c%d",
			expectedVal: float64(2),
		},
		{
			name:        "RFC: /e^f",
			pointerStr:  "/e^f",
			expectedVal: float64(3),
		},
		{
			name:        "RFC: /g|h",
			pointerStr:  "/g|h",
			expectedVal: float64(4),
		},
		{
			name:        "RFC: /i\\j",
			pointerStr:  "/i\\j",
			expectedVal: float64(5),
		},
		{
			name:        "RFC: /k\"l",
			pointerStr:  "/k\"l",
			expectedVal: float64(6),
		},
		{
			name:        "RFC: / ",
			pointerStr:  "/ ",
			expectedVal: float64(7),
		},
		{
			name:        "RFC: /m~0n",
			pointerStr:  "/m~0n",
			expectedVal: float64(8),
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			p, err := jsonpointer.New(tt.pointerStr)
			if err != nil {
				t.Fatalf("New(%q) failed: %v", tt.pointerStr, err)
			}

			currentDoc := doc
			if tt.docOverride != nil {
				currentDoc = tt.docOverride
			}
			val, err := p.Get(currentDoc)
			if tt.expectedErr != nil {
				if err == nil {
					t.Errorf("Get(%q) expected error %v, got nil", tt.pointerStr, tt.expectedErr)
				} else if !errors.Is(err, tt.expectedErr) {
					t.Errorf("Get(%q) expected error type %v, got %v (actual: %v)", tt.pointerStr, tt.expectedErr, err, err)
				}
			} else {
				if err != nil {
					t.Errorf("Get(%q) unexpected error: %v", tt.pointerStr, err)
				}
				if !reflect.DeepEqual(val, tt.expectedVal) {
					t.Errorf("Get(%q) got %v (type %T), want %v (type %T)", tt.pointerStr, val, val, tt.expectedVal, tt.expectedVal)
				}
			}
		})
	}
}

// TestGet_Errors tests the Get function for various error conditions.
func TestGet_Errors(t *testing.T) {
	var doc interface{}
	_ = json.Unmarshal([]byte(`
		{
			"a": {
				"b": [1, 2, {"c": 3}],
				"d": null
			},
			"x": "hello",
			"y": 123,
			"z": [1, "two", 3],
			"empty_map": {},
			"empty_array": []
		}
	`), &doc)

	tests := []struct {
		name        string
		pointerStr  string
		document    interface{}
		expectedErr error
		errContains string
	}{
		{
			name:        "key not found",
			pointerStr:  "/a/e",
			document:    doc,
			expectedErr: jsonpointer.ErrNotFound,
		},
		{
			name:        "array index out of bounds",
			pointerStr:  "/a/b/3",
			document:    doc,
			expectedErr: jsonpointer.ErrNotFound,
		},
		{
			name:        "non-numeric array index",
			pointerStr:  "/a/b/foo",
			document:    doc,
			expectedErr: jsonpointer.ErrInvalidIndex,
		},
		{
			name:        "array index with leading zero (not '0')",
			pointerStr:  "/a/b/01",
			document:    doc,
			expectedErr: jsonpointer.ErrInvalidIndex,
		},
		{
			name:        "dereferencing primitive value (string)",
			pointerStr:  "/x/y",
			document:    doc,
			expectedErr: jsonpointer.ErrNotAnObjectOrArray,
		},
		{
			name:        "dereferencing primitive value (number)",
			pointerStr:  "/y/foo",
			document:    doc,
			expectedErr: jsonpointer.ErrNotAnObjectOrArray,
		},
		{
			name:        "dereferencing into null value",
			pointerStr:  "/a/d/foo",
			document:    doc,
			expectedErr: jsonpointer.ErrNotFound, // Path led to nil, then tried to dereference
		},
		{
			name:        "array append index '-' used for retrieval",
			pointerStr:  "/a/b/-",
			document:    doc,
			expectedErr: jsonpointer.ErrArrayAppendIndexOnly,
		},
		// New test cases for advanced error scenarios
		{
			name:        "nil document with non-empty pointer",
			pointerStr:  "/a",
			document:    nil, // The whole document is nil
			expectedErr: jsonpointer.ErrNotFound,
			errContains: "encountered nil value at token 'a' (path segment 0)",
		},
		{
			name:        "reflection: dereference nil pointer to map",
			pointerStr:  "/a/b",
			document:    map[string]interface{}{"a": (*map[string]interface{})(nil)},
			expectedErr: jsonpointer.ErrNotFound,
			errContains: "encountered nil value via reflection at token 'b' (path segment 1)",
		},
		{
			name:        "reflection: dereference nil pointer to slice",
			pointerStr:  "/a/0",
			document:    map[string]interface{}{"a": (*[]interface{})(nil)},
			expectedErr: jsonpointer.ErrNotFound,
			errContains: "encountered nil value via reflection at token '0' (path segment 1)",
		},
		{
			name:       "reflection: key not found in map pointed to by interface{}",
			pointerStr: "/a/key_not_exists",
			document: func() interface{} {
				var ifaceVal interface{}
				m := map[string]interface{}{"actual_key": 123}
				ifaceVal = &m // interface containing a pointer to a map
				return map[string]interface{}{"a": ifaceVal}
			}(),
			expectedErr: jsonpointer.ErrNotFound,
			errContains: "key 'key_not_exists' not found via reflection (path segment 1)",
		},
		{
			name:       "reflection: index out of bounds in slice pointed to by interface{}",
			pointerStr: "/a/1",
			document: func() interface{} {
				var ifaceVal interface{}
				s := []interface{}{"val0"}
				ifaceVal = &s // interface containing a pointer to a slice
				return map[string]interface{}{"a": ifaceVal}
			}(),
			expectedErr: jsonpointer.ErrNotFound,
			errContains: "array index 1 out of bounds (length 1) via reflection (path segment 1)",
		},
		// Tests for reflect.Array error scenarios
		{
			name:        "reflection: index out of bounds for reflect.Array",
			pointerStr:  "/arr/2",
			document:    map[string]interface{}{"arr": [2]string{"hello", "world"}},
			expectedErr: jsonpointer.ErrNotFound,
			errContains: "array index 2 out of bounds (length 2) via reflection (path segment 1)",
		},
		{
			name:        "reflection: invalid index for reflect.Array (non-numeric)",
			pointerStr:  "/arr/abc",
			document:    map[string]interface{}{"arr": [1]string{"hello"}},
			expectedErr: jsonpointer.ErrInvalidIndex,
			errContains: "'abc' is not a valid array index via reflection (path segment 1)",
		},
		{
			name:        "reflection: invalid index for reflect.Array (leading zero)",
			pointerStr:  "/arr/01",
			document:    map[string]interface{}{"arr": [2]string{"a", "b"}},
			expectedErr: jsonpointer.ErrInvalidIndex,
			errContains: "'01' is not a valid array index via reflection (path segment 1)",
		},
		{
			name:        "reflection: '-' index for reflect.Array",
			pointerStr:  "/arr/-",
			document:    map[string]interface{}{"arr": [1]string{"hello"}},
			expectedErr: jsonpointer.ErrArrayAppendIndexOnly,
			errContains: "array append index '-' cannot be used for retrieval via reflection (path segment 1)",
		},
		{
			name:        "pointer on nil document (empty pointer) - should pass",
			pointerStr:  "",
			document:    nil,
			expectedErr: nil, // Should return nil, nil
		},
		{
			name:        "pointer on nil document (non-empty pointer)",
			pointerStr:  "/foo",
			document:    nil,
			expectedErr: jsonpointer.ErrNotFound,
		},
		{
			name:        "map with non-string keys (should fail as per spec context)",
			pointerStr:  "/1",
			document:    map[int]interface{}{1: "value"}, // This is a non-standard map in Go, not produced by json.Unmarshal
			expectedErr: jsonpointer.ErrNotAnObjectOrArray,
		},
		{
			name:        "navigating into empty array",
			pointerStr:  "/empty_array/0",
			document:    doc,
			expectedErr: jsonpointer.ErrNotFound,
		},
		{
			name:        "navigating into empty map",
			pointerStr:  "/empty_map/foo",
			document:    doc,
			expectedErr: jsonpointer.ErrNotFound,
		},
		{
			name:        "complex path leading to primitive, then trying to dereference",
			pointerStr:  "/a/b/2/c/invalid",
			document:    doc,
			expectedErr: jsonpointer.ErrNotAnObjectOrArray, // key 'invalid' not found in {"c":3}
		},
		{
			name:        "complex path leading to nil, then trying to dereference",
			pointerStr:  "/a/d/invalid",
			document:    doc,
			expectedErr: jsonpointer.ErrNotFound, // 'd' is nil, cannot dereference 'invalid'
		},
		{
			name:        "empty array index string",
			pointerStr:  "/z/", // This means "/z/empty_token" for parsing, which is not a valid number
			document:    doc,
			expectedErr: jsonpointer.ErrInvalidIndex,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			p, err := jsonpointer.New(tt.pointerStr)
			if err != nil {
				t.Fatalf("New(%q) failed unexpectedly: %v", tt.pointerStr, err)
			}

			_, err = p.Get(tt.document)
			if tt.expectedErr != nil {
				if err == nil {
					t.Errorf("Get(%q) expected error %v, got nil", tt.pointerStr, tt.expectedErr)
				} else if !errors.Is(err, tt.expectedErr) {
					t.Errorf("Get(%q) expected error type %v, got %v (actual: %v)", tt.pointerStr, tt.expectedErr, err, err)
				}
			} else {
				if err != nil {
					t.Errorf("Get(%q) unexpected error: %v", tt.pointerStr, err)
				}
			}
		})
	}
}

// TestGet_PrimitiveDocument tests the Get function when the root document itself is a primitive JSON value.
func TestGet_PrimitiveDocument(t *testing.T) {
	tests := []struct {
		name        string
		doc         interface{}
		pointerStr  string
		expectedVal interface{}
		expectedErr error
	}{
		{
			name:        "string document, root pointer",
			doc:         "hello",
			pointerStr:  "",
			expectedVal: "hello",
			expectedErr: nil,
		},
		{
			name:        "number document, root pointer",
			doc:         float64(123),
			pointerStr:  "",
			expectedVal: float64(123),
			expectedErr: nil,
		},
		{
			name:        "boolean document, root pointer",
			doc:         true,
			pointerStr:  "",
			expectedVal: true,
			expectedErr: nil,
		},
		{
			name:        "null document, root pointer",
			doc:         nil,
			pointerStr:  "",
			expectedVal: nil,
			expectedErr: nil,
		},
		{
			name:        "string document, non-root pointer",
			doc:         "hello",
			pointerStr:  "/foo",
			expectedErr: jsonpointer.ErrNotAnObjectOrArray,
		},
		{
			name:        "number document, non-root pointer",
			doc:         float64(123),
			pointerStr:  "/0",
			expectedErr: jsonpointer.ErrNotAnObjectOrArray,
		},
		{
			name:        "boolean document, non-root pointer",
			doc:         false,
			pointerStr:  "/key",
			expectedErr: jsonpointer.ErrNotAnObjectOrArray,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			p, err := jsonpointer.New(tt.pointerStr)
			if err != nil {
				t.Fatalf("New(%q) failed: %v", tt.pointerStr, err)
			}

			val, err := p.Get(tt.doc)
			if tt.expectedErr != nil {
				if err == nil {
					t.Errorf("Get(%q) expected error %v, got nil", tt.pointerStr, tt.expectedErr)
				} else if !errors.Is(err, tt.expectedErr) {
					t.Errorf("Get(%q) expected error type %v, got %v (actual: %v)", tt.pointerStr, tt.expectedErr, err, err)
				}
			} else {
				if err != nil {
					t.Errorf("Get(%q) unexpected error: %v", tt.pointerStr, err)
				}
				if !reflect.DeepEqual(val, tt.expectedVal) {
					t.Errorf("Get(%q) got %v (type %T), want %v (type %T)", tt.pointerStr, val, val, tt.expectedVal, tt.expectedVal)
				}
			}
		})
	}
}

// TestPointer_String tests the String method of the Pointer type.
func TestPointer_String(t *testing.T) {
	tests := []struct {
		name     string
		pointer  jsonpointer.Pointer
		expected string
	}{
		{
			name:     "empty pointer (root)",
			pointer:  jsonpointer.Pointer{},
			expected: "",
		},
		{
			name:     "single token",
			pointer:  jsonpointer.Pointer{"foo"},
			expected: "/foo",
		},
		{
			name:     "multiple tokens",
			pointer:  jsonpointer.Pointer{"foo", "bar", "baz"},
			expected: "/foo/bar/baz",
		},
		{
			name:     "token with tilde",
			pointer:  jsonpointer.Pointer{"m~n"},
			expected: "/m~0n",
		},
		{
			name:     "token with slash",
			pointer:  jsonpointer.Pointer{"a/b"},
			expected: "/a~1b",
		},
		{
			name:     "token with tilde and slash",
			pointer:  jsonpointer.Pointer{"~a/b~"},
			expected: "/~0a~1b~0",
		},
		{
			name:     "empty token",
			pointer:  jsonpointer.Pointer{""},
			expected: "/",
		},
		{
			name:     "multiple empty tokens",
			pointer:  jsonpointer.Pointer{"", ""},
			expected: "//",
		},
		{
			name:     "mixed empty and non-empty tokens",
			pointer:  jsonpointer.Pointer{"a", "", "b"},
			expected: "/a//b",
		},
		{
			name:     "token with space",
			pointer:  jsonpointer.Pointer{" "},
			expected: "/ ",
		},
		{
			name:     "token needing no escape",
			pointer:  jsonpointer.Pointer{"plain"},
			expected: "/plain",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := tt.pointer.String()
			if got != tt.expected {
				t.Errorf("Pointer.String() got %q, want %q", got, tt.expected)
			}
		})
	}
}

// TestSet tests the Set function for various success and error conditions.
func TestSet(t *testing.T) {
	tests := []struct {
		name          string
		initialDoc    string      // Initial JSON document
		pointerStr    string      // JSON Pointer string
		valueToSet    interface{} // The value to set at the pointer's location
		expectedDoc   string      // The expected JSON document after setting the value
		expectedErr   error       // The expected error, if any
		checkErrIs    bool        // Whether to use errors.Is for checking the error
		checkContains string      // A substring that the error message should contain
	}{
		// Success cases
		{
			name:        "set value in existing object",
			initialDoc:  `{"a": 1, "b": 2}`,
			pointerStr:  "/a",
			valueToSet:  float64(100),
			expectedDoc: `{"a": 100, "b": 2}`,
		},
		{
			name:        "set value in existing nested object",
			initialDoc:  `{"a": {"b": {"c": 1}}}`,
			pointerStr:  "/a/b/c",
			valueToSet:  "new value",
			expectedDoc: `{"a": {"b": {"c": "new value"}}}`,
		},
		{
			name:        "add new key to object",
			initialDoc:  `{"a": 1}`,
			pointerStr:  "/b",
			valueToSet:  "new",
			expectedDoc: `{"a": 1, "b": "new"}`,
		},
		{
			name:        "create nested objects",
			initialDoc:  `{}`,
			pointerStr:  "/a/b/c",
			valueToSet:  true,
			expectedDoc: `{"a": {"b": {"c": true}}}`,
		},
		{
			name:        "set value in existing array",
			initialDoc:  `[1, 2, 3]`,
			pointerStr:  "/1",
			valueToSet:  "two",
			expectedDoc: `[1, "two", 3]`,
		},
		{
			name:        "append to array with '-'",
			initialDoc:  `[1, 2]`,
			pointerStr:  "/-",
			valueToSet:  float64(3),
			expectedDoc: `[1, 2, 3]`,
		},
		{
			name:        "append to array with explicit index",
			initialDoc:  `[1, 2]`,
			pointerStr:  "/2",
			valueToSet:  float64(3),
			expectedDoc: `[1, 2, 3]`,
		},
		{
			name:        "create new array and append",
			initialDoc:  `{}`,
			pointerStr:  "/a/-",
			valueToSet:  "first",
			expectedDoc: `{"a": ["first"]}`,
		},
		{
			name:        "replace entire document",
			initialDoc:  `{"a": 1}`,
			pointerStr:  "",
			valueToSet:  map[string]interface{}{"b": float64(2)},
			expectedDoc: `{"b": 2}`,
		},
		{
			name:        "set value in nil document",
			initialDoc:  `null`,
			pointerStr:  "/a/b",
			valueToSet:  "hello",
			expectedDoc: `{"a": {"b": "hello"}}`,
		},

		// Error cases
		{
			name:        "index out of bounds for array",
			initialDoc:  `[1, 2]`,
			pointerStr:  "/3",
			valueToSet:  "invalid",
			expectedErr: jsonpointer.ErrNotFound,
			checkErrIs:  true,
		},
		{
			name:        "invalid array index",
			initialDoc:  `[1, 2]`,
			pointerStr:  "/abc",
			valueToSet:  "invalid",
			expectedErr: jsonpointer.ErrInvalidIndex,
			checkErrIs:  true,
		},
		{
			name:          "'-' not as last token",
			initialDoc:    `[1, 2]`,
			pointerStr:    "/-/a",
			valueToSet:    "invalid",
			expectedErr:   jsonpointer.ErrInvalidIndex,
			checkErrIs:    true,
			checkContains: "'-' may only be the last token",
		},
		{
			name:        "dereference non-object/array",
			initialDoc:  `{"a": "string"}`,
			pointerStr:  "/a/b",
			valueToSet:  "invalid",
			expectedErr: jsonpointer.ErrNotAnObjectOrArray,
			checkErrIs:  true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			var initialDoc, expectedDoc interface{}
			if err := json.Unmarshal([]byte(tt.initialDoc), &initialDoc); err != nil {
				t.Fatalf("Failed to unmarshal initialDoc: %v", err)
			}
			if tt.expectedDoc != "" {
				if err := json.Unmarshal([]byte(tt.expectedDoc), &expectedDoc); err != nil {
					t.Fatalf("Failed to unmarshal expectedDoc: %v", err)
				}
			}

			p, err := jsonpointer.New(tt.pointerStr)
			if err != nil {
				t.Fatalf("New(%q) failed: %v", tt.pointerStr, err)
			}

			modifiedDoc, err := p.Set(initialDoc, tt.valueToSet)

			if tt.expectedErr != nil {
				if err == nil {
					t.Errorf("Set() expected error, but got nil")
				} else {
					if tt.checkErrIs && !errors.Is(err, tt.expectedErr) {
						t.Errorf("Set() error type = %v, want %v", err, tt.expectedErr)
					}
					if tt.checkContains != "" && !strings.Contains(err.Error(), tt.checkContains) {
						t.Errorf("Set() error message = %q, want to contain %q", err.Error(), tt.checkContains)
					}
				}
			} else {
				if err != nil {
					t.Errorf("Set() unexpected error: %v", err)
				}
				if !reflect.DeepEqual(modifiedDoc, expectedDoc) {
					modifiedJSON, _ := json.Marshal(modifiedDoc)
					expectedJSON, _ := json.Marshal(expectedDoc)
					t.Errorf("Set() result mismatch:\ngot:  %s\nwant: %s", modifiedJSON, expectedJSON)
				}
			}
		})
	}
}

// TestRemove tests the Remove function for various success and error conditions.
func TestRemove(t *testing.T) {
	tests := []struct {
		name        string
		initialDoc  string // Initial JSON document
		pointerStr  string // JSON Pointer string
		expectedDoc string // The expected JSON document after removal
		expectedErr error  // The expected error, if any
	}{
		// Success cases
		{
			name:        "remove from object",
			initialDoc:  `{"a": 1, "b": 2}`,
			pointerStr:  "/a",
			expectedDoc: `{"b": 2}`,
		},
		{
			name:        "remove from nested object",
			initialDoc:  `{"a": {"b": {"c": 1, "d": 2}}}`,
			pointerStr:  "/a/b/c",
			expectedDoc: `{"a": {"b": {"d": 2}}}`,
		},
		{
			name:        "remove from array",
			initialDoc:  `[1, 2, 3]`,
			pointerStr:  "/1",
			expectedDoc: `[1, 3]`,
		},
		{
			name:        "remove last element from array",
			initialDoc:  `[1, 2, 3]`,
			pointerStr:  "/2",
			expectedDoc: `[1, 2]`,
		},

		// Error cases
		{
			name:        "remove non-existent key",
			initialDoc:  `{"a": 1}`,
			pointerStr:  "/b",
			expectedErr: jsonpointer.ErrNotFound,
		},
		{
			name:        "remove index out of bounds",
			initialDoc:  `[1, 2]`,
			pointerStr:  "/2",
			expectedErr: jsonpointer.ErrNotFound,
		},
		{
			name:        "remove from non-object/array",
			initialDoc:  `{"a": "string"}`,
			pointerStr:  "/a/b",
			expectedErr: jsonpointer.ErrNotAnObjectOrArray,
		},
		{
			name:        "remove root",
			initialDoc:  `{"a": 1}`,
			pointerStr:  "",
			expectedErr: errors.New("cannot remove the root"),
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			var initialDoc, expectedDoc interface{}
			if err := json.Unmarshal([]byte(tt.initialDoc), &initialDoc); err != nil {
				t.Fatalf("Failed to unmarshal initialDoc: %v", err)
			}
			if tt.expectedDoc != "" {
				if err := json.Unmarshal([]byte(tt.expectedDoc), &expectedDoc); err != nil {
					t.Fatalf("Failed to unmarshal expectedDoc: %v", err)
				}
			}

			modifiedDoc, err := jsonpointer.Remove(initialDoc, tt.pointerStr)

			if tt.expectedErr != nil {
				if err == nil {
					t.Errorf("Remove() expected error, but got nil")
				} else if !errors.Is(err, tt.expectedErr) && !strings.Contains(err.Error(), tt.expectedErr.Error()) {
					t.Errorf("Remove() error type = %T, want %T. Error: %v, want: %v", err, tt.expectedErr, err, tt.expectedErr)
				}
			} else {
				if err != nil {
					t.Errorf("Remove() unexpected error: %v", err)
				}
				if !reflect.DeepEqual(modifiedDoc, expectedDoc) {
					modifiedJSON, _ := json.Marshal(modifiedDoc)
					expectedJSON, _ := json.Marshal(expectedDoc)
					t.Errorf("Remove() result mismatch:\ngot:  %s\nwant: %s", modifiedJSON, expectedJSON)
				}
			}
		})
	}
}

// Benchmarks for performance measurement.
func BenchmarkNew(b *testing.B) {
	pointers := []string{
		"",
		"/foo",
		"/foo/bar",
		"/foo/bar/baz/0/qux/1/norf",
		"/a~1b/c%d/e^f/g|h/i\\j/k\"l/m~0n",
		// Note: The original test string had "/g h" and "/m~n" which are problematic.
		// "g h" is a valid token, but the space might cause issues with some shell/tooling. Changed to "g|h" for consistency with RFC examples.
		// "m~n" is an invalid escape sequence. Changed to "m~0n" to represent "m~n" as a key per RFC 6901.
		"/long/path/with/many/segments/that/is/quite/deep/and/has/a/few/escapes/~0/~1/last/token",
	}

	for _, ptrStr := range pointers {
		b.Run(fmt.Sprintf("New_%s", strings.ReplaceAll(ptrStr, "/", "_")), func(b *testing.B) {
			for i := 0; i < b.N; i++ {
				_, err := jsonpointer.New(ptrStr)
				if err != nil {
					b.Fatal(err)
				}
			}
		})
	}
}

func BenchmarkGet(b *testing.B) {
	// Document 1: RFC 6901 example document
	var docRFC interface{}
	err := json.Unmarshal(rfc6901Doc, &docRFC)
	if err != nil {
		b.Fatalf("Failed to unmarshal RFC JSON: %v", err)
	}

	// Document 2: A larger, more deeply nested document for realistic benchmarks
	largeDocJSON := `{
		"metadata": {
			"id": "12345",
			"version": 1.0,
			"tags": ["alpha", "beta"],
			"source": {"name": "example.com"}
		},
		"data": {
			"items": [
				{"name": "item1", "value": 100, "details": {"color": "red", "size": "M"}},
				{"name": "item2", "value": 200, "details": {"color": "blue", "size": "L"}},
				{"name": "item3", "value": 300, "details": {"color": "green", "size": "XL"}},
				{"name": "item4", "value": 400, "details": {"color": "yellow", "size": "S", "meta": {"owner": "userA"}}}
			],
			"summary": {
				"totalItems": 4,
				"maxValue": 400
			}
		},
		"user~info": {
			"name/email": "test@example.com"
		},
		"array": [
			1,
			2,
			{"a": "b"},
			[4, 5, 6],
			"final"
		]
	}`
	var largeDoc interface{}
	err = json.Unmarshal([]byte(largeDocJSON), &largeDoc)
	if err != nil {
		b.Fatalf("Failed to unmarshal large JSON: %v", err)
	}

	tests := []struct {
		name       string
		pointerStr string
		document   interface{}
	}{
		{"RFC_root", "", docRFC},
		{"RFC_simple", "/foo", docRFC},
		{"RFC_array_index", "/foo/0", docRFC},
		{"RFC_escaped_key_slash", "/a~1b", docRFC},
		{"RFC_escaped_key_tilde", "/m~0n", docRFC},
		{"LargeDoc_root", "", largeDoc},
		{"LargeDoc_simple_object", "/data", largeDoc},
		{"LargeDoc_nested_array_item_middle", "/data/items/1/value", largeDoc},
		{"LargeDoc_deep_nested_object", "/data/items/3/details/meta/owner", largeDoc},
		{"LargeDoc_escaped_key_deep", "/user~0info/name~1email", largeDoc},
		{"LargeDoc_array_element_complex", "/array/2/a", largeDoc},
		{"LargeDoc_array_nested_array_element", "/array/3/1", largeDoc},
		{"LargeDoc_array_last_primitive", "/array/4", largeDoc},
		{"LargeDoc_nonexistent_key", "/data/items/5", largeDoc}, // Will result in ErrNotFound, still tests traversal path
		{"LargeDoc_nonexistent_nested_key", "/metadata/source/url", largeDoc},
		{"LargeDoc_invalid_array_index", "/data/items/01", largeDoc},
	}

	// Pre-parse pointers to separate parsing time from getting time
	pointers := make(map[string]jsonpointer.Pointer)
	for _, tt := range tests {
		p, err := jsonpointer.New(tt.pointerStr)
		if err != nil {
			b.Fatalf("Failed to create pointer for %q: %v", tt.pointerStr, err)
		}
		pointers[tt.pointerStr] = p
	}

	b.ResetTimer() // Reset timer before the actual benchmark loop
	for _, tt := range tests {
		b.Run(fmt.Sprintf("Get_%s", strings.ReplaceAll(tt.pointerStr, "/", "_")), func(b *testing.B) {
			p := pointers[tt.pointerStr]
			for i := 0; i < b.N; i++ {
				_, err := p.Get(tt.document)
				// Asserting error here to ensure valid benchmark run for expected failures
				if err != nil && !errors.Is(err, jsonpointer.ErrNotFound) && !errors.Is(err, jsonpointer.ErrInvalidIndex) {
					b.Fatal(err)
				}
			}
		})
	}
}

func BenchmarkSet(b *testing.B) {
	largeDocJSON := `{
		"metadata": {
			"id": "12345",
			"version": 1.0,
			"tags": ["alpha", "beta"],
			"source": {"name": "example.com"}
		},
		"data": {
			"items": [
				{"name": "item1", "value": 100, "details": {"color": "red", "size": "M"}},
				{"name": "item2", "value": 200, "details": {"color": "blue", "size": "L"}},
				{"name": "item3", "value": 300, "details": {"color": "green", "size": "XL"}},
				{"name": "item4", "value": 400, "details": {"color": "yellow", "size": "S", "meta": {"owner": "userA"}}}
			],
			"summary": {
				"totalItems": 4,
				"maxValue": 400
			}
		},
		"user~info": {
			"name/email": "test@example.com"
		},
		"array": [
			1,
			2,
			{"a": "b"},
			[4, 5, 6],
			"final"
		]
	}`

	tests := []struct {
		name       string
		pointerStr string
		valueToSet interface{}
	}{
		{"Set_simple_replace", "/metadata/version", 2.0},
		{"Set_nested_item", "/data/items/1/value", 250.0},
		{"Set_deep_add", "/data/items/3/details/meta/new_key", "new_value"},
		{"Set_append", "/data/items/-", map[string]interface{}{"name": "item5"}},
		{"Set_create_path", "/new/path/to/value", "created"},
		{"Set_escaped_key", "/user~0info/name~1email", "new@example.com"},
	}

	pointers := make(map[string]jsonpointer.Pointer)
	for _, tt := range tests {
		p, err := jsonpointer.New(tt.pointerStr)
		if err != nil {
			b.Fatalf("Failed to create pointer for %q: %v", tt.pointerStr, err)
		}
		pointers[tt.name] = p
	}

	b.ResetTimer()

	for _, tt := range tests {
		b.Run(tt.name, func(b *testing.B) {
			p := pointers[tt.name]
			// Unmarshal the document once before the loop.
			var doc interface{}
			if err := json.Unmarshal([]byte(largeDocJSON), &doc); err != nil {
				b.Fatalf("unmarshal failed: %v", err)
			}

			b.ReportAllocs()
			b.ResetTimer()

			for i := 0; i < b.N; i++ {
				// We are intentionally mutating the same doc in this loop to isolate
				// the Set performance from the unmarshal performance.
				_, err := p.Set(doc, tt.valueToSet)
				if err != nil {
					// Log instead of Fatal to avoid stopping the benchmark on non-critical errors.
					b.Logf("Set operation failed during benchmark: %v", err)
				}
			}
		})
	}
}

// BenchmarkGetVsGet compares the performance of using a pre-compiled Pointer
// versus the package-level Get function that parses on the fly.
func BenchmarkGetVsGet(b *testing.B) {
	doc := unmarshalJSON(b, rfc6901Doc)
	pointerStr := "/m~0n"
	p, _ := jsonpointer.New(pointerStr)

	b.Run("Pointer.Get", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			p.Get(doc)
		}
	})

	b.Run("package.Get", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			jsonpointer.Get(doc, pointerStr)
		}
	})
}

// BenchmarkSetVsSet compares the performance of using a pre-compiled Pointer
// for Set operations versus the package-level Set function.
func BenchmarkSetVsSet(b *testing.B) {
	pointerStr := "/a/b/c"
	value := "test"

	b.Run("Pointer.Set", func(b *testing.B) {
		p, _ := jsonpointer.New(pointerStr)
		for i := 0; i < b.N; i++ {
			var doc interface{} = make(map[string]interface{})
			p.Set(doc, value)
		}
	})

	b.Run("package.Set", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			var doc interface{} = make(map[string]interface{})
			jsonpointer.Set(doc, pointerStr, value)
		}
	})
}