main.go

package main

import (
	"fmt"
	"log"

	"github.com/zignd/depot"
)

type Config struct {
	DatabaseURL string
	AppName     string
}

type Logger struct {
	Prefix string
}

func (l *Logger) Close() error {
	fmt.Printf("%s Logger closed\n", l.Prefix)
	return nil
}

type Database struct {
	Config Config
	Logger *Logger
}

func (db *Database) Close() error {
	db.Logger.Prefix = fmt.Sprintf("%s [CLOSING]", db.Logger.Prefix)
	fmt.Println("Database connection closed")
	return nil
}

type CacheService struct {
	Name string
}

type NotificationService struct {
	Logger *Logger
}

type OrderService struct {
	DB    *Database
	Cache *CacheService
}

type UserService struct {
	DB           *Database
	Cache        *CacheService
	Notification *NotificationService
}

func main() {
	fmt.Println("=== Example: RegisterMany ===")
	fmt.Println()

	// Create a new depot
	dp := depot.New(depot.Config{LazyMode: true})

	// Register all dependencies in a single call using RegisterMany
	// This is cleaner and more readable than individual registrations
	err := dp.RegisterMany(
		// Configuration
		depot.Singleton(func() Config {
			return Config{
				DatabaseURL: "postgres://localhost:5432/mydb",
				AppName:     "MyApp",
			}
		}),

		// Logger
		depot.Singleton(func(c Config) *Logger {
			return &Logger{Prefix: fmt.Sprintf("[%s]", c.AppName)}
		}),

		// Database
		depot.Singleton(func(c Config, l *Logger) (*Database, error) {
			fmt.Println("Creating database connection...")
			return &Database{Config: c, Logger: l}, nil
		}),

		// Cache Service (pre-created instance)
		depot.Instance(&CacheService{Name: "Redis"}),

		// Notification Service
		depot.Singleton(func(l *Logger) *NotificationService {
			return &NotificationService{Logger: l}
		}),

		// Named services
		depot.SingletonNamed("orderService", func(db *Database, cache *CacheService) *OrderService {
			return &OrderService{DB: db, Cache: cache}
		}),

		depot.SingletonNamed("userService", func(db *Database, cache *CacheService, notif *NotificationService) *UserService {
			return &UserService{DB: db, Cache: cache, Notification: notif}
		}),

		// Transient service (new instance each time)
		depot.TransientNamed("requestID", func() string {
			return fmt.Sprintf("req-%d", len("random"))
		}),
	)

	// Check all registration errors at once
	if err != nil {
		log.Printf("First error: %v\n", err)
	}

	if errs := dp.Errors(); errs != nil {
		fmt.Println("Registration errors found:")
		for i, err := range errs {
			fmt.Printf("  %d. %v\n", i+1, err)
		}
		log.Fatal("Cannot proceed due to registration errors")
	}

	fmt.Println("All registrations successful!")
	fmt.Println()

	// Resolve named dependencies
	orderService, err := depot.GetByName[*OrderService](dp, "orderService")
	if err != nil {
		log.Fatalf("Failed to resolve OrderService: %v", err)
	}

	userService, err := depot.GetByName[*UserService](dp, "userService")
	if err != nil {
		log.Fatalf("Failed to resolve UserService: %v", err)
	}

	fmt.Println("Services resolved successfully!")
	fmt.Printf("Order Service - Database URL: %s, Cache: %s\n",
		orderService.DB.Config.DatabaseURL,
		orderService.Cache.Name)
	fmt.Printf("User Service - Database URL: %s, Cache: %s\n",
		userService.DB.Config.DatabaseURL,
		userService.Cache.Name)
	fmt.Println()

	// Verify singleton behavior (same database instance)
	if orderService.DB == userService.DB {
		fmt.Println("✓ Both services share the same database instance (singleton)")
	}

	// Verify transient behavior
	requestID1, _ := depot.GetByName[string](dp, "requestID")
	requestID2, _ := depot.GetByName[string](dp, "requestID")
	fmt.Printf("Request ID 1: %s\n", requestID1)
	fmt.Printf("Request ID 2: %s\n", requestID2)
	fmt.Println()

	// Cleanup
	fmt.Println("Shutting down...")
	if err := dp.Shutdown(); err != nil {
		log.Fatalf("Shutdown failed: %v", err)
	}

	fmt.Println("✓ Shutdown completed successfully")
}