*/

package org.gradle.kotlin.dsl.execution


data class ProgramSource internal constructor(val path: String, val contents: ProgramText) {

    constructor(path: String, contents: String) : this(path, text(contents))

    val text: String
        get() = contents.text

    fun map(transform: (ProgramText) -> ProgramText) =
        ProgramSource(path, transform(contents))
}


/**

    @Test
    fun `solo pluginManagement`() {
        val source = ProgramSource(
            "settings.gradle.kts",
            """
            pluginManagement { println("stage 1") }
            """.trimIndent()
        )
        assertStageOneOutput(source, "stage 1\n")
    }

    @Test
    fun `pluginManagement then buildscipt`() {
        val source = ProgramSource(
            "settings.gradle.kts",
            """

                    ApplyBasePlugins
                )
            )
        )
    }

    @Test
    fun `Project target - top-level - non-empty body`() {

        val source = ProgramSource("build.gradle.kts", "dynamic")
        assertThat(
            "reduces to dynamic program that applies default plugin requests and base plugins",
            partialEvaluationOf(
                Program.Script(source),

            Program.Buildscript(source.fragment(1..11, 13..34))
        )
    }

    @Test
    fun `non-empty Stage 1 with non-empty Stage 2 parse to Stage 1 followed by Stage 2`() {

        val source = ProgramSource(
            "/src/fragment.gradle.kts",
            "\r\n\r\nplugins {\r\n  java\r\n}\r\nprintln(\"Stage 2\")\r\n\r\n"
        )

        assertProgramOf(
            source,
            Program.Staged(

    }

    /**
     * A dynamic script [source] residue, can only be compiled after the execution of the static [prelude] at runtime.
     */
    data class Dynamic(val prelude: Static, val source: ProgramSource) : ResidualProgram()

    sealed class Instruction {

        /**
         * Causes the configuration of the embedded Kotlin libraries
         * on the host's ScriptHandler.
         */

                verifyNoMoreInteractions()
            }
        }
    }

    @Test
    fun `Static(CloseTargetScope, Eval(source))`() {

        val source = ProgramSource(
            "plugin.settings.gradle.kts",
            "include(\"precompiled stage 2\")"
        )

        val target = mock<Settings>()
        val scriptHost = scriptHostWith(target)

import org.gradle.kotlin.dsl.execution.Program
import org.gradle.kotlin.dsl.execution.ProgramKind
import org.gradle.kotlin.dsl.execution.ProgramParser
import org.gradle.kotlin.dsl.execution.ProgramSource
import org.gradle.kotlin.dsl.execution.ProgramTarget

import org.gradle.kotlin.dsl.provider.plugins.precompiled.PrecompiledScriptPlugin
import org.gradle.kotlin.dsl.provider.plugins.precompiled.scriptPluginFilesOf

object ProgramParser {

    fun parse(source: ProgramSource, kind: ProgramKind, target: ProgramTarget): Packaged<Program> = try {
        programFor(source, kind, target)
    } catch (unexpectedBlock: UnexpectedBlock) {
        handleUnexpectedBlock(unexpectedBlock, source.text, source.path)
    }

    private
    fun programFor(source: ProgramSource, kind: ProgramKind, target: ProgramTarget): Packaged<Program> {

            Program.Buildscript(source.fragment(29..39, 41..62, 0))
        )
    }

    @Test
    fun `non-empty Stage 1 with non-empty Stage 2 parse to Stage 1 followed by Stage 2`() {
        val source = ProgramSource(
            "/src/fragment.gradle.kts",
            """
            // a comment
            @Suppress("unused_variable")

            /* more comments */
            @Suppress("whatever")

            val sourceText =
                scriptSource.resource!!.text

            val programSource =
                ProgramSource(scriptPath, sourceText)

            val program =
                ProgramParser.parse(programSource, programKind, programTarget)

            val residualProgram = program.map(
                PartialEvaluator(programKind, programTarget)::reduce