Dependency Management

/**
 * Represents JVM classpath dependencies using file paths
 * @param classpath List of JAR files and directories for classpath
 */
data class JvmDependency(val classpath: List<File>) : ScriptDependency {
    /**
     * Alternative constructor for vararg file entries
     * @param classpathEntries Variable number of File arguments
     */
    constructor(vararg classpathEntries: File)
}

import kotlin.script.experimental.jvm.JvmDependency
import java.io.File

// Using list of files
val dependency1 = JvmDependency(listOf(
    File("/path/to/library1.jar"),
    File("/path/to/library2.jar"),
    File("/path/to/classes/directory")
))

// Using vararg constructor
val dependency2 = JvmDependency(
    File("/path/to/library1.jar"),
    File("/path/to/library2.jar")
)

// Adding to script compilation configuration
val config = ScriptCompilationConfiguration {
    dependencies(dependency1, dependency2)
}

/**
 * Dependency resolved from a ClassLoader
 * @param classLoaderGetter Function that provides ClassLoader based on configuration
 */
class JvmDependencyFromClassLoader(
    val classLoaderGetter: ClassLoaderByConfiguration
) : ScriptDependency {
    /**
     * Get the ClassLoader for the given configuration
     * @param configuration Script compilation configuration
     * @return ClassLoader containing the dependency classes
     */
    fun getClassLoader(configuration: ScriptCompilationConfiguration): ClassLoader
}

/**
 * Type alias for function that provides ClassLoader based on configuration
 */
typealias ClassLoaderByConfiguration = (ScriptCompilationConfiguration) -> ClassLoader

import kotlin.script.experimental.jvm.JvmDependencyFromClassLoader

// Using current thread context ClassLoader
val dependency1 = JvmDependencyFromClassLoader { _ ->
    Thread.currentThread().contextClassLoader
}

// Using application ClassLoader
val dependency2 = JvmDependencyFromClassLoader { _ ->
    MyApplication::class.java.classLoader
}

// Using configuration-specific ClassLoader
val dependency3 = JvmDependencyFromClassLoader { config ->
    // Determine ClassLoader based on configuration properties
    when (config.jvm.jvmTarget.value) {
        "1.8" -> legacyClassLoader
        else -> modernClassLoader
    }
}

// Adding to compilation configuration
val config = ScriptCompilationConfiguration {
    dependencies(dependency1, dependency2, dependency3)
}

/**
 * JavaScript dependency representation
 * @param path Path to JavaScript file or module
 */
data class JsDependency(val path: String) : ScriptDependency

import kotlin.script.experimental.jvm.JsDependency

val jsDependency = JsDependency("/path/to/script.js")

val config = ScriptCompilationConfiguration {
    dependencies(jsDependency)
}

/**
 * Configure dependencies from classes in the current classpath context
 * @param classes Classes to extract classpath from
 * @param wholeClasspath Whether to include entire classpath or just specific classes
 */
fun JvmScriptCompilationConfigurationBuilder.dependenciesFromClassContext(
    vararg classes: KClass<*>,
    wholeClasspath: Boolean = false
)

/**
 * Configure dependencies from current execution context
 * @param wholeClasspath Whether to include entire current classpath
 */
fun JvmScriptCompilationConfigurationBuilder.dependenciesFromCurrentContext(
    wholeClasspath: Boolean = false
)

/**
 * Configure dependencies from a specific ClassLoader
 * @param classLoader Source ClassLoader for dependency extraction
 * @param wholeClasspath Whether to extract entire ClassLoader classpath
 */
fun JvmScriptCompilationConfigurationBuilder.dependenciesFromClassloader(
    classLoader: ClassLoader,
    wholeClasspath: Boolean = false
)

// Extract dependencies from specific classes
val config1 = ScriptCompilationConfiguration {
    jvm {
        dependenciesFromClassContext(
            String::class,
            ArrayList::class,
            MyCustomClass::class,
            wholeClasspath = false
        )
    }
}

// Include entire current classpath
val config2 = ScriptCompilationConfiguration {
    jvm {
        dependenciesFromCurrentContext(wholeClasspath = true)
    } 
}

// Use specific ClassLoader with full classpath
val config3 = ScriptCompilationConfiguration {
    jvm {
        dependenciesFromClassloader(
            MyPlugin::class.java.classLoader,
            wholeClasspath = true
        )
    }
}

/**
 * Create new configuration with updated classpath
 * @param classpath Collection of files to add to classpath
 * @return New configuration with updated dependencies
 */
fun ScriptCompilationConfiguration.withUpdatedClasspath(
    classpath: Collection<File>
): ScriptCompilationConfiguration

/**
 * Update classpath in configuration builder
 * @param classpath Collection of files to add to classpath (null to keep existing)
 */
fun ScriptCompilationConfiguration.Builder.updateClasspath(
    classpath: Collection<File>?
)

/**
 * Update classpath in JVM configuration builder
 * @param classpath Collection of files to add to classpath (null to keep existing)
 */
fun JvmScriptCompilationConfigurationBuilder.updateClasspath(
    classpath: Collection<File>?
)

import java.io.File

// Update existing configuration with additional classpath
val originalConfig = ScriptCompilationConfiguration {
    jvm {
        dependenciesFromCurrentContext()
    }
}

val additionalClasspath = listOf(
    File("/opt/myapp/plugins/plugin1.jar"),
    File("/opt/myapp/plugins/plugin2.jar")
)

val updatedConfig = originalConfig.withUpdatedClasspath(additionalClasspath)

// Build configuration with dynamic classpath
val dynamicConfig = ScriptCompilationConfiguration {
    jvm {
        val runtimeClasspath = discoverRuntimeDependencies()
        updateClasspath(runtimeClasspath)
    }
}

/**
 * Convert script dependencies to legacy classpath format
 * @return List of File objects representing classpath entries
 */
fun List<ScriptDependency>?.toClassPathOrEmpty(): List<File>

/**
 * Convert configuration to legacy dependencies format
 * @param classpath List of classpath files
 * @return Legacy ScriptDependencies object
 */
fun ScriptCompilationConfiguration.toDependencies(
    classpath: List<File>
): ScriptDependencies

/**
 * Refine configuration with additional dependencies
 * @return Result containing refined configuration or diagnostics
 */
fun ScriptCompilationConfiguration.refineWith(
    /* parameters */
): ResultWithDiagnostics<ScriptCompilationConfiguration>

// Convert modern dependencies to legacy format
val modernConfig = ScriptCompilationConfiguration {
    dependencies(JvmDependency(File("/path/to/lib.jar")))
}

val legacyDependencies = modernConfig.dependencies.toClassPathOrEmpty()
val scriptDependencies = modernConfig.toDependencies(legacyDependencies)

// Use with legacy scripting APIs
val refinedConfig = modernConfig.refineWith(/* additional parameters */)

// Configure dependencies for Spring Boot application
val springBootConfig = ScriptCompilationConfiguration {
    jvm {
        dependenciesFromClassContext(
            SpringApplication::class,
            wholeClasspath = true
        )
    }
}

// Dynamic plugin dependency loading
class PluginScriptCompiler {
    fun createConfigurationForPlugin(pluginClassLoader: ClassLoader) = 
        ScriptCompilationConfiguration {
            jvm {
                dependenciesFromClassloader(pluginClassLoader, wholeClasspath = false)
                // Add core application dependencies
                dependenciesFromCurrentContext(wholeClasspath = false)
            }
        }
}

// Test-specific dependency configuration
val testConfig = ScriptCompilationConfiguration {
    jvm {
        dependenciesFromClassContext(
            JUnit5::class,
            TestClass::class,
            wholeClasspath = false
        )
    }
}