import org.gradle.internal.service.scopes.ServiceScope


/**
 * Holds the list of imports implicitly added to every Kotlin build script.
 */
@ServiceScope(Scope.Global::class)
class ImplicitImports internal constructor(
    @Transient
    private val importsReader: ImportsReader
) {

    val list by lazy {
        gradleImports() + gradleKotlinDslImports()
    }

    private

    val sourcePath = gradleKotlinDslJar + base.scriptPaths.src + model.localSourcePath
    val implicitImports = base.implicitImports + model.localImplicitImports
    return buildOutputModel(model.scriptFile, classPath, sourcePath, implicitImports, base.classPathModeExceptions)
}


private
fun GradleInternal.baseScriptClassPath(): ClassPath {

        kotlinScriptBasePluginsApplicator: KotlinScriptBasePluginsApplicator,
        scriptSourceHasher: ScriptSourceHasher,
        classpathHasher: ClasspathHasher,
        implicitImports: ImplicitImports,
        progressLoggerFactory: ProgressLoggerFactory,
        buildOperationRunner: BuildOperationRunner,
        cachedClasspathTransformer: CachedClasspathTransformer,
        listenerManager: ListenerManager,

    private val kotlinScriptBasePluginsApplicator: KotlinScriptBasePluginsApplicator,
    private val scriptSourceHasher: ScriptSourceHasher,
    private val classpathHasher: ClasspathHasher,
    private val implicitImports: ImplicitImports,
    private val progressLoggerFactory: ProgressLoggerFactory,
    private val buildOperationRunner: BuildOperationRunner,
    private val cachedClasspathTransformer: CachedClasspathTransformer,

import org.gradle.kotlin.dsl.resolver.EditorReports
import org.gradle.kotlin.dsl.resolver.SourceDistributionResolver
import org.gradle.kotlin.dsl.resolver.SourcePathProvider
import org.gradle.kotlin.dsl.support.ImplicitImports
import org.gradle.kotlin.dsl.support.KotlinScriptType
import org.gradle.kotlin.dsl.support.kotlinScriptTypeFor
import org.gradle.kotlin.dsl.support.serviceOf
import org.gradle.kotlin.dsl.tooling.models.EditorReport

import org.gradle.internal.service.ServiceRegistrationProvider


internal
object GlobalServices : ServiceRegistrationProvider {

    @Provides
    fun createImplicitImports(importsReader: ImportsReader) =
        ImplicitImports(importsReader)

        assert actual instanceof KotlinDslScriptModel

        checkModel(actual, expected, [
            { it.classPath },
            { it.sourcePath },
            { it.implicitImports },
            // TODO:isolated support editor reports
//            [{ it.editorReports }, { a, e -> checkEditorReport(a, e) }],
            { it.exceptions },
        ])
    }

fun configureKotlinCompilerArguments(
    objects: ObjectFactory,
    implicitImports: ImplicitImports,
    classpathFingerprinter: ClasspathFingerprinter,
    compileClasspath: FileCollection,
    accessorsMetadata: Provider<Directory>
) {
    configureKotlinCompilerArguments(
        objects,
        resolverEnvironmentStringFor(
            implicitImports,
            classpathFingerprinter,
            compileClasspath,

    private val classPath: ClassPath = ClassPath.EMPTY,
    private val originalSourceHash: HashCode,
    private val programKind: ProgramKind,
    private val programTarget: ProgramTarget,
    private val implicitImports: List<String> = emptyList(),
    private val logger: Logger = interpreterLogger,
    private val temporaryFileProvider: TemporaryFileProvider,