Dependency Injection

/**
 * Builder for Guice-backed Play applications with comprehensive configuration
 */
public final class GuiceApplicationBuilder extends GuiceBuilder<GuiceApplicationBuilder, play.api.inject.guice.GuiceApplicationBuilder> {
    /** Create new application builder */
    public GuiceApplicationBuilder();
    
    /** Set custom configuration loader function */
    public GuiceApplicationBuilder loadConfig(Function<Environment, Configuration> load);
    
    /** Set specific configuration */
    public GuiceApplicationBuilder loadConfig(Configuration conf);
    
    /** Set global settings (deprecated in newer versions) */
    public GuiceApplicationBuilder global(GlobalSettings global);
    
    /** Load GuiceableModule modules */
    public GuiceApplicationBuilder load(GuiceableModule... modules);
    
    /** Load Google Guice modules */
    public GuiceApplicationBuilder load(com.google.inject.Module... modules);
    
    /** Load Play API modules */
    public GuiceApplicationBuilder load(play.api.inject.Module... modules);
    
    /** Load Play API bindings */
    public GuiceApplicationBuilder load(play.api.inject.Binding<?>... bindings);
    
    /** Load modules using custom loader function */
    public GuiceApplicationBuilder load(java.util.function.BiFunction<Environment, Configuration, List<GuiceableModule>> loader);
    
    /** Build the configured application */
    public Application build();
}

/**
 * Default builder for creating Guice-backed Injectors without Application context
 */
public final class GuiceInjectorBuilder extends GuiceBuilder<GuiceInjectorBuilder, play.api.inject.guice.GuiceInjectorBuilder> {
    /** Create new injector builder */
    public GuiceInjectorBuilder();
    
    /** Build the configured injector */
    public Injector build();
}

/**
 * Base builder for Guice-backed Play components with common configuration
 */
public abstract class GuiceBuilder<Self, Delegate extends play.api.inject.guice.GuiceBuilder<Delegate>> {
    /** Set the environment */
    public final Self in(Environment env);
    
    /** Set the environment path */
    public final Self in(File path);
    
    /** Set the environment mode */
    public final Self in(Mode mode);
    
    /** Set environment class loader */
    public final Self in(ClassLoader classLoader);
    
    /** Set configuration map */
    public final Self configure(Map<String, Object> conf);
    
    /** Set configuration key-value pair */
    public final Self configure(String key, Object value);
    
    /** Override bindings */
    public final Self overrides(GuiceableModule... overrides);
}

import play.inject.guice.GuiceApplicationBuilder;
import play.inject.guice.Guiceable;
import com.google.inject.AbstractModule;

// Basic application building
public class ApplicationLoader extends play.ApplicationLoader {
    
    @Override
    public Application load(Context context) {
        return new GuiceApplicationBuilder()
            .in(context.environment())
            .loadConfig(context.initialConfiguration())
            .build();
    }
}

// Advanced configuration
public Application createApplication() {
    return new GuiceApplicationBuilder()
        .in(Environment.simple())
        .configure("play.http.secret.key", "changeme")
        .configure("db.default.driver", "org.h2.Driver")
        .configure("db.default.url", "jdbc:h2:mem:play")
        .bindings(new DatabaseModule())
        .overrides(new TestModule())
        .build();
}

/**
 * ApplicationLoader using Guice for bootstrapping Play applications
 */
public class GuiceApplicationLoader implements ApplicationLoader {
    /** Create loader with default builder */
    public GuiceApplicationLoader();
    
    /** Create loader with custom initial builder */
    public GuiceApplicationLoader(GuiceApplicationBuilder initialBuilder);
    
    /** Load application with given context */
    public Application load(ApplicationLoader.Context context);
    
    /** Create builder for the given context */
    public GuiceApplicationBuilder builder(ApplicationLoader.Context context);
    
    /** Get override bindings for the context */
    public GuiceableModule[] overrides(ApplicationLoader.Context context);
}

// Custom application loader
public class CustomApplicationLoader extends GuiceApplicationLoader {
    
    @Override
    public GuiceApplicationBuilder builder(Context context) {
        return super.builder(context)
            .bindings(new MyCustomModule())
            .configure("my.custom.setting", "value");
    }
    
    @Override
    public GuiceableModule[] overrides(Context context) {
        if (context.environment().isTest()) {
            return new GuiceableModule[] {
                Guiceable.modules(new TestModule())
            };
        }
        return super.overrides(context);
    }
}

/**
 * Base builder for Guice-backed Play components with fluent configuration
 */
public abstract class GuiceBuilder<Self, Delegate> {
    /** Set environment */
    public Self in(Environment env);
    
    /** Set environment path */
    public Self in(File path);
    
    /** Set environment mode */
    public Self in(Mode mode);
    
    /** Set class loader */
    public Self in(ClassLoader classLoader);
    
    /** Add configuration */
    public Self configure(Configuration conf);
    
    /** Add configuration from map */
    public Self configure(Map<String, Object> conf);
    
    /** Add single configuration setting */
    public Self configure(String key, Object value);
    
    /** Add binding modules */
    public Self bindings(GuiceableModule... modules);
    
    /** Override existing bindings */
    public Self overrides(GuiceableModule... modules);
    
    /** Disable specific module classes */
    public Self disable(Class<?>... moduleClasses);
    
    /** Create application module */
    public Module applicationModule();
    
    /** Create Guice injector */
    public Injector injector();
}

/**
 * Builder for Guice-backed Injectors without full application context
 */
public class GuiceInjectorBuilder extends GuiceBuilder<GuiceInjectorBuilder, play.api.inject.guice.GuiceInjectorBuilder> {
    /** Create new injector builder */
    public GuiceInjectorBuilder();
    
    /** Build the configured injector */
    public Injector build();
}

// Standalone injector for testing or utilities
public class ServiceFactory {
    
    public static Injector createInjector() {
        return new GuiceInjectorBuilder()
            .configure("database.url", "jdbc:h2:mem:test")
            .bindings(
                Guiceable.modules(new DatabaseModule()),
                Guiceable.modules(new ServiceModule())
            )
            .build();
    }
    
    public static <T> T getInstance(Class<T> clazz) {
        return createInjector().getInstance(clazz);
    }
}

// Usage in tests
@Test
public void testService() {
    UserService userService = ServiceFactory.getInstance(UserService.class);
    assertNotNull(userService);
}

/**
 * Utilities for creating GuiceableModules from different sources
 */
public class Guiceable {
    /** Create GuiceableModule from Guice modules */
    public static GuiceableModule modules(com.google.inject.Module... modules);
    
    /** Create GuiceableModule from Play modules */
    public static GuiceableModule modules(play.api.inject.Module... modules);
    
    /** Create GuiceableModule from bindings */
    public static GuiceableModule bindings(play.api.inject.Binding... bindings);
    
    /** Create GuiceableModule from arbitrary module object */
    public static GuiceableModule module(Object module);
}

import com.google.inject.AbstractModule;
import play.inject.guice.Guiceable;

// Standard Guice module
public class DatabaseModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(Database.class).to(H2Database.class);
        bind(UserRepository.class).to(JpaUserRepository.class);
    }
}

// Using Guiceable utilities
public Application buildApplication() {
    return new GuiceApplicationBuilder()
        .bindings(
            Guiceable.modules(new DatabaseModule()),
            Guiceable.modules(new ServiceModule()),
            Guiceable.bindings(
                bind(CacheApi.class).to(EhCacheApi.class)
            )
        )
        .build();
}

/**
 * Built-in dependency injection bindings for Play Framework
 */
public class BuiltInModule extends play.api.inject.Module {
    /** Define core Play Framework bindings */
    public Seq<Binding<?>> bindings(Environment environment, Configuration configuration);
}

/**
 * Provider for Java Configuration wrapper around Scala configuration
 */
public class ConfigurationProvider implements Provider<Configuration> {
    /** Create provider with Scala configuration delegate */
    public ConfigurationProvider(play.api.Configuration delegate);
    
    /** Get Java Configuration instance */
    public Configuration get();
}

/**
 * Java wrapper for Scala ApplicationLifecycle with stop hook support
 */
public class DelegateApplicationLifecycle implements ApplicationLifecycle {
    /** Create wrapper for Scala ApplicationLifecycle */
    public DelegateApplicationLifecycle(play.api.inject.ApplicationLifecycle delegate);
    
    /** Add stop hook that executes on application shutdown */
    public void addStopHook(Callable<F.Promise<Void>> hook);
}

// Service with lifecycle management
@Singleton
public class DatabaseService {
    
    @Inject
    public DatabaseService(ApplicationLifecycle lifecycle) {
        // Initialize database connection pool
        initializeConnectionPool();
        
        // Register cleanup on shutdown
        lifecycle.addStopHook(() -> {
            cleanupConnectionPool();
            return F.Promise.pure(null);
        });
    }
    
    private void initializeConnectionPool() {
        // Database initialization
    }
    
    private void cleanupConnectionPool() {
        // Cleanup resources
    }
}

// Custom module with conditional bindings
public class CustomModule extends AbstractModule {
    private final Environment environment;
    private final Configuration configuration;
    
    public CustomModule(Environment env, Configuration config) {
        this.environment = env;
        this.configuration = config;
    }
    
    @Override
    protected void configure() {
        // Environment-specific bindings
        if (environment.isProd()) {
            bind(EmailService.class).to(SmtpEmailService.class);
            bind(PaymentProcessor.class).to(StripePaymentProcessor.class);
        } else {
            bind(EmailService.class).to(MockEmailService.class);
            bind(PaymentProcessor.class).to(MockPaymentProcessor.class);
        }
        
        // Configuration-driven bindings
        String cacheProvider = configuration.getString("cache.provider");
        if ("redis".equals(cacheProvider)) {
            bind(CacheApi.class).to(RedisCacheApi.class);
        } else {
            bind(CacheApi.class).to(EhCacheApi.class);
        }
        
        // Singleton services
        bind(UserService.class).in(Scopes.SINGLETON);
        bind(AuditService.class).asEagerSingleton();
    }
    
    @Provides
    @Singleton
    public DatabaseConfig provideDatabaseConfig() {
        return new DatabaseConfig(
            configuration.getString("db.url"),
            configuration.getString("db.username"),
            configuration.getString("db.password")
        );
    }
}

// Test-specific application setup
public class TestApplicationBuilder {
    
    public static Application buildTestApplication() {
        return new GuiceApplicationBuilder()
            .in(Environment.simple())
            .configure("db.default.driver", "org.h2.Driver")
            .configure("db.default.url", "jdbc:h2:mem:test")
            .configure("play.evolutions.autoApply", "true")
            .bindings(
                Guiceable.modules(new TestDatabaseModule()),
                Guiceable.modules(new MockServiceModule())
            )
            .overrides(
                Guiceable.bindings(
                    bind(EmailService.class).to(MockEmailService.class)
                )
            )
            .build();
    }
}

// Test module
public class TestDatabaseModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(Database.class).to(H2InMemoryDatabase.class);
        bind(UserRepository.class).to(InMemoryUserRepository.class);
    }
}

// Environment-aware application loader
public class EnvironmentAwareLoader extends GuiceApplicationLoader {
    
    @Override
    public GuiceApplicationBuilder builder(Context context) {
        GuiceApplicationBuilder builder = super.builder(context);
        
        Environment env = context.environment();
        
        if (env.isDev()) {
            return configureDevelopment(builder);
        } else if (env.isTest()) {
            return configureTest(builder);
        } else {
            return configureProduction(builder);
        }
    }
    
    private GuiceApplicationBuilder configureDevelopment(GuiceApplicationBuilder builder) {
        return builder
            .configure("play.http.secret.key", "dev-secret-change-me")
            .configure("db.default.url", "jdbc:h2:mem:dev")
            .bindings(Guiceable.modules(new DevModule()));
    }
    
    private GuiceApplicationBuilder configureTest(GuiceApplicationBuilder builder) {
        return builder
            .configure("db.default.url", "jdbc:h2:mem:test")
            .bindings(Guiceable.modules(new TestModule()));
    }
    
    private GuiceApplicationBuilder configureProduction(GuiceApplicationBuilder builder) {
        return builder
            .bindings(Guiceable.modules(new ProdModule()))
            .disable(DevModule.class, TestModule.class);
    }
}

// Dynamic module loading based on configuration
public class DynamicModuleLoader {
    
    public static List<GuiceableModule> loadModules(Configuration config) {
        List<GuiceableModule> modules = new ArrayList<>();
        
        // Load modules specified in configuration
        List<String> moduleNames = config.getStringList("play.modules.enabled");
        
        for (String moduleName : moduleNames) {
            try {
                Class<?> moduleClass = Class.forName(moduleName);
                Object moduleInstance = moduleClass.newInstance();
                modules.add(Guiceable.module(moduleInstance));
            } catch (Exception e) {
                Logger.warn("Failed to load module: " + moduleName, e);
            }
        }
        
        return modules;
    }
}

// Usage in application loader
public class DynamicApplicationLoader extends GuiceApplicationLoader {
    
    @Override
    public GuiceApplicationBuilder builder(Context context) {
        Configuration config = context.initialConfiguration();
        List<GuiceableModule> dynamicModules = DynamicModuleLoader.loadModules(config);
        
        return super.builder(context)
            .bindings(dynamicModules.toArray(new GuiceableModule[0]));
    }
}