import org.gradle.api.logging.LogLevel;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

@ServiceScope(Scope.BuildTree.class)
public class BuildModelParameters {

    private final boolean parallelProjectExecution;
    private final boolean configureOnDemand;
    private final boolean configurationCache;
    private final boolean isolatedProjects;

    @Inject
    public DefaultBuildFeatures(StartParameterInternal startParameter, BuildModelParameters buildModelParameters) {
        this.configurationCache = Lazy.atomic().of(() -> createConfigurationCache(startParameter, buildModelParameters));
        this.isolatedProjects = Lazy.atomic().of(() -> createIsolatedProjects(startParameter, buildModelParameters));
    }

    @Override
    public BuildFeature getConfigurationCache() {

        BuildTaskScheduler buildTaskScheduler,
        BuildOperationRunner buildOperationRunner,
        BuildModelParameters buildModelParameters
    ) {
        this.buildTaskScheduler = buildTaskScheduler;
        this.buildOperationRunner = buildOperationRunner;
        this.buildModelParameters = buildModelParameters;
    }

    @Override

    private final BuildModelParameters buildModelParameters;

    @Inject
    public BuildOptionBuildOperationProgressEventsEmitter(BuildOperationProgressEventEmitter eventEmitter, BuildModelParameters buildModelParameters) {
        this.eventEmitter = eventEmitter;
        this.buildModelParameters = buildModelParameters;
    }

    @Override
    public void afterStart() {

        BuildModelParameters buildModelParameters,
        BuildOperationRunner buildOperationRunner
    ) {
        this.projectConfigurer = projectConfigurer;
        this.buildModelParameters = buildModelParameters;
        this.buildOperationRunner = buildOperationRunner;
    }

    @Override
    public void prepareProjects(GradleInternal gradle) {

    private final BuildTreeFinishExecutor finishExecutor;
    private final StateTransitionController<State> state;
    private final StartParameter startParameter;
    private final BuildModelParameters buildModelParameters;

    public DefaultBuildTreeLifecycleController(
        BuildLifecycleController buildLifecycleController,
        BuildTreeWorkController workController,
        BuildTreeModelCreator modelCreator,

            }

        @Provides
        fun createDynamicLookupRoutine(
            dynamicCallContextTracker: DynamicCallContextTracker,
            buildModelParameters: BuildModelParameters
        ): DynamicLookupRoutine = when {
            buildModelParameters.isIsolatedProjects -> TrackingDynamicLookupRoutine(dynamicCallContextTracker)
            else -> DefaultDynamicLookupRoutine()
        }
    }

    private

    def buildModelParameters = Mock(BuildModelParameters)
    def runner = new IntermediateBuildActionRunner(buildOperationExecutor, buildModelParameters, "Test operation")

    def "parallelism is defined by Tooling API parallel actions"() {
        when:
        runner.isParallel()

        then:
        1 * buildModelParameters.isParallelToolingApiActions() >> true
        0 * _
    }

    private final BuildModelParameters buildModelParameters;
    private final GradleEnterprisePluginManager manager;
    private final BuildType buildType;

    private BuildScanEndOfBuildNotifier.Listener listener;

    @Inject
    public LegacyGradleEnterprisePluginCheckInService(
        GradleInternal gradle,
        BuildModelParameters buildModelParameters,
        GradleEnterprisePluginManager manager,

    private final BuildOperationExecutor buildOperationExecutor;
    private final BuildModelParameters buildModelParameters;
    private final String buildOperationDescription;

    public IntermediateBuildActionRunner(
        BuildOperationExecutor buildOperationExecutor,
        BuildModelParameters buildModelParameters,
        String buildOperationDescription
    ) {