handler.go

package enc

import (
	"encoding/json"
	"fmt"
	"math"
	"reflect"
	"strconv"
	"time"

	"github.com/ohait/forego/ctx"
	"github.com/ohait/forego/ctx/log"
)

// factory holds global type factories registered at init time.
// This map is only written during init() and read-only afterwards, so no locking is needed.
var factory = map[reflect.Type]func(c ctx.C, n Node) (any, error){}

// generic object that do the Unmarshal()/Conflate()
type Handler struct {
	Factory map[reflect.Type]func(c ctx.C, n Node) (any, error)

	// called if a field is present in the NodeTree but there is no mapping on the object it's unmarshaled into
	UnhandledFields func(c ctx.C, path []any, n Node) error

	Debugf func(c ctx.C, f string, args ...any)

	path path
}

// Register registers a factory function for type T.
// When h is nil, registers globally (must be called during init()).
// When h is non-nil, registers on that specific Handler instance (can be called anytime).
// Note: The factory is registered as *T, not T, so unmarshal lookup checks both T and *T.
func Register[T any](h *Handler, f func(ctx.C, Node) (T, error)) {
	var obj *T
	t := reflect.TypeOf(obj)
	fn := func(c ctx.C, n Node) (any, error) {
		return f(c, n)
	}
	if h == nil {
		factory[t] = fn
	} else {
		if h.Debugf != nil {
			h.Debugf(nil, "registered %v (%T)", t, obj)
		}
		if h.Factory == nil {
			h.Factory = map[reflect.Type]func(ctx.C, Node) (any, error){}
		}
		h.Factory[t] = fn
	}
}

func (this Handler) Append(p any) Handler {
	this.path = append(this.path, p)
	return this
}

var ineff = map[string]bool{}

func MustUnmarshal(c ctx.C, n Node, into any) {
	err := Handler{}.Unmarshal(c, n, into)
	if err != nil {
		panic(err)
	}
}

func Unmarshal(c ctx.C, n Node, into any) error {
	return Handler{}.Unmarshal(c, n, into)
}

func (this Handler) Unmarshal(c ctx.C, n Node, into any) error {
	if n == nil {
		n = Nil{}
	}
	v := reflect.ValueOf(into).Elem()
	return this.Append(v.Type()).unmarshal(c, n, v)
}

func (this Handler) unmarshal(c ctx.C, from Node, v reflect.Value) error {
	// c = ctx.WithTag(c, "path", this.path.String()) // NOTE(oha): this is a bit slow because the json part
	// defer log.Debugf(c, "unmarshal( %T %+v => %v{%+v} )", from, from, v.Type(), v)
	if this.Debugf != nil {
		this.Debugf(c, "unmarshal( %v -> %v{%v} )", from, v.Type(), v)
	}
	if !v.CanSet() {
		return ctx.NewErrorf(c, "can't assign %v", v)
	}
	if v.Kind() == reflect.Pointer {
		switch from.(type) {
		case Nil:
			v.SetZero()
			return nil
		default:
			vv := reflect.New(v.Type().Elem())
			v.Set(vv)
			if this.Debugf != nil {
				this.Debugf(c, "pointer deref: %v -> %v", v.Type(), v.Elem().Type())
			}
			return this.unmarshal(c, from, v.Elem())
		}
	}
	switch into := v.Addr().Interface().(type) {
	case Unmarshaler:
		if this.Debugf != nil {
			this.Debugf(c, "is %T", into)
		}
		return into.UnmarshalNode(c, from)
	case *[]byte:
		if this.Debugf != nil {
			this.Debugf(c, "is %T", into)
		}
		switch from := from.(type) {
		case Bytes:
			out := make([]byte, len(from))
			copy(out, from)
			*into = out
			return nil
		default:
			j := JSON{}.Encode(c, from)
			return json.Unmarshal(j, into)
		}
	case *json.RawMessage:
		if this.Debugf != nil {
			this.Debugf(c, "is %T", into)
		}
		*into = JSON{}.Encode(c, from)
		warnIneff(c, "Warn: inefficient json.RawMessage, use enc.Node instead")
		return nil
	case *time.Time:
		var t time.Time
		err := json.Unmarshal(JSON{}.Encode(c, from), &t)
		if err != nil {
			return ctx.NewErrorf(c, "can't unmarshal %#v as time", from)
		}
		*into = t
		return nil
	case json.Unmarshaler:
		if this.Debugf != nil {
			this.Debugf(c, "is %T", into)
		}
		warnIneff(c, "Warn: inefficient %T.UnmarshalJSON(): implement enc.Unmarshaler instead", into)
		j, _ := json.Marshal(from) // we must go back to the json
		return into.UnmarshalJSON(j)
	case *Node:
		if this.Debugf != nil {
			this.Debugf(c, "is %T", into)
		}
		// NOTE(oha) if a struct has a field of type enc.Node, we drop the data there (similarly to json.RawMessage)
		*into = from
		return nil
	}

	/*
		vv := v.Elem()
		switch from.(type) {
		case nil, Nil:
			vv.SetZero()
			return nil
		}
	*/

	var f func(ctx.C, Node) (any, error)
	if this.Factory == nil {
		f = factory[v.Type()]
		if f == nil {
			// also check for a pointer to this type
			f = factory[reflect.PointerTo(v.Type())]
		}
	} else {
		f = this.Factory[v.Type()]
		if f == nil {
			// also check for a pointer to this type
			f = this.Factory[reflect.PointerTo(v.Type())]
		}
	}
	if f != nil {
		if this.Debugf != nil {
			this.Debugf(c, "factory for type %v", v.Type())
		}
		obj, err := f(c, from)
		if err != nil {
			return ctx.NewErrorf(c, "factory error: %w", err)
		}
		s := reflect.ValueOf(obj)
		if !s.CanConvert(v.Type()) {
			return ctx.NewErrorf(c, "Factory %v returned %v which can't be converted to %v",
				v.Type(), s.Type(), v.Type())
		}
		if this.Debugf != nil {
			this.Debugf(c, "Factory %v returned %v which can be converted to %v", v.Type(), s.Type(), v.Type())
		}
		v.Set(s)
		return nil
	}

	// log.Debugf(c, "OHA %T => %v", from, v.Type())
	if this.Debugf != nil {
		this.Debugf(c, "normal type: %v, use generic %T.unmarshalInto()", v.Type(), from)
	}
	/*
		if v.Kind() == reflect.Pointer {
			// if we unmarshal into a pointer, we create the zero value and unmarshal into that instead
			// this allow to unmarshal into *bool or *string
			e := reflect.New(v.Type().Elem())
			log.Debugf(c, "OHA4: %v", e.Type())
			err := from.unmarshalInto(c, this, path, e.Elem())
			if err != nil {
				return err
			}
			v.Set(e)
			return nil
		}
	*/

	return from.unmarshalInto(c, this, v)
}

// skip the factory and unmarshal and directly unmarshal into the object, useful inside a custo Unmarshaler
func UnmarshalInto(c ctx.C, n Node, into any) error {
	return Handler{}.UnmarshalInto(c, n, into)
}

func (h Handler) UnmarshalInto(c ctx.C, n Node, into any) error {
	return n.unmarshalInto(c, h, reflect.ValueOf(into).Elem())
}

func warnIneff(c ctx.C, f string, args ...any) {
	msg := fmt.Sprintf(f, args...)
	if !ineff[msg] {
		ineff[msg] = true
		log.Warnf(c, f, args...)
	}
}

func (this Handler) marshalValue(c ctx.C, v reflect.Value) (Node, error) {
	if !v.IsValid() {
		return Nil{}, nil
	}
	if v.CanAddr() {
		if in, ok := v.Addr().Interface().(Marshaler); ok {
			return in.MarshalNode(c)
		}
		if in, ok := v.Addr().Interface().(json.Marshaler); ok {
			j, err := in.MarshalJSON()
			if err != nil {
				return nil, err
			}
			return JSON{}.Decode(c, j)
		}
	}
	return this.Marshal(c, v.Interface())
}

// transform a struct into a enc.Node, using the struct tags to determine the field names and options, allow custom pairs
// this can be useful for adding a "type" field to a struct:
//
//	func (f Filter) MarshalNode(c ctx.C) (enc.Node, error) {
//		return enc.MarshalStruct(c, f, enc.Pair{Name: "type", Value: enc.String("filter")})
//	}
func MarshalStruct(c ctx.C, in any, pairs ...Pair) (Pairs, error) {
	return Handler{}.MarshalStruct(c, in, pairs...)
}

func (this Handler) MarshalStruct(c ctx.C, in any, pairs ...Pair) (Pairs, error) {
	v := reflect.ValueOf(in)
	if !v.IsValid() {
		return nil, ctx.NewErrorf(c, "can't marshal %T as struct", in)
	}
	for v.Kind() == reflect.Pointer {
		if v.IsNil() {
			return nil, ctx.NewErrorf(c, "can't marshal %T as struct", in)
		}
		v = v.Elem()
	}
	if v.Kind() != reflect.Struct {
		return nil, ctx.NewErrorf(c, "can't marshal %T as struct", in)
	}
	t := v.Type()
	out := Pairs(pairs)
	for i := 0; i < v.NumField(); i++ {
		ft := t.Field(i)
		if !ft.IsExported() {
			continue
		}
		tag, err := parseTag(ft)
		if err != nil {
			return nil, ctx.WrapError(c, err)
		}
		if tag.Skip {
			continue
		}
		fv := v.Field(i)
		fn, err := this.marshalValue(c, fv)
		if err != nil {
			return nil, err
		}
		switch fn := fn.(type) {
		case Nil:
			if !tag.OmitEmpty {
				out = append(out, Pair{tag.Name, fn})
			}
		case String:
			if !tag.OmitEmpty || fn != "" {
				out = append(out, Pair{tag.Name, fn})
			}
		case Integer:
			if !tag.OmitEmpty || fn != 0 {
				out = append(out, Pair{tag.Name, fn})
			}
		case Float:
			if !tag.OmitEmpty || fn != 0.0 {
				out = append(out, Pair{tag.Name, fn})
			}
		case Digits:
			if !tag.OmitEmpty || fn != "" {
				out = append(out, Pair{tag.Name, fn})
			}
		case Bytes:
			if !tag.OmitEmpty || len(fn) > 0 {
				out = append(out, Pair{tag.Name, fn})
			}
		case Time:
			if !tag.OmitEmpty || !time.Time(fn).IsZero() {
				out = append(out, Pair{tag.Name, fn})
			}
		default:
			out = append(out, Pair{tag.Name, fn})
		}
	}
	return out, nil
}

// transform an object into a enc.Node
func Marshal(c ctx.C, in any) (Node, error) {
	return Handler{}.Marshal(c, in)
}

func (this Handler) Marshal(c ctx.C, in any) (Node, error) {
	// log.Warnf(c, "OHA: %T %v", in, in)
	switch in := in.(type) {
	case nil:
		return Nil{}, nil
	case []byte:
		if in == nil {
			return Nil{}, nil
		}
		out := make(Bytes, len(in))
		copy(out, in)
		return out, nil
	case time.Time:
		return Time(in), nil
		// return String(in.Format(time.RFC3339Nano)), nil
	case Marshaler:
		// log.Warnf(c, "OHA: %T->MarshalNode", in)
		return in.MarshalNode(c)
	case json.Marshaler:
		j, err := in.MarshalJSON()
		if err != nil {
			return nil, err
		}
		return JSON{}.Decode(c, j)
	case error:
		return String(in.Error()), nil
	case Node:
		return in, nil
	}

	v := reflect.ValueOf(in)
	t := v.Type()
	switch t.Kind() {
	default:
		log.Warnf(c, "possible wrong fallback for type %T", in)
		return fromNative(in), nil
	case reflect.Func:
		return nil, ctx.NewErrorf(c, "can't marshal %T", in)
	case reflect.Bool:
		return Bool(v.Bool()), nil
	case reflect.Float64, reflect.Float32:
		return Float(v.Float()), nil
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return Integer(v.Int()), nil
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		u := v.Uint()
		if u <= math.MaxInt64 {
			return Integer(int64(u)), nil
		}
		return Digits(strconv.FormatUint(u, 10)), nil
	case reflect.String:
		return String(v.String()), nil
	case reflect.Pointer:
		if v.IsNil() {
			return Nil{}, nil
		}
		return this.Marshal(c, v.Elem().Interface())
	case reflect.Slice:
		if v.IsNil() {
			return Nil{}, nil
		}
		fallthrough // Intentional, since the above check breaks when called on arrays
	case reflect.Array:
		list := List{}
		for i := 0; i < v.Len(); i++ {
			ev := v.Index(i)
			e, err := this.marshalValue(c, ev)
			if err != nil {
				return nil, err
			}
			list = append(list, e)
		}
		return list, nil
	case reflect.Map:
		if v.IsNil() {
			return Nil{}, nil
		}
		m := Map{}
		for _, kv := range v.MapKeys() {
			vv := v.MapIndex(kv)
			n, err := this.Marshal(c, vv.Interface())
			if err != nil {
				return nil, err
			}
			switch k := kv.Interface().(type) {
			case string:
				m[k] = n
			default:
				nk, err := this.Marshal(c, k)
				if err != nil {
					return nil, err
				}
				switch nk := nk.(type) {
				case String:
					m[string(nk)] = n
				case Integer:
					m[fmt.Sprint(nk)] = n
				case Float:
					m[fmt.Sprint(nk)] = n
				case Digits:
					m[fmt.Sprint(nk)] = n
				default:
					return nil, ctx.NewErrorf(c, "can't marshal %v as map key", kv.Type())
				}
			}
		}
		return m, nil

	case reflect.Struct:
	}
	return this.MarshalStruct(c, in)
}