inject.go

package di

import (
	"fmt"
	"reflect"
)

func (inj *injector) InvokeWithErrorOnly(f interface{}) (err error) {
	v, err := inj.Invoke(f)
	if err != nil {
		return err
	}

	if len(v) == 0 {
		return nil
	}

	for i := range v {
		if err, ok := v[i].Interface().(error); ok {
			return err
		}
	}

	return nil
}

// -----------------------------------------------------------------------------
// Invoke con TryCatch cubriendo la llamada completa
// -----------------------------------------------------------------------------
func (inj *injector) Invoke(f interface{}) (values []reflect.Value, err error) {
	// Fast path
	if pre, ok := f.(PreInvoker); ok {
		return inj.fast(pre, reflect.TypeOf(f), reflect.TypeOf(f).NumIn())
	}

	defer func() {
		if r := recover(); r != nil {
			// Convertir el panic en un error
			switch x := r.(type) {
			case error:
				err = x
			case string:
				err = fmt.Errorf("%s", x)
			default:
				err = fmt.Errorf("panic: %v", r)
			}
		}
	}()

	rv := reflect.ValueOf(f)
	fPtr := rv.Pointer()

	// ----- caché de tipos de argumentos -----------------------
	var argTypes []reflect.Type
	if v, ok := inj.fnCache.Load(fPtr); ok {
		argTypes = v.([]reflect.Type)
	} else {
		t := rv.Type()
		n := t.NumIn()
		argTypes = make([]reflect.Type, n)
		for i := 0; i < n; i++ {
			argTypes[i] = t.In(i)
		}
		inj.fnCache.Store(fPtr, argTypes)
	}

	// ----- resolver dependencias ------------------------------
	in := make([]reflect.Value, len(argTypes))
	for i, at := range argTypes {
		v, ok := inj.Get(at)
		if !ok {
			return nil, fmt.Errorf("di: value not found for %v", at)
		}
		in[i] = v
	}

	// ----- llamada protegida ----------------------------------
	values = rv.Call(in)
	return values, nil
}

// -----------------------------------------------------------------------------
// Map v2 – almacena reflect.Value pre-creado
// -----------------------------------------------------------------------------
func (inj *injector) Map(val interface{}, opt ...Option) (override reflect.Type) {
	cfg := mapOption{}
	for _, fn := range opt {
		fn(&cfg)
	}
	if cfg.key == nil {
		cfg.key = reflect.TypeOf(val)
	}
	k := typeKey(cfg.key)

	if _, existed := inj.values.Load(k); existed {
		override = cfg.key
	}

	inj.values.Store(k, entry{v: reflect.ValueOf(val)})

	// Si el usuario mapea explícitamente una interfaz (WithInterface)
	if cfg.key.Kind() == reflect.Interface {
		inj.ifaceIndex.Store(k, entry{v: reflect.TypeOf(val)})
	}
	return
}

func (inj *injector) Maps(values ...interface{}) (override []reflect.Type) {
	for _, val := range values {
		o := inj.Map(val)
		if o != nil {
			override = append(override, o)
		}
	}
	return
}

func (inj *injector) Set(typ reflect.Type, val reflect.Value) {
	// inj.values[typ] = val
	inj.values.Store(typeKey(typ), entry{v: val.Interface()})
}

// -----------------------------------------------------------------------------
// Get v3.1 – reflect.Value directo + fallback seguro para interfaces
// -----------------------------------------------------------------------------
func (inj *injector) Get(t reflect.Type) (reflect.Value, bool) {
	key := typeKey(t)

	// 1. Valor directo
	if e, ok := inj.values.Load(key); ok && e.v != nil {
		if rv, isRV := e.v.(reflect.Value); isRV {
			return rv, true
		}
		return reflect.ValueOf(e.v), true
	}

	// 2. Proveedor diferido
	if e, ok := inj.providers.Load(key); ok && e.v != nil {
		prov := e.v.(reflect.Value)
		out, err := inj.Invoke(prov.Interface())
		if err != nil {
			panic(err)
		}
		for _, r := range out {
			inj.values.Store(typeKey(r.Type()), entry{v: r})
		}
		inj.providers.Store(key, entry{})
		if e2, ok := inj.values.Load(key); ok && e2.v != nil {
			return e2.v.(reflect.Value), true
		}
	}

	// 3. Interfaces -------------------------------------------------------------
	if t.Kind() == reflect.Interface {
		// 3a. Lookup O(1)
		if impl, ok := inj.ifaceIndex.Load(key); ok && impl.v != nil {
			return inj.Get(impl.v.(reflect.Type))
		}

		// 3b. Fallback lineal (primer uso)
		var found reflect.Value
		var implType reflect.Type

		inj.values.Range(func(e entry) bool {
			if e.v == nil {
				return true
			}
			var rv reflect.Value
			if rvv, ok := e.v.(reflect.Value); ok {
				rv = rvv
			} else {
				rv = reflect.ValueOf(e.v)
			}
			if rv.Type().Implements(t) {
				found = rv
				implType = rv.Type()
				return false // break
			}
			return true // continue
		})

		if found.IsValid() {
			// cachear para futuras llamadas
			inj.ifaceIndex.Store(key, entry{v: implType})
			return found, true
		}
	}

	// 4. Delegar al padre
	if inj.parent != nil {
		return inj.parent.Get(t)
	}
	return reflect.Value{}, false
}

// -------- 3. GetT (función libre — genérica) --------------------------------

// GetT devuelve un valor del inyector usando genéricos (Go 1.18+).
// Uso: cfg, ok := di.GetT[*Config](inj)
func GetT[T any](inj Injector) (T, bool) {
	var zero T
	t := reflect.TypeOf((*T)(nil)).Elem()
	v, ok := inj.Get(t)
	if !ok {
		return zero, false
	}
	return v.Interface().(T), true
}