source.go

package validator

import (
	"reflect"
	"sort"
	"strings"

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

// varFieldName is the validation name of a Value input.
const varFieldName = "value"

// source is the data set behind a Validation. Each input kind (struct, map,
// single value) implements it, so the engine resolves names, "sometimes"
// absence and the root value without knowing which kind it holds.
type source interface {
	// lookup resolves a validation name. found is false when the name is not
	// part of the data set; a found name may still carry an invalid Value
	// (nil pointer, explicit null).
	lookup(name string) (reflect.Value, bool)
	// absent reports whether a "sometimes" rule should skip name entirely.
	absent(name string) bool
	// raw returns the complete input, for Field.Root.
	raw() any
}

// mapSource backs Map, JSON and Values inputs.
type mapSource struct{ m map[string]any }

func (s mapSource) lookup(name string) (reflect.Value, bool) {
	return lookupInMap(s.m, name)
}

// absent distinguishes a missing key from an explicit null: only the former
// skips a "sometimes" field.
func (s mapSource) absent(name string) bool {
	_, found := lookupInMap(s.m, name)
	return !found
}

func (s mapSource) raw() any { return s.m }

// varSource backs Value inputs. Only varFieldName resolves, so cross-field
// references miss rather than compare the value with itself.
type varSource struct{ val reflect.Value }

func (s *varSource) lookup(name string) (reflect.Value, bool) {
	if name != varFieldName {
		return reflect.Value{}, false
	}
	return unwrapValue(s.val), true
}

func (s *varSource) absent(name string) bool { return name != varFieldName }

func (s *varSource) raw() any { return valToAny(s.val) }

func toValue(v any) reflect.Value {
	if v == nil {
		return reflect.Value{}
	}
	return unwrapValue(reflect.ValueOf(v))
}

// lookupInMap resolves a dotted name, nested path before flat key so a decoy key can't shadow a nested field.
func lookupInMap(m map[string]any, name string) (reflect.Value, bool) {
	if v, ok := descendDotted(m, name); ok {
		return toValue(v), true
	}
	if v, ok := m[name]; ok {
		return toValue(v), true
	}
	return reflect.Value{}, false
}

func descendDotted(m map[string]any, path string) (any, bool) {
	head, rest, ok := strings.Cut(path, ".")
	if !ok {
		return nil, false
	}
	next, ok := m[head]
	if !ok {
		return nil, false
	}
	nm, ok := asStringMap(unwrap(next))
	if !ok {
		return nil, false
	}
	if v, ok := descendDotted(nm, rest); ok {
		return v, true
	}
	if v, ok := nm[rest]; ok {
		return v, true
	}
	return nil, false
}

// asStringMap returns v as a map[string]any for any map kind. String keys are
// copied as-is; other key types are rendered, sorted so a collision (int 1 vs
// string "1") has a deterministic survivor.
func asStringMap(v any) (map[string]any, bool) {
	switch m := v.(type) {
	case nil:
		return nil, false
	case map[string]any:
		return m, true
	case map[string]string:
		out := make(map[string]any, len(m))
		for k, val := range m {
			out[k] = val
		}
		return out, true
	}
	rv := reflect.ValueOf(v)
	if rv.Kind() != reflect.Map {
		return nil, false
	}
	if rv.Type().Key().Kind() == reflect.String {
		out := make(map[string]any, rv.Len())
		for it := rv.MapRange(); it.Next(); {
			out[it.Key().String()] = it.Value().Interface()
		}
		return out, true
	}
	type kv struct {
		mapKeyOrder
		v any
	}
	entries := make([]kv, 0, rv.Len())
	for it := rv.MapRange(); it.Next(); {
		k, vv := it.Key(), it.Value()
		entries = append(entries, kv{
			mapKeyOrder: mapKeyOrder{
				keyRepr: conv.ToString(k.Interface()),
				keyType: dynType(k).String(),
				valRepr: conv.ToString(vv.Interface()),
				valType: dynType(vv).String(),
			},
			v: vv.Interface(),
		})
	}
	sort.Slice(entries, func(a, b int) bool { return entries[a].less(entries[b].mapKeyOrder) })
	m := make(map[string]any, len(entries))
	for _, e := range entries {
		m[e.keyRepr] = e.v
	}
	return m, true
}