Core Scripting Host

/**
 * Main JVM scripting host for executing Kotlin scripts with configurable compiler and evaluator
 * @param baseHostConfiguration Optional base host configuration
 * @param compiler JVM script compiler instance
 * @param evaluator Script evaluator instance
 */
open class BasicJvmScriptingHost(
    val baseHostConfiguration: ScriptingHostConfiguration? = null,
    compiler: JvmScriptCompiler = JvmScriptCompiler(baseHostConfiguration.withDefaultsFrom(defaultJvmScriptingHostConfiguration)),
    evaluator: ScriptEvaluator = BasicJvmScriptEvaluator()
) : BasicScriptingHost(compiler, evaluator) {
    
    /**
     * Evaluates a script using a template-based configuration
     * @param script Source code to evaluate
     * @param compilation Compilation configuration builder
     * @param evaluation Evaluation configuration builder
     * @returns Result with diagnostics containing evaluation result or errors
     */
    inline fun <reified T : Any> evalWithTemplate(
        script: SourceCode,
        noinline compilation: ScriptCompilationConfiguration.Builder.() -> Unit = {},
        noinline evaluation: ScriptEvaluationConfiguration.Builder.() -> Unit = {}
    ): ResultWithDiagnostics<EvaluationResult>
}

import kotlin.script.experimental.jvmhost.BasicJvmScriptingHost
import kotlin.script.experimental.api.*

// Basic host creation
val host = BasicJvmScriptingHost()

// Script execution with simple template
@KotlinScript(fileExtension = "kts")
class SimpleScript

val script = "val x = 42; println(\"Result: \$x\")"
val result = host.evalWithTemplate<SimpleScript>(script.toScriptSource())

// Handle result
when (result) {
    is ResultWithDiagnostics.Success -> {
        val evaluationResult = result.value
        when (val returnValue = evaluationResult.returnValue) {
            is ResultValue.Value -> println("Script returned: ${returnValue.value}")
            is ResultValue.Unit -> println("Script executed successfully")
            is ResultValue.Error -> println("Execution error: ${returnValue.error.message}")
            else -> println("Script not evaluated")
        }
    }
    is ResultWithDiagnostics.Failure -> {
        result.reports.forEach { report ->
            println("${report.severity}: ${report.message}")
        }
    }
}

// Advanced usage with custom configuration
val customHost = BasicJvmScriptingHost(
    baseHostConfiguration = ScriptingHostConfiguration {
        // Custom host configuration
    }
)

val advancedResult = customHost.evalWithTemplate<SimpleScript>(
    script = script.toScriptSource(),
    compilation = {
        // Compilation configuration
        dependencies(JvmDependency(File("/path/to/library.jar")))
        importScripts(FileBasedScriptSource(File("common.kts")))
    },
    evaluation = {
        // Evaluation configuration
        constructorArgs("arg1", "arg2")
        providedProperties("contextVar" to "contextValue")
    }
)

/**
 * Creates JVM compilation configuration from template type
 * @param baseHostConfiguration Optional base host configuration
 * @param body Configuration builder function
 * @returns Configured ScriptCompilationConfiguration
 */
inline fun <reified T : Any> createJvmCompilationConfigurationFromTemplate(
    baseHostConfiguration: ScriptingHostConfiguration? = null,
    noinline body: ScriptCompilationConfiguration.Builder.() -> Unit = {}
): ScriptCompilationConfiguration

@KotlinScript(fileExtension = "script.kts")
class MyScriptTemplate

val compilationConfig = createJvmCompilationConfigurationFromTemplate<MyScriptTemplate> {
    dependencies(JvmDependency(File("lib.jar")))
    importScripts(FileBasedScriptSource(File("common.kts")))
    compilerOptions.append("-opt-in=kotlin.RequiresOptIn")
}

/**
 * Creates JVM evaluation configuration from template type
 * @param baseHostConfiguration Optional base host configuration
 * @param body Configuration builder function
 * @returns Configured ScriptEvaluationConfiguration
 */
inline fun <reified T : Any> createJvmEvaluationConfigurationFromTemplate(
    baseHostConfiguration: ScriptingHostConfiguration? = null,
    noinline body: ScriptEvaluationConfiguration.Builder.() -> Unit = {}
): ScriptEvaluationConfiguration

val evaluationConfig = createJvmEvaluationConfigurationFromTemplate<MyScriptTemplate> {
    constructorArgs("arg1", 42, true)
    providedProperties(
        "database" to DatabaseConnection(),
        "logger" to LoggerFactory.getLogger("script")
    )
    jvm {
        baseClassLoader(MyClass::class.java.classLoader)
    }
}

/**
 * Creates complete script definition from template type
 * @param baseHostConfiguration Optional base host configuration
 * @param compilation Compilation configuration builder
 * @param evaluation Evaluation configuration builder
 * @returns Complete ScriptDefinition
 */
inline fun <reified T : Any> createJvmScriptDefinitionFromTemplate(
    baseHostConfiguration: ScriptingHostConfiguration? = null,
    noinline compilation: ScriptCompilationConfiguration.Builder.() -> Unit = {},
    noinline evaluation: ScriptEvaluationConfiguration.Builder.() -> Unit = {}
): ScriptDefinition

val scriptDefinition = createJvmScriptDefinitionFromTemplate<MyScriptTemplate>(
    compilation = {
        dependencies(JvmDependency(File("runtime.jar")))
        compilerOptions.append("-Xmulti-platform")
    },
    evaluation = {
        constructorArgs("contextData")
        enableScriptsInstancesSharing()
    }
)

// Use with compiler directly
val compiler = JvmScriptCompiler()
val compilationResult = compiler(
    script.toScriptSource(),
    scriptDefinition.compilationConfiguration
)

enum class ScriptDiagnostic.Severity {
    DEBUG, INFO, WARNING, ERROR, FATAL
}

data class ScriptDiagnostic(
    val code: Int,
    val message: String,
    val severity: Severity,
    val location: SourceCode.Location? = null,
    val exception: Throwable? = null
)

val result = host.evalWithTemplate<MyTemplate>(script.toScriptSource())

when (result) {
    is ResultWithDiagnostics.Success -> {
        // Handle successful evaluation
        val evaluationResult = result.value
        if (result.reports.isNotEmpty()) {
            // Handle warnings
            result.reports.filter { it.severity == ScriptDiagnostic.Severity.WARNING }
                .forEach { println("Warning: ${it.message}") }
        }
    }
    is ResultWithDiagnostics.Failure -> {
        // Handle compilation or evaluation failure
        result.reports.forEach { diagnostic ->
            val location = diagnostic.location?.let { " at line ${it.start.line}" } ?: ""
            println("${diagnostic.severity}$location: ${diagnostic.message}")
            diagnostic.exception?.let { 
                println("Caused by: ${it.javaClass.simpleName}: ${it.message}")
            }
        }
    }
}