resolver.go

package di

import (
	"errors"
	"fmt"
	"reflect"
	"strings"
	"unsafe"
)

// NewResolver constructs a Resolver against one or more Containers
func NewResolver(containers ...Container) Resolver {
	if containers == nil {
		containers = make([]Container, 0)
	}

	return &resolver{
		containers: containers,
	}
}

// Resolver implements methods for several implementation resolution scenarios
type Resolver interface {
	With(implementations ...any) Resolver
	Resolve(receiver any, opts ...Option) error
	Call(function any, opts ...Option) error
	Fill(receiver any) error
}

type resolver struct {
	containers      []Container
	implementations []any
}

func (self *resolver) getBinding(abstraction reflect.Type, name string) (bnd Binding, err error) {
	// look in with() implementation list
	for _, inst := range self.implementations {
		if reflect.TypeOf(inst).AssignableTo(abstraction) && name == DefaultBindName {
			return Binding{
				instance: inst,
			}, nil
		}
	}

	// look in containers
	var list map[string]Binding
	for _, cnt := range self.containers {
		if list, err = cnt.ListBindings(abstraction); err != nil {
			continue
		}

		var ok bool
		if bnd, ok = list[name]; ok {
			return bnd, nil
		}
	}

	return bnd, fmt.Errorf("di: no binding found for %s", abstraction.String())
}

func (self *resolver) resolveBinding(abstraction reflect.Type, name string) (any, error) {
	var bnd, err = self.getBinding(abstraction, name)
	if err != nil {
		return nil, err
	}

	return self.resolveBindingInstance(bnd)
}

func (self *resolver) resolveBindingInstance(bnd Binding) (any, error) {
	// Is binding already instantiated?
	if bnd.instance != nil {
		return bnd.instance, nil
	}

	// Or we need to call a factory method?
	var out, err = self.invoke(bnd.factory)
	if err != nil {
		return nil, err
	}

	if bnd.fill {
		if err = self.Fill(out[0].Interface()); err != nil {
			return nil, err
		}
	}

	if t, ok := out[0].Interface().(Constructor); ok {
		if _, err = self.invoke(t.Construct); err != nil {
			return nil, err
		}
	}

	return out[0].Interface(), nil
}

// arguments returns container-resolved arguments of a function.
func (self *resolver) arguments(function any) ([]reflect.Value, error) {
	var (
		ref  = reflect.TypeOf(function)
		args = make([]reflect.Value, ref.NumIn())
	)

	for i := 0; i < ref.NumIn(); i++ {
		var instance, err = self.resolveBinding(ref.In(i), DefaultBindName)
		if err != nil {
			return nil, err
		}

		args[i] = reflect.ValueOf(instance)
	}

	return args, nil
}

// invoke calls a function and returns the yielded values.
func (self *resolver) invoke(function any) (out []reflect.Value, err error) {
	var args []reflect.Value
	if args, err = self.arguments(function); err != nil {
		return
	}

	out = reflect.ValueOf(function).Call(args)
	// if there is something returned and the last value is error and it's not nil then return it
	if len(out) > 0 && isError(out[len(out)-1].Type()) && !out[len(out)-1].IsNil() {
		return nil, out[len(out)-1].Interface().(error)
	}

	return
}

// With takes a list of instantiated implementations and tries to use them in resolving scenarios
func (self *resolver) With(implementations ...any) Resolver {
	var res = &resolver{
		containers:      make([]Container, len(self.containers)),
		implementations: implementations, // this is required for us to be able to resolve already existing implementations to abstract types (interfaces)
	}

	copy(res.containers, self.containers)

	return res
}

// Call takes a function, builds a list of arguments for it from the available bindings, calls it and returns a result.
func (self *resolver) Call(function any, opts ...Option) error {
	var ref = reflect.TypeOf(function)
	if ref == nil || ref.Kind() != reflect.Func {
		return errors.New("di: invalid function")
	}

	// not boolean to make further logic easier
	var returnsAnError int
	if ref.NumOut() > 0 && isError(ref.Out(ref.NumOut()-1)) {
		returnsAnError = 1
	}

	var options = newCallOptions(opts)
	if options.returns != nil && ref.NumOut()-returnsAnError-len(options.returns) != 0 {
		return fmt.Errorf("di: cannot assign %d returned values to %d receivers", ref.NumOut()-returnsAnError, len(options.returns))
	}

	var args, err = self.arguments(function)
	if err != nil {
		return err
	}

	var out = reflect.ValueOf(function).Call(args)
	// if there is something returned from a function and the last value is error and it's not nil then return it
	if returnsAnError == 1 && !out[len(out)-1].IsNil() {
		return out[len(out)-1].Interface().(error)
	}

	for i, ret := range options.returns {
		var t = reflect.TypeOf(ret)
		if t == nil || t.Kind() != reflect.Ptr || !reflect.ValueOf(ret).Elem().CanSet() || ref.Out(i) != t.Elem() {
			return fmt.Errorf("di: cannot assign returned value of type %s to %s", ref.Out(i).Name(), t.Elem().Name())
		}

		reflect.ValueOf(ret).Elem().Set(out[i])
	}

	return nil
}

// Resolve takes a receiver and fills it with the related implementation.
func (self *resolver) Resolve(receiver any, opts ...Option) error {
	var ref = reflect.TypeOf(receiver)
	if ref == nil || ref.Kind() != reflect.Ptr {
		return errors.New("di: invalid receiver")
	}

	var (
		options   = newResolveOptions(opts)
		inst, err = self.resolveBinding(ref.Elem(), options.name)
	)

	if err != nil {
		return err
	}

	reflect.ValueOf(receiver).Elem().Set(reflect.ValueOf(inst))

	return nil
}

// Fill takes a struct and resolves the fields with the tag `di:"..."`.
// Alternatively map[string]Type or []Type can be provided. It will be filled with all available implementations of provided Type.
func (self *resolver) Fill(receiver any) (err error) {
	var ref = reflect.TypeOf(receiver)
	if ref == nil {
		return errors.New("di: invalid receiver: nil")
	}

	if ref.Kind() != reflect.Ptr {
		return fmt.Errorf("di: receiver is not a pointer: %s", ref.Kind().String())
	}

	defer func() {
		if err != nil {
			err = fmt.Errorf("%s: filling %s", err.Error(), ref.String())
		}
	}()

	switch ref.Elem().Kind() {
	case reflect.Struct:
		err = self.fillStruct(receiver)
		return err

	case reflect.Slice:
		err = self.fillSlice(receiver)
		return

	case reflect.Map:
		if ref.Elem().Key().Name() != "string" {
			break
		}

		err = self.fillMap(receiver)
		return
	}

	return fmt.Errorf("di: invalid receiver: %s", ref.String())
}

func (self *resolver) fillStruct(receiver any) error {
	var elem = reflect.ValueOf(receiver).Elem()
	for i := 0; i < elem.NumField(); i++ {
		var tag, ok = elem.Type().Field(i).Tag.Lookup("di")
		if !ok {
			continue
		}

		var canBeSkipped bool
		tag, canBeSkipped = self.canBeSkipped(tag)

		var name string
		switch tag {
		case "type":
			name = DefaultBindName

		case "name":
			name = elem.Type().Field(i).Name

		case "recursive":
			var ptr = reflect.NewAt(elem.Field(i).Type(), unsafe.Pointer(elem.Field(i).UnsafeAddr())).Elem()

			switch ptr.Kind() {
			case reflect.Slice, reflect.Map, reflect.Struct:
				ptr = ptr.Addr()
			}

			if err := self.Fill(ptr.Interface()); err != nil {
				return err
			}

			continue

		default:
			return fmt.Errorf("di: %v has an invalid struct tag", elem.Type().Field(i).Name)
		}

		var instance, err = self.resolveBinding(elem.Field(i).Type(), name)
		if err != nil {
			if canBeSkipped {
				continue
			}

			return err
		}

		var ptr = reflect.NewAt(elem.Field(i).Type(), unsafe.Pointer(elem.Field(i).UnsafeAddr())).Elem()
		ptr.Set(reflect.ValueOf(instance))
	}

	return nil
}

func (self *resolver) fillSlice(receiver any) error {
	var (
		elem   = reflect.TypeOf(receiver).Elem()
		result = reflect.MakeSlice(reflect.SliceOf(elem.Elem()), 0, 3)
	)

	for _, cnt := range self.containers {
		var bindings, err = cnt.ListBindings(elem.Elem())
		if err != nil {
			continue
		}

		for _, bnd := range bindings {
			var instance any
			if instance, err = self.resolveBindingInstance(bnd); err != nil {
				return err
			}

			result = reflect.Append(result, reflect.ValueOf(instance))
		}
	}

	if result.Len() == 0 {
		return fmt.Errorf("di: no binding found for %v", elem.Elem().String())
	}

	reflect.ValueOf(receiver).Elem().Set(result)

	return nil
}

func (self *resolver) fillMap(receiver any) error {
	var (
		elem   = reflect.TypeOf(receiver).Elem()
		result = reflect.MakeMapWithSize(reflect.MapOf(elem.Key(), elem.Elem()), 3)
	)

	for _, cnt := range self.containers {
		var bindings, err = cnt.ListBindings(elem.Elem())
		if err != nil {
			continue
		}

		for name, bnd := range bindings {
			var instance any
			if instance, err = self.resolveBindingInstance(bnd); err != nil {
				return err
			}

			result.SetMapIndex(reflect.ValueOf(name), reflect.ValueOf(instance))
		}
	}

	if result.Len() == 0 {
		return fmt.Errorf("di: no binding found for %v", elem.Elem().String())
	}

	reflect.ValueOf(receiver).Elem().Set(result)

	return nil
}

func (self *resolver) canBeSkipped(tag string) (string, bool) {
	const omitemptySuffix = ",omitempty"
	var isOmitempty bool

	if strings.Contains(tag, omitemptySuffix) {
		isOmitempty = true
		tag = strings.TrimSuffix(tag, omitemptySuffix)
	}

	return tag, isOmitempty
}