eval.go

package validator

import (
	"context"
	"fmt"
	"reflect"
	"sort"
	"strconv"
	"strings"
	"sync"

	"github.com/libtnb/validator/conv"
)

// This file is the evaluation engine. A compiledField runs in two modes:
// evalCompiledField collects diagnostics for Validate, and fieldPasses
// answers Valid's yes/no without allocating. Both take a pooled Field, honor
// "sometimes" absence, run the container rules on the filtered value, then
// dive into each element of the raw collection. Dive elements are probed
// with the fast path first so the "field[i]" key is built only for failures,
// and map elements get deterministic labels. Rule and reflection panics are
// recovered into *RuleError.

var fieldPool = sync.Pool{New: func() any { return &Field{} }}

// evalCompiledField appends the field's failures to dst. Reflection panics
// become execution errors.
func (vd *Validation) evalCompiledField(
	ctx context.Context,
	cf compiledField,
	dst []FieldError,
) (out []FieldError, err error) {
	if err := context.Cause(ctx); err != nil {
		return dst, err
	}
	out = dst
	defer func() {
		if recovered := recover(); recovered != nil {
			// conv.ToString, not %v: a panic value whose String() panics must not re-escape recovery
			err = &RuleError{Field: cf.name, Err: fmt.Errorf("%w: %s", ErrRulePanic, conv.ToString(recovered))}
		}
	}()
	if cf.buildErr != nil {
		return dst, &RulesError{Field: cf.name, Err: cf.buildErr}
	}
	if vd.sometimesAbsent(cf) {
		return out, nil
	}
	if cf.container != nil {
		cval := vd.containerValue(cf)
		if cf.hasDive {
			cval = vd.rawValue(cf)
		}
		out, err = vd.evalCompiled(
			ctx,
			cf.name,
			cf.name,
			cf.container,
			cval,
			out,
		)
		if err != nil {
			return out, err
		}
	}
	if cf.hasDive && cf.element != nil {
		// dive uses the raw collection; filtering would stringify it.
		out, err = vd.evalDive(
			ctx,
			cf.name,
			cf.element,
			vd.rawValue(cf),
			out,
		)
	}
	return out, err
}

// sometimesAbsent reports whether a "sometimes" field is skipped; the source
// decides what absence means (a missing map key, a nil struct pointer).
func (vd *Validation) sometimesAbsent(cf compiledField) bool {
	if cf.container == nil || !cf.container.sometimes {
		return false
	}
	return vd.src.absent(cf.name)
}

// rawValue reads the field before filters. A struct plan carries the index
// path, which skips the by-name lookup.
func (vd *Validation) rawValue(cf compiledField) reflect.Value {
	if cf.index != nil {
		return vd.ss.byIndex(cf.index)
	}
	v, _ := vd.srcLookup(cf.name)
	return v
}

func (vd *Validation) containerValue(cf compiledField) reflect.Value {
	if vd.filtered != nil {
		if fv, ok := vd.filtered[cf.name]; ok {
			return toValue(fv)
		}
	}
	return vd.rawValue(cf)
}

func (vd *Validation) diag(field, msg string) FieldError {
	return FieldError{Field: field, Message: msg}
}

// evalCompiled runs one compiled program in diagnostic mode over a pooled
// Field; rule panics become execution errors. name is the error key; scope
// is the cross-field identity (the container name for dive elements) so
// sibling resolution matches the fast path exactly.
func (vd *Validation) evalCompiled(
	ctx context.Context,
	name string,
	scope string,
	compiled *compiled,
	val reflect.Value,
	dst []FieldError,
) (out []FieldError, err error) {
	f := fieldPool.Get().(*Field)
	f.name, f.scope, f.rv, f.ctx, f.vd = name, scope, val, ctx, vd
	out = dst
	defer func() {
		*f = Field{}
		fieldPool.Put(f)
		if recovered := recover(); recovered != nil {
			// conv.ToString, not %v: see evalCompiledField
			err = &RuleError{Field: name, Err: fmt.Errorf("%w: %s", ErrRulePanic, conv.ToString(recovered))}
		}
	}()
	_, out, err = compiled.Diag(f, dst)
	return out, err
}

func (vd *Validation) evalDive(
	ctx context.Context,
	name string,
	element *compiled,
	val reflect.Value,
	dst []FieldError,
) ([]FieldError, error) {
	// val is pre-unwrapped; invalid Value means nil container.
	if !val.IsValid() {
		return dst, nil
	}
	switch val.Kind() {
	case reflect.Slice, reflect.Array:
		for i := 0; i < val.Len(); i++ {
			// unwrap so rules see the pointee, matching every source
			ev := unwrapValue(val.Index(i))
			// fast probe first: the "field[i]" key is built only for a failing
			// element; custom rules must be deterministic.
			passes, err := vd.exprPasses(
				ctx,
				name,
				element,
				ev,
			)
			if err != nil {
				return dst, err
			}
			if passes {
				continue
			}
			dst, err = vd.evalCompiled(
				ctx,
				name+"["+strconv.Itoa(i)+"]",
				name,
				element,
				ev,
				dst,
			)
			if err != nil {
				return dst, err
			}
		}
	case reflect.Map:
		return vd.evalDiveMap(
			ctx,
			name,
			element,
			val,
			dst,
		)
	default:
		// non-collection: fail-closed if non-empty, else skip (omitempty)
		if !IsEmptyValue(val) {
			dst = append(dst, vd.diag(name, "validator: dive requires an array or map value"))
		}
	}
	return dst, nil
}

// evalDiveMap dives into a map. MapRange avoids MapIndex with NaN keys; type
// and ordinal suffixes keep rendered key collisions distinct.
func (vd *Validation) evalDiveMap(
	ctx context.Context,
	name string,
	element *compiled,
	rv reflect.Value,
	dst []FieldError,
) ([]FieldError, error) {
	type mentry struct {
		mapKeyOrder
		val reflect.Value
	}
	// Fast probe each entry first: the label machinery (stringify/sort/dedup)
	// runs only over failing entries, and only those need unique error keys.
	var failed []mentry
	for it := rv.MapRange(); it.Next(); {
		// unwrap so rules see the pointee, matching every source
		ev := unwrapValue(it.Value())
		passes, err := vd.exprPasses(
			ctx,
			name,
			element,
			ev,
		)
		if err != nil {
			return dst, err
		}
		if passes {
			continue
		}
		failed = append(failed, mentry{mapKeyOrder: mapKeyOrderOf(it.Key(), it.Value()), val: ev})
	}
	labels := mapFailureLabels(failed)
	for i, e := range failed {
		var err error
		dst, err = vd.evalCompiled(
			ctx,
			name+"["+labels[i]+"]",
			name,
			element,
			e.val,
			dst,
		)
		if err != nil {
			return dst, err
		}
	}
	return dst, nil
}

// mapKeyOrderOf renders a map entry for deterministic ordering and labels;
// the value may be cyclic, so it uses cycle-bounded conv.ToString.
func mapKeyOrderOf(k, v reflect.Value) mapKeyOrder {
	return mapKeyOrder{
		keyRepr: fmt.Sprintf("%v", k.Interface()),
		keyType: dynType(k).String(),
		valRepr: conv.ToString(v.Interface()),
		valType: dynType(v).String(),
	}
}

// mapFailureLabels sorts failing map entries into a total order and returns
// their unique error labels in that order: the rendered key, qualified by its
// type when two keys render alike and numbered when still equal. The total
// order makes labels independent of map iteration; only entries equal in all
// four fields (NaN keys) stay unordered.
func mapFailureLabels[E interface{ keyOrder() mapKeyOrder }](failed []E) []string {
	if len(failed) == 0 {
		return nil
	}
	sort.SliceStable(failed, func(a, b int) bool { return failed[a].keyOrder().less(failed[b].keyOrder()) })
	formatCount := make(map[string]int, len(failed))
	for i := range failed {
		formatCount[failed[i].keyOrder().keyRepr]++
	}
	labels := make([]string, len(failed))
	used := make(map[string]bool, len(failed))
	for i := range failed {
		order := failed[i].keyOrder()
		display := order.keyRepr
		if formatCount[order.keyRepr] > 1 {
			display = order.keyRepr + "|" + order.keyType
		}
		label := display
		for n := 1; used[label]; n++ {
			label = fmt.Sprintf("%s#%d", display, n)
		}
		used[label] = true
		labels[i] = label
	}
	return labels
}

// validFast is Valid's verdict-only pass: it stops at the first failing
// field and never builds error keys or messages.
func (vd *Validation) validFast(ctx context.Context) (ok bool, err error) {
	if ctx == nil {
		return false, ErrNilContext
	}
	if err := context.Cause(ctx); err != nil {
		return false, err
	}
	// Fail closed on any rule/dive panic. Valid() attaches the struct plan's
	// rules snapshot and never filters, so the fast path carries no filters.
	defer func() {
		if recovered := recover(); recovered != nil {
			ok = false
			err = &RuleError{Err: fmt.Errorf("%w: %s", ErrRulePanic, conv.ToString(recovered))}
		}
	}()
	if vd.rulesShared {
		for i := range vd.plan {
			passed, err := vd.fieldPasses(ctx, vd.plan[i])
			if err != nil || !passed {
				return false, err
			}
		}
	} else {
		// slow path (AddRules-mutated): split+compile per field on demand
		for name, expr := range vd.rules {
			if strings.TrimSpace(expr) == "" {
				continue
			}
			passed, err := vd.fieldPasses(ctx, vd.validator.buildCompiledField(name, expr))
			if err != nil || !passed {
				return false, err
			}
		}
	}
	for _, ef := range vd.elemFields() {
		passed, err := vd.elemFieldPasses(ctx, ef)
		if err != nil || !passed {
			return false, err
		}
	}
	return true, nil
}

func (vd *Validation) fieldPasses(ctx context.Context, cf compiledField) (bool, error) {
	if cf.buildErr != nil {
		return false, &RulesError{Field: cf.name, Err: cf.buildErr}
	}
	if vd.sometimesAbsent(cf) {
		return true, nil
	}
	if cf.container != nil {
		cval := vd.containerValue(cf)
		if cf.hasDive {
			cval = vd.rawValue(cf)
		}
		passed, err := vd.exprPasses(
			ctx,
			cf.name,
			cf.container,
			cval,
		)
		if err != nil || !passed {
			return false, err
		}
	}
	if cf.hasDive && cf.element != nil {
		passed, err := vd.divePasses(
			ctx,
			cf.name,
			cf.element,
			vd.rawValue(cf),
		)
		if err != nil || !passed {
			return false, err
		}
	}
	return true, nil
}

// exprPasses runs one compiled program in fast mode over a pooled Field;
// rule panics become execution errors.
func (vd *Validation) exprPasses(
	ctx context.Context,
	name string,
	compiled *compiled,
	val reflect.Value,
) (ok bool, err error) {
	f := fieldPool.Get().(*Field)
	f.name, f.scope, f.rv, f.ctx, f.vd = name, name, val, ctx, vd
	defer func() {
		*f = Field{}
		fieldPool.Put(f)
		if recovered := recover(); recovered != nil {
			ok = false
			err = &RuleError{Field: name, Err: fmt.Errorf("%w: %s", ErrRulePanic, conv.ToString(recovered))}
		}
	}()
	return compiled.Fast(f)
}

func (vd *Validation) divePasses(
	ctx context.Context,
	name string,
	element *compiled,
	val reflect.Value,
) (bool, error) {
	if !val.IsValid() {
		return true, nil
	}
	switch val.Kind() {
	case reflect.Slice, reflect.Array:
		for i := 0; i < val.Len(); i++ {
			passed, err := vd.exprPasses(
				ctx,
				name,
				element,
				unwrapValue(val.Index(i)),
			)
			if err != nil || !passed {
				return false, err
			}
		}
	case reflect.Map:
		for it := val.MapRange(); it.Next(); {
			passed, err := vd.exprPasses(
				ctx,
				name,
				element,
				unwrapValue(it.Value()),
			)
			if err != nil || !passed {
				return false, err
			}
		}
	default:
		return IsEmptyValue(val), nil
	}
	return true, nil
}