internal

type Codec interface {
	// Decode decodes a JSON operation object into an Op instance
	Decode(operation Operation) (Op, error)
	// DecodeSlice decodes an array of operations into an Op slice
	DecodeSlice(operations []Operation) ([]Op, error)
	// Encode encodes an Op instance into a JSON operation object
	Encode(op Op) (Operation, error)
	// EncodeSlice encodes an Op slice into an array of operations
	EncodeSlice(ops []Op) ([]Operation, error)
}

type CompactOperation = []interface{}

type Document interface {
	~[]byte | ~string | map[string]any | any
}

type JsonPatchOptions struct {
	CreateMatcher func(pattern string, ignoreCase bool) RegexMatcher
}

type JsonPatchTypes string

type Op interface {
	// Op returns the operation type string (e.g. "add", "remove", etc.)
	Op() OpType
	// Code returns the numeric code for the operation (consistent with constants)
	Code() int
	// Path returns the JSON Pointer path for the operation (slice form)
	Path() []string
	// Apply applies the operation to the document, returning the new document and old value
	Apply(doc any) (OpResult[any], error)
	// ToJSON returns the standard JSON Patch format
	ToJSON() (Operation, error)
	// ToCompact returns the compact array format
	ToCompact() (CompactOperation, error)
	// Validate validates the operation parameters
	Validate() error
}

type OpResult[T Document] struct {
	Doc T           `json:"doc"`
	Old interface{} `json:"old,omitempty"`
}

type OpType string

type Operation = map[string]interface{}

type Option func(*Options)

type Options struct {
	Mutate        bool                                               // Whether to modify the original document
	CreateMatcher func(pattern string, ignoreCase bool) RegexMatcher // Optional regex matcher creator
}

type PatchResult[T Document] struct {
	Doc T             // The patched document of the original type
	Res []OpResult[T] // Results of individual patch operations
}

type PredicateOp interface {
	Op
	// Test tests the operation on the document, returning whether it passed
	Test(doc any) (bool, error)
	// Not returns whether the operation is a negation predicate
	Not() bool
}

type RegexMatcher func(value string) bool

type SecondOrderPredicateOp interface {
	PredicateOp
	// Ops returns all sub-predicate operations
	Ops() []PredicateOp
}