Script Compilation

/**
 * Interface for compiling script source code
 */
interface ScriptCompiler {
    /**
     * Compile script source code using the provided configuration
     * @param script Source code to compile
     * @param configuration Compilation configuration
     * @return Result containing compiled script or compilation errors
     */
    suspend operator fun invoke(
        script: SourceCode,
        configuration: ScriptCompilationConfiguration
    ): ResultWithDiagnostics<CompiledScript>
}

/**
 * Represents a compiled script ready for evaluation
 */
interface CompiledScript {
    /** Unique identifier for the source location */
    val sourceLocationId: String?
    /** Configuration used during compilation */
    val compilationConfiguration: ScriptCompilationConfiguration
    /** Other scripts this script depends on */
    val otherScripts: List<CompiledScript>
    /** Name and type of the field containing the result */
    val resultField: Pair<String, KotlinType>?
    
    /**
     * Get the runtime class of the compiled script
     * @param scriptEvaluationConfiguration Optional evaluation configuration
     * @return Result containing the script class or errors
     */
    suspend fun getClass(
        scriptEvaluationConfiguration: ScriptEvaluationConfiguration?
    ): ResultWithDiagnostics<KClass<*>>
}

/**
 * Configuration for script compilation
 */
class ScriptCompilationConfiguration : PropertiesCollection {
    companion object {
        val Default = ScriptCompilationConfiguration()
    }
}

/**
 * Keys for script compilation configuration properties
 */
interface ScriptCompilationConfigurationKeys {
    val baseClass: PropertiesCollection.Key<KotlinType>
    val implicitReceivers: PropertiesCollection.Key<List<KotlinType>>
    val providedProperties: PropertiesCollection.Key<Map<String, KotlinType>>
    val dependencies: PropertiesCollection.Key<List<ScriptDependency>>
    val defaultImports: PropertiesCollection.Key<List<String>>
    val restrictions: PropertiesCollection.Key<List<ScriptRestriction>>
    val compilerOptions: PropertiesCollection.Key<List<String>>
    val displayName: PropertiesCollection.Key<String>
    val fileExtension: PropertiesCollection.Key<String>
    val suppressWarnings: PropertiesCollection.Key<List<String>>
    val metadataKeys: PropertiesCollection.Key<List<String>>
    val refineConfiguration: PropertiesCollection.Key<List<RefineScriptCompilationConfigurationHandler>>
}

/**
 * Handler for refining script compilation configuration
 */
typealias RefineScriptCompilationConfigurationHandler = 
    suspend (ScriptConfigurationRefinementContext) -> ResultWithDiagnostics<ScriptCompilationConfiguration>

/**
 * Simplified refinement handler
 */
typealias SimpleRefineScriptCompilationConfigurationHandler = 
    (ScriptConfigurationRefinementContext) -> ScriptCompilationConfiguration?

/**
 * Context provided to refinement handlers
 */
data class ScriptConfigurationRefinementContext(
    val script: SourceCode,
    val compilationConfiguration: ScriptCompilationConfiguration,
    val collectedData: ScriptCollectedData? = null
)

/**
 * Builder for refining script compilation configuration
 */
class RefineConfigurationBuilder(
    baseConfiguration: ScriptCompilationConfiguration
) {
    fun dependencies(configure: DependenciesBuilder.() -> Unit)
    fun defaultImports(vararg imports: String)
    fun compilerOptions(vararg options: String)
    fun refineConfiguration(handler: RefineScriptCompilationConfigurationHandler)
    fun build(): ScriptCompilationConfiguration
}

/**
 * Data for unconditional configuration refinement
 */
data class RefineConfigurationUnconditionallyData(
    val handler: RefineScriptCompilationConfigurationHandler
)

/**
 * Data for annotation-based configuration refinement
 */
data class RefineConfigurationOnAnnotationsData(
    val annotations: List<KClass<out Annotation>>,
    val handler: RefineScriptCompilationConfigurationHandler
)

import kotlin.script.experimental.api.*

// Basic compilation configuration
val basicConfig = ScriptCompilationConfiguration {
    defaultImports("kotlin.math.*", "kotlin.collections.*")
    dependencies {
        append(JvmDependency("org.apache.commons:commons-lang3:3.12.0"))
    }
}

// Compile a script
class MyScriptCompiler : ScriptCompiler {
    override suspend fun invoke(
        script: SourceCode,
        configuration: ScriptCompilationConfiguration
    ): ResultWithDiagnostics<CompiledScript> {
        // Implementation would use Kotlin compiler APIs
        // This is a simplified example
        TODO("Implementation depends on specific compiler backend")
    }
}

// Using the compiler
val compiler = MyScriptCompiler()
val script = "println(sqrt(16.0))".toScriptSource("math.kts")

val result = compiler(script, basicConfig)
when (result) {
    is ResultWithDiagnostics.Success -> {
        val compiledScript = result.value
        println("Compiled successfully: ${compiledScript.sourceLocationId}")
        
        // Get the runtime class
        val classResult = compiledScript.getClass()
        if (classResult is ResultWithDiagnostics.Success) {
            val scriptClass = classResult.value
            println("Script class: ${scriptClass.qualifiedName}")
        }
    }
    is ResultWithDiagnostics.Failure -> {
        result.reports.forEach { diagnostic ->
            println("${diagnostic.severity}: ${diagnostic.message}")
        }
    }
}

// Refinement based on script annotations
val configWithRefinement = ScriptCompilationConfiguration {
    refineConfiguration {
        onAnnotations<Import> { context ->
            val imports = context.collectedData?.get(ScriptCollectedData.foundAnnotations)
                ?.filterIsInstance<Import>()
                ?.map { it.packages }
                ?.flatten()
                ?: emptyList()
            
            ScriptCompilationConfiguration(context.compilationConfiguration) {
                defaultImports.append(imports)
            }.asSuccess()
        }
    }
}

// Unconditional refinement
val refinedConfig = ScriptCompilationConfiguration {
    refineConfiguration {
        unconditionally { context ->
            // Always add specific dependencies
            ScriptCompilationConfiguration(context.compilationConfiguration) {
                dependencies.append(JvmDependency("my.runtime:core:1.0"))
            }.asSuccess()
        }
    }
}

// Complex compilation configuration
val advancedConfig = ScriptCompilationConfiguration {
    // Set base class for scripts
    baseClass(KotlinType.from<Any>())
    
    // Add implicit receivers
    implicitReceivers(KotlinType.from<File>())
    
    // Provide properties available in scripts
    providedProperties(mapOf(
        "scriptFile" to KotlinType.from<File>(),
        "args" to KotlinType.from<Array<String>>()
    ))
    
    // Add dependencies
    dependencies {
        append(JvmDependency("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4"))
        append(JvmDependency("com.fasterxml.jackson.module:jackson-module-kotlin:2.14.2"))
    }
    
    // Default imports
    defaultImports(
        "kotlin.coroutines.*",
        "kotlinx.coroutines.*",
        "com.fasterxml.jackson.module.kotlin.*"
    )
    
    // Compiler options
    compilerOptions("-opt-in=kotlin.RequiresOptIn")
    
    // Suppress specific warnings
    suppressWarnings("UNUSED_PARAMETER", "UNUSED_VARIABLE")
}