*/

package org.gradle.kotlin.dsl.execution

import org.gradle.internal.hash.HashCode
import org.gradle.kotlin.dsl.support.KotlinCompilerOptions
import java.lang.ref.WeakReference


class ProgramId(
    val templateId: String,
    val sourceHash: HashCode,
    parentClassLoader: ClassLoader,
    private val accessorsClassPathHash: HashCode? = null,
    private val classPathHash: HashCode? = null,

    interface Host {

        fun cachedClassFor(
            programId: ProgramId
        ): CompiledScript?

        fun cache(
            specializedProgram: CompiledScript,
            programId: ProgramId
        )

        fun cachedDirFor(
            scriptHost: KotlinScriptHost<*>,
            programId: ProgramId,
            compilationClassPath: ClassPath,
            accessorsClassPath: ClassPath,

            serviceRegistry

        override fun cachedClassFor(programId: ProgramId): CompiledScript? =
            null

        override fun cache(specializedProgram: CompiledScript, programId: ProgramId) = Unit

        override fun cachedDirFor(
            scriptHost: KotlinScriptHost<*>,
            programId: ProgramId,
            compilationClassPath: ClassPath,
            accessorsClassPath: ClassPath,

            )
        }

        override fun cachedClassFor(
            programId: ProgramId
        ): CompiledScript? = classloadingCache.get(programId)

        override fun cache(
            specializedProgram: CompiledScript,
            programId: ProgramId
        ) {
            classloadingCache.put(
                programId,
                specializedProgram
            )
        }

import org.gradle.kotlin.dsl.execution.ProgramId

import javax.inject.Inject


internal
class KotlinScriptClassloadingCache @Inject constructor(
    cacheFactory: CrossBuildInMemoryCacheFactory
) {

    private
    val cache: CrossBuildInMemoryCache<ProgramId, CompiledScript> = cacheFactory.newCache()

    fun get(key: ProgramId): CompiledScript? =

            accessorsClassPath: ClassPath
        )

        fun compileSecondStageOf(
            program: StagedProgram,
            scriptHost: KotlinScriptHost<*>,
            programId: ProgramId,
            programKind: ProgramKind,
            programTarget: ProgramTarget,
            accessorsClassPath: ClassPath
        ): CompiledScript

        fun handleScriptException(

        val stage1CacheDir = root.resolve("stage1").apply { mkdir() }
        val stage2CacheDir = root.resolve("stage2").apply { mkdir() }

        val stage1ProgramId = ProgramId(stage1TemplateId, sourceHash, parentClassLoader)
        val stage2ProgramId = ProgramId(stage2TemplateId, sourceHash, targetScopeExportClassLoader, accessorsClassPathHash, compilationClassPathHash)

        val mockServiceRegistry = mock<ServiceRegistry> {

        val programHost = safeMockProgramHost {
            on { accessorsClassPathFor(scriptHost) } doReturn accessorsClassPath
        }

        val scriptTemplateId = "Project/TopLevel/stage2"
        val programId = ProgramId(scriptTemplateId, sourceHash, mock())

        private
        fun verifyStandardOutput(program: ExecutableProgram) {
            assertStandardOutputOf(expectedStage1Output) {

        Type.getType(ProgramId::class.java),
        Type.getType(ClassPath::class.java)
    )

    private
    val compileSecondStageOfDescriptor = Type.getMethodDescriptor(
        Type.getType(CompiledScript::class.java),
        stagedProgram,
        Type.getType(KotlinScriptHost::class.java),
        Type.getType(ProgramId::class.java),
        Type.getType(ProgramKind::class.java),