Bean Container

/**
 * Represents the fully initialized CDI bean container
 */
public class BeanContainerBuildItem extends SimpleBuildItem {
    public BeanContainerBuildItem(BeanContainer value);
    
    /**
     * Get the initialized bean container
     */
    public BeanContainer getValue();
}

/**
 * The CDI bean container interface
 */
public interface BeanContainer {
    /**
     * Get a bean instance by type
     */
    <T> T instance(Class<T> type, Annotation... qualifiers);
    
    /**
     * Get a bean instance by type name
     */
    <T> T instance(String className);
    
    /**
     * Get all bean instances of a given type
     */
    <T> List<T> instances(Class<T> type);
    
    /**
     * Check if a bean of the given type exists
     */
    boolean hasBean(Class<?> type, Annotation... qualifiers);
    
    /**
     * Get bean metadata
     */
    <T> BeanMetadata<T> getBeanMetadata(Class<T> type, Annotation... qualifiers);
}

// Access the bean container in a build step
@BuildStep
@Record(ExecutionTime.RUNTIME_INIT)
void initializeRuntime(BeanContainerBuildItem beanContainer, 
                      RuntimeRecorder recorder) {
    
    BeanContainer container = beanContainer.getValue();
    
    // Initialize runtime services using the container
    recorder.initializeServices(container);
}

// Use container for service lookup
@BuildStep
void configureServices(BeanContainerBuildItem beanContainer) {
    BeanContainer container = beanContainer.getValue();
    
    // Check if service is available
    if (container.hasBean(DatabaseService.class)) {
        DatabaseService service = container.instance(DatabaseService.class);
        // Configure or validate service
    }
}

/**
 * Register listeners for bean container initialization
 */
public class BeanContainerListenerBuildItem extends MultiBuildItem {
    public BeanContainerListenerBuildItem(BeanContainerListener beanContainerListener);
    
    /**
     * Get the registered container listener
     */
    public BeanContainerListener getBeanContainerListener();
}

/**
 * Listener interface for container lifecycle events
 */
public interface BeanContainerListener {
    /**
     * Called when the bean container is created but before beans are instantiated
     */
    void created(BeanContainer container);
    
    /**
     * Called when the bean container is being initialized
     */
    default void beforeBeanDiscovery(BeanContainer container) {}
    
    /**
     * Called after bean discovery is complete
     */
    default void afterBeanDiscovery(BeanContainer container) {}
    
    /**
     * Called when container initialization is complete
     */
    default void initialized(BeanContainer container) {}
}

// Register a container listener
@BuildStep
BeanContainerListenerBuildItem registerContainerListener() {
    return new BeanContainerListenerBuildItem(new BeanContainerListener() {
        @Override
        public void created(BeanContainer container) {
            // Perform initialization when container is created
            initializeCustomServices(container);
        }
        
        @Override
        public void initialized(BeanContainer container) {
            // Final initialization when container is ready
            validateConfiguration(container);
        }
    });
}

// Register multiple listeners for different phases
@BuildStep
void registerLifecycleListeners(BuildProducer<BeanContainerListenerBuildItem> listeners) {
    // Early initialization listener
    listeners.produce(new BeanContainerListenerBuildItem(container -> {
        // Early setup tasks
        setupInfrastructure(container);
    }));
    
    // Post-initialization listener  
    listeners.produce(new BeanContainerListenerBuildItem(new BeanContainerListener() {
        @Override
        public void initialized(BeanContainer container) {
            // Post-initialization tasks
            startServices(container);
        }
    }));
}

/**
 * Marker for pre-container initialization phase
 */
public class PreBeanContainerBuildItem extends SimpleBuildItem {
    public PreBeanContainerBuildItem(SyntheticBeansRuntimeInitBuildItem syntheticBeansRuntimeInit,
                                    BeanContainerBuildItem beanContainer);
    
    public SyntheticBeansRuntimeInitBuildItem getSyntheticBeansRuntimeInit();
    public BeanContainerBuildItem getBeanContainer();
}

/**
 * Context registration phase marker
 */
public class ContextRegistrationPhaseBuildItem extends SimpleBuildItem {
    public ContextRegistrationPhaseBuildItem(BeanProcessor.Builder builder);
    public BeanProcessor.Builder getBeanProcessor(); 
}

/**
 * Observer registration phase marker
 */
public class ObserverRegistrationPhaseBuildItem extends SimpleBuildItem {
    public ObserverRegistrationPhaseBuildItem(BeanProcessor.Builder builder);
    public BeanProcessor.Builder getBeanProcessor();
}

/**
 * Runtime initialization of synthetic beans
 */
public class SyntheticBeansRuntimeInitBuildItem extends SimpleBuildItem {
    public SyntheticBeansRuntimeInitBuildItem(RuntimeValue<BeanContainer> beanContainer);
    public RuntimeValue<BeanContainer> getBeanContainer();
}

/**
 * Resources generation phase marker
 */
public class ResourcesGeneratedPhaseBuildItem extends SimpleBuildItem {
    public ResourcesGeneratedPhaseBuildItem(Set<String> generatedResources);
    public Set<String> getGeneratedResources();
}

// Handle pre-container phase
@BuildStep
void handlePreContainer(PreBeanContainerBuildItem preContainer) {
    BeanContainer container = preContainer.getBeanContainer().getValue();
    
    // Perform pre-initialization tasks
    configureCustomContexts(container);
}

// Register contexts during context registration phase
@BuildStep  
void registerCustomContexts(ContextRegistrationPhaseBuildItem contextPhase) {
    BeanProcessor.Builder builder = contextPhase.getBeanProcessor();
    
    // Register custom context implementations
    builder.addContext(new CustomContext());
}

/**
 * Bean metadata information
 */
public interface BeanMetadata<T> {
    /**
     * Get the bean class
     */
    Class<T> getBeanClass();
    
    /**
     * Get bean qualifiers
     */
    Set<Annotation> getQualifiers();
    
    /**
     * Get bean scope
     */
    Class<? extends Annotation> getScope();
    
    /**
     * Check if bean is alternative
     */
    boolean isAlternative();
    
    /**
     * Get bean name if named
     */
    Optional<String> getName();
}

/**
 * Application class predicate for determining application vs framework beans
 */
public class CompletedApplicationClassPredicateBuildItem extends SimpleBuildItem {
    public CompletedApplicationClassPredicateBuildItem(Predicate<String> predicate);
    public Predicate<String> getPredicate();
}

@BuildStep
@Record(ExecutionTime.RUNTIME_INIT) 
void initializeApplicationServices(BeanContainerBuildItem beanContainer,
                                  MyServiceRecorder recorder) {
    // Use the container to initialize application services
    recorder.initialize(beanContainer.getValue());
}

@BuildStep
BeanContainerListenerBuildItem addValidationListener() {
    return new BeanContainerListenerBuildItem(container -> {
        // Validate required services are present
        if (!container.hasBean(DatabaseService.class)) {
            throw new IllegalStateException("DatabaseService not configured");
        }
        
        // Perform health checks
        HealthService health = container.instance(HealthService.class);
        health.validateConfiguration();
    });
}

@BuildStep
void setupCustomContexts(ContextRegistrationPhaseBuildItem contextPhase,
                        BeanContainerListenerBuildItem.Builder listeners) {
    
    // Register context during registration phase
    contextPhase.getBeanProcessor().addContext(new TenantContext());
    
    // Add listener to initialize context
    listeners.produce(new BeanContainerListenerBuildItem(container -> {
        TenantContext context = container.instance(TenantContext.class);
        context.initialize();
    }));
}