* limitations under the License.
 */
package org.gradle.initialization;

import org.gradle.plugin.use.internal.PluginsAwareScript;

public abstract class SettingsScript extends PluginsAwareScript {
    @Override
    public String toString() {
        return getScriptTarget().toString();
    }

        when (scriptContext) {
            is DeclarativeScriptContext.UnknownScript -> SchemaNotBuilt

            is DeclarativeScriptContext.SettingsScript -> {
                require(scriptContext is LoadedSettingsScriptContext) { "A ${LoadedSettingsScriptContext::class.simpleName} is needed to build the settings schema" }
                InterpretationSequenceAvailable(

        }

        @Override
        void beforeScenario(ScenarioContext context) {
            def projectTestDir = new TestFile(projectDir)
            def settingsScript = projectTestDir.file('settings.gradle')
            settingsScript.text = """
                    buildscript {
                        repositories {
                            maven {
                                name 'gradleInternalRepository'

    data object SchemaNotBuilt : InterpretationSchemaBuildingResult
}


sealed interface DeclarativeScriptContext {
    interface SettingsScript : DeclarativeScriptContext

    object ProjectScript : DeclarativeScriptContext

    object UnknownScript : DeclarativeScriptContext

        DeclarativeScriptContext.ProjectScript -> InterpretationSchemaBuildingResult.InterpretationSequenceAvailable(projectSequence)
        is DeclarativeScriptContext.SettingsScript -> InterpretationSchemaBuildingResult.InterpretationSequenceAvailable(settingsSequence)
        DeclarativeScriptContext.UnknownScript -> InterpretationSchemaBuildingResult.SchemaNotBuilt
    }

    private
    fun scriptContextFromFileName(fileName: String) = when (File(fileName).name) {
        "build.gradle.dcl" -> DeclarativeScriptContext.ProjectScript
        "settings.gradle.dcl" -> object : DeclarativeScriptContext.SettingsScript {}
        else -> DeclarativeScriptContext.UnknownScript
    }

        val settings = target.mutableModel.settings
        val settingsContext = LoadedSettingsScriptContext(settings, settings.classLoaderScope, settings.settingsScript)

        val settingsSequence = schemaBuilder.getEvaluationSchemaForScript(settingsContext)
            .sequenceOrError().analysisOnly()

    )

    return NonProjectScriptModel(
        initScript,
        scriptClassPath,
        sourcePathFor(listOf(scriptHandler)),
    )
}


private
fun buildSettingsScriptModel(settingsScript: File, rootProject: Project): NonProjectScriptModel {
    val settings = rootProject.settings
    val scriptCompilationClassPath = settings.scriptCompilationClassPath

                    }
                }
            }
        """
        expect:
        succeeds 'help', '-PrepoUrl=some/place'

    }

    def "Can access SettingsScript API in pluginManagement block"() {
        given:
        settingsFile << """
            pluginManagement {
                repositories {
                    maven {
                        url file('bar')

            else -> projectScriptPluginModelBuilder(scriptFile, modelRequestProject)
        }
    }

    private
    fun isSettingsFileOf(project: Project, scriptFile: File): Boolean =
        project.settings.settingsScript.resource.file?.canonicalFile == scriptFile

    private
    fun requestParameterOf(modelRequestProject: Project) =
        KotlinBuildScriptModelParameter(