import org.gradle.plugin.management.internal.PluginRequests;

/**
 * Provides a list of plugins that can be auto-applied to a certain Project.
 *
 * @since 4.3
 */
public interface AutoAppliedPluginRegistry {

    /**
     * Returns the plugins that should be auto-applied to the given
     * target, based on the current build invocation.
     */
    PluginRequests getAutoAppliedPlugins(Project target);

            val pluginManager = get(PluginManagerInternal::class.java)
            val pluginApplicator = get(PluginRequestApplicator::class.java)
            pluginApplicator.applyPlugins(PluginRequests.of(pluginRequests), scriptHandler, pluginManager, targetScope)
        }
        targetScope.lock()
    }
}


private
val isPluginConfiguringCall: AnalysisStatementFilter = isConfiguringCall.and(isCallNamed("plugins"))

    private val autoAppliedPluginHandler: AutoAppliedPluginHandler
) {

    fun handle(
        pluginRequests: PluginRequests?,
        scriptHandler: ScriptHandlerInternal,
        target: PluginAwareInternal,
        targetScope: ClassLoaderScope
    ) {
        val initialRequests = pluginRequests ?: PluginRequests.EMPTY
        val autoAppliedPlugins = autoAppliedPluginHandler.getAutoAppliedPlugins(initialRequests, target)

import org.gradle.plugin.management.internal.PluginRequestInternal;
import org.gradle.plugin.management.internal.PluginRequests;

import javax.annotation.Nullable;

@ServiceScope(Scope.Build.class)
public interface PluginRequestApplicator {

    /**
     * Resolves the given {@link PluginRequests} into the given {@link ScriptHandlerInternal#getScriptClassPath()},

    @Override
    public PluginRequests getAutoAppliedPlugins(Project target) {
        return PluginRequests.EMPTY;
    }

    @Override
    public PluginRequests getAutoAppliedPlugins(Settings target) {
        if (((StartParameterInternal) target.getStartParameter()).isUseEmptySettings() || !shouldApplyGradleEnterprisePlugin(target)) {
            return PluginRequests.EMPTY;
        } else {

                    ScriptPluginPlugins(plugin, emptyList())
                } else {
                    val pluginRequests = collectPluginRequestsOf(plugin)
                    validatePluginRequestsOf(plugin, pluginRequests)
                    ScriptPluginPlugins(
                        plugin,
                        pluginRequests.map { it.id.id }
                    )
                }
            },

            host.setupEmbeddedKotlinFor(scriptHost)
        }

        override fun applyPluginsTo(scriptHost: KotlinScriptHost<*>, pluginRequests: PluginRequests) {
            host.applyPluginsTo(scriptHost, pluginRequests)
        }

        override fun applyBasePluginsTo(project: Project) {
            host.applyBasePluginsTo(project as ProjectInternal)
        }

        val target = mock<ProjectInternal> {
            on { this.pluginManager } doReturn pluginManager
        }
        val initialRequests = mock<PluginRequests>(name = "initialRequests")
        val autoAppliedPlugins = mock<PluginRequests>(name = "autoAppliedPlugins")
        val autoAppliedPluginHandler = mock<AutoAppliedPluginHandler> {

        ConfigureUtil.configure(configureClosure, spec);
    }

    public PluginRequests getPluginRequests() {
        if (pluginRequestCollector != null) {
            return pluginRequestCollector.getPluginRequests();
        }
        return PluginRequests.EMPTY;
    }

public interface AutoAppliedPluginHandler {

    /**
     * Returns plugin requests that should be auto-applied
     * based on user requests, the current build invocation and the given target.
     */
    PluginRequests getAutoAppliedPlugins(PluginRequests initialRequests, Object pluginTarget);