Configuration

/**
 * Main configuration interface for ArC CDI settings at build time
 */
public interface ArcConfig {
    /**
     * Controls bean removal strategy during optimization
     * Values: "all", "none", "fwk", "framework-only"
     */
    String removeUnusedBeans();
    
    /**
     * Enable automatic field injection without @Inject
     */
    boolean autoInjectFields();
    
    /**
     * Transform classes that cannot be proxied by CDI
     */
    boolean transformUnproxyableClasses();
    
    /**
     * Transform private fields for injection
     */
    boolean transformPrivateInjectedFields();
    
    /**
     * Fail build if intercepted private methods are detected
     */
    boolean failOnInterceptedPrivateMethod();
    
    /**
     * List of selected alternative bean classes
     */
    Optional<List<String>> selectedAlternatives();
    
    /**
     * Enable automatic producer method generation
     */
    boolean autoProducerMethods();
    
    /**
     * Type exclusion patterns for bean discovery
     */
    Optional<List<String>> excludeTypes();
    
    /**
     * Patterns for beans that should never be removed
     */
    Optional<List<String>> unremovableTypes();
    
    /**
     * Dependency exclusion configuration by artifact
     */
    Map<String, IndexDependencyConfig> excludeDependency();
    
    /**
     * Detect false positives in unused bean detection
     */
    boolean detectUnusedFalsePositives();
    
    /**
     * Detect wrong usage of annotations (e.g., wrong @Singleton)
     */
    boolean detectWrongAnnotations();
    
    /**
     * Enable strict CDI compatibility mode
     */
    boolean strictCompatibility();
    
    /**
     * Development mode specific configuration
     */
    ArcDevModeConfig devMode();
    
    /**
     * Test mode specific configuration
     */
    ArcTestConfig test();
    
    /**
     * Split packages to ignore during validation
     */
    Optional<List<String>> ignoredSplitPackages();
    
    /**
     * Context propagation configuration
     */
    ArcContextPropagationConfig contextPropagation();
    
    /**
     * Context optimization settings
     */
    OptimizeContexts optimizeContexts();
    
    /**
     * Validate removeUnusedBeans configuration value
     */
    boolean isRemoveUnusedBeansFieldValid();
    
    /**
     * Check if bean removal should be enabled based on configuration
     */
    boolean shouldEnableBeanRemoval();
    
    /**
     * Check if only application beans should be kept
     */
    boolean shouldOnlyKeepAppBeans();
}

// Access configuration in build step
@BuildStep
void configureBeanRemoval(ArcConfig config, BuildProducer<UnremovableBeanBuildItem> unremovable) {
    if (!config.shouldEnableBeanRemoval()) {
        // Disable bean removal for all beans
        unremovable.produce(UnremovableBeanBuildItem.beanTypes(Object.class));
    }
    
    // Process unremovable type patterns
    config.unremovableTypes().ifPresent(patterns -> {
        for (String pattern : patterns) {
            unremovable.produce(new UnremovableBeanBuildItem(
                beanInfo -> beanInfo.getBeanClass().toString().matches(pattern)
            ));
        }
    });
}

/**
 * Configuration for development mode features
 */
public interface ArcDevModeConfig {
    /**
     * Enable monitoring of file changes for hot reload
     */
    boolean monitoringEnabled();
    
    /**
     * Enable lifecycle event debugging
     */
    boolean lifecycleEvents();
}

/**
 * Configuration for test mode
 */
public interface ArcTestConfig {
    /**
     * Enable test-specific bean discovery
     */
    boolean disableApplicationIndex();
    
    /**
     * Configure test bean transformation
     */
    boolean transformTestClasses();
}

/**
 * Configuration for context propagation features
 */
public interface ArcContextPropagationConfig {
    /**
     * Enable context propagation support
     */
    boolean enabled();
    
    /**
     * Configure which contexts to propagate
     */
    Optional<List<String>> propagatedContexts();
}

/**
 * Configuration for index dependency exclusions
 */
public interface IndexDependencyConfig {
    /**
     * Maven group ID to exclude
     */
    Optional<String> groupId();
    
    /**
     * Maven artifact ID to exclude
     */
    Optional<String> artifactId();
    
    /**
     * Maven classifier to exclude
     */
    Optional<String> classifier();
}

/**
 * Configuration properties for CDI
 */
public class ConfigPropertyBuildItem extends MultiBuildItem {
    public ConfigPropertyBuildItem(String propertyName, String defaultValue);
    public ConfigPropertyBuildItem(String propertyName, String defaultValue, String configPhase);
    
    public String getPropertyName();
    public String getDefaultValue();
    public String getConfigPhase();
}

/**
 * Custom scope annotations discovered in configuration  
 */
public class CustomScopeAnnotationsBuildItem extends SimpleBuildItem {
    public CustomScopeAnnotationsBuildItem(Set<DotName> scopes);
    public Set<DotName> getScopes();
}

// Register configuration properties
@BuildStep
ConfigPropertyBuildItem addConfigProperty() {
    return new ConfigPropertyBuildItem(
        "quarkus.arc.remove-unused-beans",
        "all",
        "BUILD_TIME"
    );
}

// Provide custom scope annotations
@BuildStep
CustomScopeAnnotationsBuildItem customScopes() {
    return new CustomScopeAnnotationsBuildItem(
        Set.of(
            DotName.createSimple("com.example.TenantScoped"),
            DotName.createSimple("com.example.RequestScoped")
        )
    );
}

/**
 * Context optimization strategies
 */
public enum OptimizeContexts {
    /**
     * Automatically determine optimization based on usage
     */
    AUTO,
    
    /**
     * Force enable context optimization
     */
    ENABLED,
    
    /**
     * Disable context optimization
     */
    DISABLED
}

/**
 * Bean removal strategies
 */
public interface RemoveUnusedBeansStrategy {
    String ALL = "all";           // Remove all unused beans
    String NONE = "none";         // Keep all beans  
    String FWK = "fwk";          // Remove only framework beans
    String FRAMEWORK_ONLY = "framework-only";  // Alias for fwk
}

@BuildStep
void processConfiguration(ArcConfig arcConfig) {
    // Access configuration values
    String removalStrategy = arcConfig.removeUnusedBeans();
    boolean autoInject = arcConfig.autoInjectFields();
    
    // Process conditional configuration
    if (arcConfig.strictCompatibility()) {
        // Enable strict CDI compatibility checks
    }
    
    // Handle optional configuration
    arcConfig.selectedAlternatives().ifPresent(alternatives -> {
        // Process selected alternatives
        for (String alternative : alternatives) {
            // Register alternative beans
        }
    });
}

@BuildStep
@Record(ExecutionTime.STATIC_INIT)
void configureBeanContainer(ArcConfig config, 
                           ArcRecorder recorder,
                           BuildProducer<BeanContainerListenerBuildItem> listeners) {
    
    if (config.devMode().monitoringEnabled()) {
        listeners.produce(new BeanContainerListenerBuildItem(
            recorder.createDevModeListener()
        ));
    }
    
    if (config.detectWrongAnnotations()) {
        listeners.produce(new BeanContainerListenerBuildItem(
            recorder.createAnnotationValidator()
        ));
    }
}