import org.gradle.build.event.BuildEventsListenerRegistry
// Using star import to workaround https://youtrack.jetbrains.com/issue/KTIJ-24390
import org.gradle.kotlin.dsl.*
import org.gradle.kotlin.dsl.support.serviceOf

/**
 * In build-logic and main build, register a BuildService instance separately,
 * which collects necessary information for build scan.
 */

import org.gradle.internal.resources.ProjectLeaseRegistry
import org.gradle.internal.time.Time
import org.gradle.kotlin.dsl.provider.PrecompiledScriptPluginsSupport
import org.gradle.kotlin.dsl.support.serviceOf
import org.gradle.tooling.model.kotlin.dsl.EditorPosition
import org.gradle.tooling.model.kotlin.dsl.EditorReport
import org.gradle.tooling.model.kotlin.dsl.EditorReportSeverity

import org.gradle.api.internal.GradleInternal
import org.gradle.api.invocation.Gradle


inline fun <reified T : Any> Gradle.serviceOf(): T =
    (gradle as GradleInternal).services.get()


internal
fun serviceRegistryOf(gradle: Gradle) =

import org.gradle.internal.operations.OperationStartEvent
import org.gradle.internal.watch.vfs.BuildFinishedFileSystemWatchingBuildOperationType
import org.gradle.kotlin.dsl.support.serviceOf
import org.gradle.launcher.exec.RunBuildBuildOperationType
import java.net.InetAddress
import java.net.URLEncoder

plugins {
    id("gradlebuild.collect-failed-tasks")
    id("gradlebuild.cache-miss-monitor")

import org.gradle.api.internal.project.ProjectInternal

import java.io.File


inline fun <reified T : Any> Project.serviceOf(): T =
    (this as ProjectInternal).services.get()


internal
fun serviceRegistryOf(project: Project) =
    (project as ProjectInternal).services


fun isGradleKotlinDslJar(file: File) =
    isGradleKotlinDslJarName(file.name)


internal

    class SettingsScriptHost(val host: KotlinScriptHost<Settings>) : Host {
        override fun getLogger(): Logger = Logging.getLogger(Settings::class.java)
        override fun getLogging(): LoggingManager = host.target.serviceOf()
        override fun getFileOperations(): FileOperations = host.fileOperations
        override fun getProcessOperations(): ProcessOperations = host.processOperations
    }

    private
    fun executionEngineFor(scriptHost: KotlinScriptHost<*>): ExecutionEngine {
        // get the ExecutionEngine from the closest available service scope
        // for the global one has no support for the build cache
        return (scriptHost.target as? Project)?.serviceOf()
            ?: executionEngine
    }

    private
    class ScopeBackedCompiledScript(
        private val classLoaderScope: ClassLoaderScope,

        fun from(gradle: GradleInternal, referrerProject: ProjectInternal): CrossProjectConfigurationReportingGradle {
            val parentCrossProjectModelAccess = gradle.serviceOf<CrossProjectModelAccess>()
            val parentCrossProjectConfigurator = gradle.serviceOf<CrossProjectConfigurator>()
            return CrossProjectConfigurationReportingGradle(gradle, referrerProject, parentCrossProjectModelAccess, parentCrossProjectConfigurator)
        }

            inputs.property("kotlinDslScriptTemplates", scriptTemplates)
        }

        configureKotlinCompilerArguments(
            objects,
            serviceOf(),
            serviceOf(),
            compileClasspath,
            generatePrecompiledScriptPluginAccessors.flatMap { it.metadataOutputDir }
        )

        if (inClassPathMode()) {

    private
    class InitScriptHost(val host: KotlinScriptHost<Gradle>) : Host {
        override fun getLogger(): Logger = Logging.getLogger(Gradle::class.java)
        override fun getLogging(): LoggingManager = host.target.serviceOf()
        override fun getFileOperations(): FileOperations = host.fileOperations
        override fun getProcessOperations(): ProcessOperations = host.processOperations
    }
}


/**