di

func TestContainer_ProvideAndGet(t *testing.T)

{
	c := New()
	db := &testDB{Name: "test"}
	c.Provide("db", db)

	got, ok := c.Get("db")
	if !ok {
		t.Fatal("expected to find 'db'")
	}

	gotDB, ok := got.(*testDB)
	if !ok {
		t.Fatal("expected *testDB type")
	}

	if gotDB.Name != "test" {
		t.Errorf("got %q, want %q", gotDB.Name, "test")
	}
}

func TestContainer_Has(t *testing.T)

{
	c := New()
	c.Provide("exists", "value")

	if !c.Has("exists") {
		t.Error("Has should return true for 'exists'")
	}

	if c.Has("missing") {
		t.Error("Has should return false for 'missing'")
	}
}

func TestContainer_Inject(t *testing.T)

{
	c := New()
	db := &testDB{Name: "injected"}
	c.Provide("db", db)
	c.Provide("logger", "stdout")

	svc := &testService{}
	if err := c.Inject(svc); err != nil {
		t.Fatalf("Inject() error = %v", err)
	}

	if svc.DB != db {
		t.Errorf("DB not injected correctly")
	}

	if svc.Logger != "stdout" {
		t.Errorf("Logger: got %q, want %q", svc.Logger, "stdout")
	}
}

func TestContainer_InjectRejectsUnexportedField(t *testing.T)

{
	target := struct {
		value string `inject:"value"`
	}{}
	container := NewBuilder()
	container.Provide("value", "ok")

	if err := container.MustBuild().Inject(&target); err == nil {
		t.Fatal("Inject() accepted an unexported field")
	}
}

func TestContainer_Clone(t *testing.T)

{
	c := New()
	c.Provide("key", "value")

	clone := c.Clone()
	clone.Provide("new", "added")

	if !clone.Has("key") {
		t.Error("clone should have 'key'")
	}

	if !clone.Has("new") {
		t.Error("clone should have 'new'")
	}

	if c.Has("new") {
		t.Error("original should not have 'new'")
	}
}

func TestContainer_MustGet_Panic(t *testing.T)

{
	c := New()

	defer func() {
		if r := recover(); r == nil {
			t.Error("MustGet should panic for missing key")
		}
	}()

	c.MustGet("missing")
}

func TestResolve(t *testing.T)

{
	c := New()
	c.Provide("num", 42)

	got, ok := Resolve[int](c, "num")
	if !ok {
		t.Fatal("expected to resolve 'num'")
	}
	if got != 42 {
		t.Errorf("got %d, want 42", got)
	}
}

func TestMustResolve_Panic(t *testing.T)

{
	c := New()

	defer func() {
		if r := recover(); r == nil {
			t.Error("MustResolve should panic for missing key")
		}
	}()

	MustResolve[int](c, "missing")
}

func TestBuilder_RegisterImplIgnoresContractMarkerForInjection(t *testing.T)

{
	b := NewBuilder()
	RegisterImpl[Worker, *GoodWorker](b)

	worker, err := TryResolveType[Worker](b.MustBuild())
	if err != nil {
		t.Fatal(err)
	}
	if worker.Work() != "working hard" {
		t.Fatalf("Work() = %q", worker.Work())
	}
}

func TestBuilder_TransientLifetime(t *testing.T)

{
	b := NewBuilder()
	Register(b, func() *testDB { return &testDB{Name: "fresh"} }, Transient)

	c := b.MustBuild()
	a := ResolveType[*testDB](c)
	b2 := ResolveType[*testDB](c)
	if a == b2 {
		t.Error("Transient should return new instances")
	}
}

func TestBuilder_SingletonLifetime(t *testing.T)

{
	b := NewBuilder()
	Register(b, func() *testDB { return &testDB{Name: "singleton"} }, Singleton)

	c := b.MustBuild()
	a := ResolveType[*testDB](c)
	b2 := ResolveType[*testDB](c)
	if a != b2 {
		t.Error("Singleton should return same instance")
	}
}

func TestBuilder_ConcurrentSingletonResolution(t *testing.T)

{
	b := NewBuilder()
	started := make(chan struct{})
	release := make(chan struct{})
	var calls atomic.Int32
	Register(b, func() *testDB {
		if calls.Add(1) == 1 {
			close(started)
		}
		<-release
		return &testDB{Name: "singleton"}
	})

	container := b.MustBuild()
	results := make(chan *testDB, 2)
	go func() {
		results <- ResolveType[*testDB](container)
	}()
	<-started
	go func() {
		results <- ResolveType[*testDB](container)
	}()
	close(release)

	first := <-results
	second := <-results
	if first != second {
		t.Fatal("concurrent singleton resolutions returned different instances")
	}
	if got := calls.Load(); got != 1 {
		t.Fatalf("singleton factory called %d times", got)
	}
}

func TestResolveType_PanicOnMissing(t *testing.T)

{
	b := NewBuilder()
	c := b.MustBuild()

	defer func() {
		if r := recover(); r == nil {
			t.Error("ResolveType should panic on missing type")
		}
	}()

	ResolveType[*testDB](c)
}

func TestBuilder_ProvideNamed(t *testing.T)

{
	b := NewBuilder()
	b.Provide("db", &testDB{Name: "named"})

	c := b.MustBuild()
	got, ok := c.Get("db")
	if !ok {
		t.Fatal("expected named dep 'db'")
	}
	db := got.(*testDB)
	if db.Name != "named" {
		t.Errorf("got %q, want %q", db.Name, "named")
	}
}

func TestBuilder_RejectsNilFactoryResults(t *testing.T)

{
	t.Run("register", func(t *testing.T) {
		b := NewBuilder()
		Register(b, func() *testDB { return nil })
		if _, err := TryResolveType[*testDB](b.MustBuild()); err == nil {
			t.Fatal("TryResolveType() accepted a nil factory result")
		}
	})

	t.Run("register as", func(t *testing.T) {
		b := NewBuilder()
		RegisterAs[Worker](b, func() *GoodWorker { return nil })
		if _, err := TryResolveType[Worker](b.MustBuild()); err == nil {
			t.Fatal("TryResolveType() accepted a nil implementation")
		}
	})

	t.Run("constructor", func(t *testing.T) {
		b := NewBuilder()
		RegisterFromFunc[*testDB](b, func() *testDB { return nil })
		if _, err := TryResolveType[*testDB](b.MustBuild()); err == nil {
			t.Fatal("TryResolveType() accepted a nil constructor result")
		}
	})
}

func TestContainer_ProvideWithContracts(t *testing.T)

{
	c := New()

	t.Run("Valid implementation", func(t *testing.T) {
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Provide should not panic for valid worker: %v", r)
			}
		}()
		c.Provide("good", &GoodWorker{})
	})

	t.Run("Invalid implementation panics", func(t *testing.T) {
		defer func() {
			if r := recover(); r == nil {
				t.Error("Provide should panic for broken worker")
			}
		}()
		c.Provide("broken", &BrokenWorker{})
	})
}

func TestResolveAll(t *testing.T)

{
	c := New()
	c.Provide("good", &GoodWorker{})
	c.Provide("lazy", &LazyWorker{})
	c.Provide("other", "not a worker")

	workers := ResolveAll[Worker](c)
	if len(workers) != 2 {
		t.Fatalf("expected 2 workers, got %d", len(workers))
	}

	foundGood := false
	foundLazy := false
	for _, w := range workers {
		switch w.Work() {
		case "working hard":
			foundGood = true
		case "working smart":
			foundLazy = true
		}
	}

	if !foundGood || !foundLazy {
		t.Error("ResolveAll did not find all expected workers")
	}
}

func TestContainer_ScopeDoesNotOwnSingleton(t *testing.T)

{
	b := NewBuilder()
	Register(b, func() *closableService { return &closableService{} }, Singleton)

	container := b.MustBuild()
	scope := container.Scope()
	service := ResolveType[*closableService](scope)
	if err := scope.Close(); err != nil {
		t.Fatalf("scope.Close(): %v", err)
	}
	if service.closed {
		t.Fatal("scope closed a singleton owned by the root container")
	}
	if err := container.Close(); err != nil {
		t.Fatalf("container.Close(): %v", err)
	}
	if !service.closed {
		t.Fatal("root container did not close its singleton")
	}
}

func TestContainer_ProvideLazy(t *testing.T)

{
	c := New()
	called := 0
	c.ProvideLazy("lazy", func() any {
		called++
		return "computed"
	})

	if called != 0 {
		t.Error("lazy factory should not be called on registration")
	}

	v, ok := c.Get("lazy")
	if !ok {
		t.Fatal("expected to find 'lazy'")
	}
	if v != "computed" {
		t.Errorf("got %v, want %q", v, "computed")
	}
	if called != 1 {
		t.Error("lazy factory should be called once on first access")
	}

	v2, _ := c.Get("lazy")
	if v2 != "computed" {
		t.Error("lazy factory should return cached value")
	}
	if called != 1 {
		t.Error("lazy factory should only be called once")
	}
}

func TestContainer_ResolveAllAllowsReentrantLazyFactory(t *testing.T)

{
	c := New()
	c.ProvideLazy("worker", func() any {
		c.Provide("side-effect", "registered")
		return &GoodWorker{}
	})

	done := make(chan []Worker, 1)
	go func() {
		done <- ResolveAll[Worker](c)
	}()

	select {
	case workers := <-done:
		if len(workers) != 1 {
			t.Fatalf("ResolveAll() returned %d workers", len(workers))
		}
	case <-time.After(time.Second):
		t.Fatal("ResolveAll() deadlocked in a reentrant lazy factory")
	}
}

func TestContainer_NamedCloserIsClosed(t *testing.T)

{
	service := &closableService{}
	builder := NewBuilder()
	builder.Provide("service", service)
	container := builder.MustBuild()

	if err := container.Close(); err != nil {
		t.Fatal(err)
	}
	if !service.closed {
		t.Fatal("Close() did not close a named dependency")
	}
}

func TestContainer_LazyCloserBelongsToRoot(t *testing.T)

{
	service := &closableService{}
	container := New()
	container.ProvideLazy("service", func() any { return service })
	scope := container.Scope()

	if _, ok := scope.Get("service"); !ok {
		t.Fatal("scope did not resolve the lazy dependency")
	}
	if err := scope.Close(); err != nil {
		t.Fatal(err)
	}
	if service.closed {
		t.Fatal("scope closed a lazy dependency owned by the root")
	}
	if err := container.Close(); err != nil {
		t.Fatal(err)
	}
	if !service.closed {
		t.Fatal("root did not close its lazy dependency")
	}
}

func TestContainerRejectsUseAfterClose(t *testing.T)

{
	container := New()
	container.Provide("value", 1)
	if err := container.Close(); err != nil {
		t.Fatal(err)
	}
	if _, ok := container.Get("value"); ok {
		t.Fatal("Get() returned a value after Close()")
	}
	if _, err := TryResolveType[*testDB](container); !errors.Is(err, ErrContainerClosed) {
		t.Fatalf("TryResolveType() error = %v, want ErrContainerClosed", err)
	}
	defer func() {
		if recover() == nil {
			t.Fatal("Provide() succeeded after Close()")
		}
	}()
	container.Provide("late", 2)
}

func TestResolveAllRejectsUseAfterClose(t *testing.T)

{
	container := New()
	var called atomic.Bool
	container.ProvideLazy("worker", func() any {
		called.Store(true)
		return &GoodWorker{}
	})
	if err := container.Close(); err != nil {
		t.Fatal(err)
	}

	if workers := ResolveAll[Worker](container); len(workers) != 0 {
		t.Fatalf("ResolveAll() returned %d workers after Close()", len(workers))
	}
	if called.Load() {
		t.Fatal("ResolveAll() realized a lazy dependency after Close()")
	}
}

func TestContainerProvideLinearizesWithClose(t *testing.T)

{
	for iteration := 0; iteration < 100; iteration++ {
		container := New()
		service := &closableService{}
		start := make(chan struct{})
		var wg sync.WaitGroup
		var provided atomic.Bool
		wg.Add(2)
		go func() {
			defer wg.Done()
			<-start
			_ = container.Close()
		}()
		go func() {
			defer wg.Done()
			<-start
			defer func() {
				_ = recover()
			}()
			container.Provide("service", service)
			provided.Store(true)
		}()
		close(start)
		wg.Wait()

		if container.Has("service") {
			t.Fatal("closed container reported a registered service")
		}
		if provided.Load() && !service.closed {
			t.Fatal("service admitted before Close() was not closed")
		}
	}
}

func TestContainerClosesLazyResourceRacingClose(t *testing.T)

{
	container := New()
	started := make(chan struct{})
	release := make(chan struct{})
	service := &closableService{}
	container.ProvideLazy("service", func() any {
		close(started)
		<-release
		return service
	})
	resolved := make(chan bool, 1)
	go func() {
		_, ok := container.Get("service")
		resolved <- ok
	}()
	<-started
	if err := container.Close(); err != nil {
		t.Fatal(err)
	}
	close(release)
	if <-resolved {
		t.Fatal("Get() succeeded after concurrent Close()")
	}
	if !service.closed {
		t.Fatal("late lazy resource was not closed")
	}
}

func TestRegisterFromFunc(t *testing.T)

{
	b := NewBuilder()
	Register(b, func() *testDB { return &testDB{Name: "pg"} })
	Register(b, func() *Config { return &Config{DSN: "host=localhost"} })
	RegisterFromFunc[UserService](b, NewUserService, Scoped)

	c := b.MustBuild()
	svc := ResolveType[UserService](c)
	if svc.DB.Name != "pg" {
		t.Errorf("DB.Name = %q, want %q", svc.DB.Name, "pg")
	}
	if svc.Cfg.DSN != "host=localhost" {
		t.Errorf("Cfg.DSN = %q, want %q", svc.Cfg.DSN, "host=localhost")
	}
}

func TestRegisterFromFunc_ReturnsConstructorError(t *testing.T)

{
	b := NewBuilder()
	Register(b, func() *testDB { return &testDB{Name: "pg"} })
	Register(b, func() *Config { return &Config{DSN: "host=localhost"} })
	RegisterFromFunc[UserService](b, NewFailingUserService)

	c := b.MustBuild()
	if _, err := TryResolveType[UserService](c); err == nil {
		t.Fatal("TryResolveType() ignored the constructor error")
	}
}

func TestRegisterFromFunc_UsesRegisteredSingleton(t *testing.T)

{
	b := NewBuilder()
	created := 0
	Register(b, func() *testDB {
		created++
		return &testDB{Name: "singleton"}
	})
	RegisterFromFunc[*serviceWithDB](b, func(db *testDB) *serviceWithDB {
		return &serviceWithDB{DB: db}
	})

	container := b.MustBuild()
	db := ResolveType[*testDB](container)
	service := ResolveType[*serviceWithDB](container)
	if service.DB != db {
		t.Fatal("constructor dependency did not use the registered singleton")
	}
	if created != 1 {
		t.Fatalf("singleton factory called %d times", created)
	}
}

func TestScopedContainer_Close(t *testing.T)

{
	b := NewBuilder()
	Register(b, func() *closableService { return &closableService{} }, Scoped)

	c := b.MustBuild()
	scope := c.Scope()
	svc := ResolveType[*closableService](scope)
	if svc.closed {
		t.Error("service should not be closed yet")
	}
	if err := scope.Close(); err != nil {
		t.Fatalf("Close: %v", err)
	}
	if !svc.closed {
		t.Error("service should be closed after scope.Close()")
	}
}

func TestContainer_Close_Singleton(t *testing.T)

{
	b := NewBuilder()
	Register(b, func() *closableService { return &closableService{} }, Singleton)

	c := b.MustBuild()
	svc := ResolveType[*closableService](c)
	if svc.closed {
		t.Error("service should not be closed yet")
	}
	if err := c.Close(); err != nil {
		t.Fatalf("Close: %v", err)
	}
	if !svc.closed {
		t.Error("singleton implementing io.Closer should be closed on container close")
	}
}

func TestContainer_CloseRegisteredInstance(t *testing.T)

{
	service := &closableService{}
	b := NewBuilder()
	RegisterInstance(b, service)
	container := b.MustBuild()

	if err := container.Close(); err != nil {
		t.Fatal(err)
	}
	if !service.closed {
		t.Fatal("Close() did not close a registered instance")
	}
}

func TestContainer_CloseUsesReverseCreationOrder(t *testing.T)

{
	var order []string
	b := NewBuilder()
	Register(b, func() *closableService {
		return &closableService{name: "dependency", order: &order}
	})
	RegisterFromFunc[*dependentCloser](b, func(service *closableService) *dependentCloser {
		return &dependentCloser{service: service, order: &order}
	})

	container := b.MustBuild()
	ResolveType[*dependentCloser](container)
	if err := container.Close(); err != nil {
		t.Fatal(err)
	}
	if len(order) != 2 || order[0] != "dependent" || order[1] != "dependency" {
		t.Fatalf("close order = %v", order)
	}
}

func TestKey(t *testing.T)

{
	key := NewKey[int]("answer")
	b := NewBuilder()
	ProvideKey(b, key, 42)

	c := b.MustBuild()
	got, ok := ResolveKey(c, key)
	if !ok || got != 42 {
		t.Fatalf("ResolveKey() = %v, %v", got, ok)
	}
}

func TestProvideLazyKeyCanBeValidatedWithoutInstantiation(t *testing.T)

{
	type target struct {
		Answer int `inject:"answer"`
	}
	container := New()
	called := false
	ProvideLazyKey(container, NewKey[int]("answer"), func() int {
		called = true
		return 42
	})
	if err := container.ValidateTarget(&target{}); err != nil {
		t.Fatal(err)
	}
	if called {
		t.Fatal("ValidateTarget() instantiated a lazy dependency")
	}
}

func Resolve[T any](c *Container, name string) (T, bool)

{
	var zero T
	v, ok := c.Get(name)
	if !ok {
		return zero, false
	}
	typed, ok := v.(T)
	if !ok {
		return zero, false
	}
	return typed, true
}

func ResolveAll[T any](c *Container) []T

{
	if c == nil || c.ensureOpen() != nil {
		return nil
	}
	c.mu.RLock()
	values := make([]any, 0, len(c.named))
	for _, value := range c.named {
		values = append(values, value)
	}
	c.mu.RUnlock()

	var result []T
	for _, v := range values {
		if lp, ok := v.(*lazyProvider); ok {
			var err error
			v, err = lp.get()
			if err != nil {
				continue
			}
			if lp.owner.trackCloser(v) != nil {
				continue
			}
		}
		if t, ok := v.(T); ok {
			result = append(result, t)
		}
	}
	return result
}

func Register[T any](b *Builder, factory func() T, lifetime ...Lifetime)

{
	lt := Singleton
	if len(lifetime) > 0 {
		lt = lifetime[0]
	}
	typ := reflect.TypeOf((*T)(nil)).Elem()
	b.mu.Lock()
	if factory == nil {
		b.buildErrors = append(b.buildErrors, fmt.Errorf("di: factory for %v cannot be nil", typ))
		b.mu.Unlock()
		return
	}
	if _, exists := b.services[typ]; exists {
		b.buildErrors = append(b.buildErrors, fmt.Errorf("di: type %v is already registered", typ))
		b.mu.Unlock()
		return
	}
	b.services[typ] = &serviceEntry{lifetime: lt, factory: factory, concreteType: typ}
	b.mu.Unlock()
}

func RegisterAs[I, T any](b *Builder, factory func() T, lifetime ...Lifetime)

{
	lt := Singleton
	if len(lifetime) > 0 {
		lt = lifetime[0]
	}
	typ := reflect.TypeOf((*I)(nil)).Elem()
	concreteType := reflect.TypeOf((*T)(nil)).Elem()
	b.mu.Lock()
	if factory == nil {
		b.buildErrors = append(b.buildErrors, fmt.Errorf("di: factory for %v cannot be nil", typ))
		b.mu.Unlock()
		return
	}
	if !concreteType.Implements(typ) {
		b.buildErrors = append(b.buildErrors, fmt.Errorf("di: type %v does not implement %v", concreteType, typ))
		b.mu.Unlock()
		return
	}
	if _, exists := b.services[typ]; exists {
		b.buildErrors = append(b.buildErrors, fmt.Errorf("di: type %v is already registered", typ))
		b.mu.Unlock()
		return
	}
	b.services[typ] = &serviceEntry{lifetime: lt, factory: factory, concreteType: concreteType}
	b.mu.Unlock()
}

func RegisterInstance[T any](b *Builder, instance T)

{
	typ := reflect.TypeOf((*T)(nil)).Elem()
	b.mu.Lock()
	if isNilInstance(instance) {
		b.buildErrors = append(b.buildErrors, fmt.Errorf("di: instance for %v cannot be nil", typ))
		b.mu.Unlock()
		return
	}
	if _, exists := b.services[typ]; exists {
		b.buildErrors = append(b.buildErrors, fmt.Errorf("di: type %v is already registered", typ))
		b.mu.Unlock()
		return
	}
	b.services[typ] = &serviceEntry{
		lifetime:     Singleton,
		concreteType: typ,
		factory:      func() T { return instance },
		built:        true,
		instance:     instance,
	}
	b.mu.Unlock()
}

func RegisterImpl[I, T any](b *Builder, lifetime ...Lifetime)

{
	lt := Singleton
	if len(lifetime) > 0 {
		lt = lifetime[0]
	}
	iTyp := reflect.TypeOf((*I)(nil)).Elem()
	tTyp := reflect.TypeOf((*T)(nil)).Elem()
	b.mu.Lock()
	if !tTyp.Implements(iTyp) {
		b.buildErrors = append(b.buildErrors, fmt.Errorf("di: type %v does not implement %v", tTyp, iTyp))
		b.mu.Unlock()
		return
	}
	if _, exists := b.services[iTyp]; exists {
		b.buildErrors = append(b.buildErrors, fmt.Errorf("di: type %v is already registered", iTyp))
		b.mu.Unlock()
		return
	}
	b.services[iTyp] = &serviceEntry{lifetime: lt, factory: nil, concreteType: tTyp}
	b.mu.Unlock()
}

func RegisterFromFunc[T any](b *Builder, constructor any, lifetime ...Lifetime)

{
	lt := Singleton
	if len(lifetime) > 0 {
		lt = lifetime[0]
	}
	typ := reflect.TypeOf((*T)(nil)).Elem()

	ctorType := reflect.TypeOf(constructor)
	if ctorType == nil || ctorType.Kind() != reflect.Func {
		panic("di: RegisterFromFunc requires a function")
	}
	if ctorType.NumOut() < 1 || ctorType.NumOut() > 2 {
		panic("di: RegisterFromFunc constructor must return a value and optional error")
	}
	if !ctorType.Out(0).AssignableTo(typ) {
		panic(fmt.Sprintf("di: RegisterFromFunc constructor returns %v, want %v", ctorType.Out(0), typ))
	}
	errorType := reflect.TypeOf((*error)(nil)).Elem()
	if ctorType.NumOut() == 2 && ctorType.Out(1) != errorType {
		panic("di: RegisterFromFunc second result must be error")
	}

	paramTypes := make([]reflect.Type, ctorType.NumIn())
	for i := 0; i < ctorType.NumIn(); i++ {
		paramTypes[i] = ctorType.In(i)
	}

	b.mu.Lock()
	if _, exists := b.services[typ]; exists {
		b.buildErrors = append(b.buildErrors, fmt.Errorf("di: type %v is already registered", typ))
		b.mu.Unlock()
		return
	}
	b.services[typ] = &serviceEntry{
		lifetime: lt, factory: nil, concreteType: typ,
		constructor: constructor, paramTypes: paramTypes,
	}
	b.mu.Unlock()
}

func cloneServiceEntry(entry *serviceEntry) *serviceEntry

{
	return &serviceEntry{
		lifetime:     entry.lifetime,
		factory:      entry.factory,
		constructor:  entry.constructor,
		instance:     entry.instance,
		built:        entry.built,
		concreteType: entry.concreteType,
		paramTypes:   append([]reflect.Type(nil), entry.paramTypes...),
	}
}

func resolveByType(c *Container, typ reflect.Type, stack map[reflect.Type]struct{}) (reflect.Value, error)

{
	if err := c.ensureOpen(); err != nil {
		return reflect.Value{}, err
	}
	c.mu.RLock()
	entry, ok := c.services[typ]
	c.mu.RUnlock()

	if !ok {
		if c.parent != nil {
			return resolveByType(c.parent, typ, stack)
		}
		return reflect.Value{}, &ResolveError{Type: typ}
	}
	if entry.lifetime == Singleton && c.parent != nil {
		return resolveByType(c.parent, typ, stack)
	}
	if _, resolving := stack[typ]; resolving {
		return reflect.Value{}, fmt.Errorf("di: circular dependency detected for type %v", typ)
	}
	stack[typ] = struct{}{}
	defer func() {
		delete(stack, typ)
	}()

	switch entry.lifetime {
	case Singleton, Scoped:
		entry.buildMu.Lock()
		defer entry.buildMu.Unlock()
		if entry.built {
			return reflect.ValueOf(entry.instance), nil
		}
		result, err := invokeEntry(c, entry, stack)
		if err != nil {
			return reflect.Value{}, err
		}
		if isNilReflectValue(result) {
			return reflect.Value{}, fmt.Errorf("di: factory for %v returned nil", typ)
		}
		entry.instance = result.Interface()
		entry.built = true
		if err := c.trackCloser(entry.instance); err != nil {
			return reflect.Value{}, err
		}
		return result, nil
	case Transient:
		result, err := invokeEntry(c, entry, stack)
		if err != nil {
			return reflect.Value{}, err
		}
		if isNilReflectValue(result) {
			return reflect.Value{}, fmt.Errorf("di: factory for %v returned nil", typ)
		}
		if err := c.trackCloser(result.Interface()); err != nil {
			return reflect.Value{}, err
		}
		return result, nil
	default:
		return reflect.Value{}, &ResolveError{Type: typ}
	}
}

func invokeConstructor(c *Container, entry *serviceEntry, stack map[reflect.Type]struct{}) (reflect.Value, error)

{
	ctorVal := reflect.ValueOf(entry.constructor)
	args := make([]reflect.Value, len(entry.paramTypes))
	for i, pt := range entry.paramTypes {
		resolved, err := resolveByType(c, pt, stack)
		if err != nil {
			return reflect.Value{}, fmt.Errorf("di: cannot resolve param %d (%v) of constructor for %v: %w", i, pt, entry.concreteType, err)
		}
		args[i] = resolved
	}
	results := ctorVal.Call(args)
	if len(results) == 2 && !results[1].IsNil() {
		return reflect.Value{}, results[1].Interface().(error)
	}
	return results[0], nil
}

func constructValue(c *Container, typ reflect.Type, stack map[reflect.Type]struct{}) (reflect.Value, error)

{
	if typ.Kind() == reflect.Ptr {
		typ = typ.Elem()
	}
	if typ.Kind() != reflect.Struct {
		return reflect.Value{}, fmt.Errorf("di: auto-construction requires struct type, got %v", typ)
	}

	val := reflect.New(typ)

	ctorVal := val.MethodByName("Init")
	if ctorVal.IsValid() {
		ctorType := ctorVal.Type()
		args := make([]reflect.Value, ctorType.NumIn())
		for i := 0; i < ctorType.NumIn(); i++ {
			resolved, err := resolveByType(c, ctorType.In(i), stack)
			if err != nil {
				return reflect.Value{}, fmt.Errorf("di: cannot resolve param %d of Init: %w", i, err)
			}
			args[i] = resolved
		}
		results := ctorVal.Call(args)
		if len(results) == 1 && !results[0].IsNil() {
			return reflect.Value{}, results[0].Interface().(error)
		}
	} else {
		elem := val.Elem()
		for i := 0; i < typ.NumField(); i++ {
			field := typ.Field(i)
			tag := field.Tag.Get("inject")
			if tag == "" {
				continue
			}
			fieldVal := elem.Field(i)
			if !fieldVal.CanSet() || !field.IsExported() {
				return reflect.Value{}, fmt.Errorf("di: injected field %s must be exported and settable", field.Name)
			}
			resolved, err := resolveByType(c, fieldVal.Type(), stack)
			if err != nil {
				return reflect.Value{}, fmt.Errorf("di: cannot resolve field %s: %w", field.Name, err)
			}
			fieldVal.Set(resolved)
		}
	}

	return val, nil
}

func isNilInstance(instance any) bool

{
	if instance == nil {
		return true
	}
	value := reflect.ValueOf(instance)
	switch value.Kind() {
	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map,
		reflect.Ptr, reflect.Slice:
		return value.IsNil()
	default:
		return false
	}
}

func isNilReflectValue(value reflect.Value) bool

{
	if !value.IsValid() {
		return true
	}
	switch value.Kind() {
	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map,
		reflect.Ptr, reflect.Slice:
		return value.IsNil()
	default:
		return false
	}
}