bind.go

package di

import (
	"errors"
	"fmt"
	"reflect"
)

// ResolveT devuelve un valor del inyector usando genéricos.
//
//	cfg, err := di.ResolveT[*Config](inj)
func ResolveT[T any](inj Injector) (T, error) {
	var zero T
	var dst T // se pasa la dirección

	// Resolve requiere un "pointer al destino".
	if err := inj.Resolve(&dst); err != nil {
		return zero, err
	}
	return dst, nil
}

func (inj *injector) Resolve(v ...Pointer) error {
	for _, p := range v {
		r := reflect.ValueOf(p)
		if r.Kind() != reflect.Ptr || r.IsNil() {
			return errors.New("invalid pointer")
		}

		elem := r.Elem()
		t := elem.Type()

		val, ok := inj.Get(t)
		if !ok {
			return errors.New("can't find injector for " + t.String())
		}

		if !elem.CanSet() {
			return errors.New("cannot set value")
		}

		elem.Set(val)
	}
	return nil
}

func (inj *injector) Apply(p Pointer) error {
	v := reflect.ValueOf(p)
	for v.Kind() == reflect.Ptr {
		v = v.Elem()
	}

	if !v.CanSet() {
		return errors.New("cannot set value")
	}

	typ := v.Type()
	valInject, ok := inj.Get(typ)
	if ok {
		v.Set(valInject)
		return nil
	}

	if v.Kind() != reflect.Struct {
		valInject, ok := inj.Get(typ)
		if !ok {
			return nil
		}
		v.Set(valInject)
		return nil
	}

	for i := 0; i < v.NumField(); i++ {
		f := v.Field(i)
		structField := typ.Field(i)
		_, ok := structField.Tag.Lookup("di")
		if f.CanSet() && ok {
			ft := f.Type()
			valInject, ok := inj.Get(ft)
			if !ok {
				return fmt.Errorf("value not found for type %v", ft)
			}
			f.Set(valInject)
		}
	}
	return nil
}