Application Setup & Configuration

/**
 * Start Koin with application configuration
 * @param appDeclaration - Configuration block for KoinApplication setup
 * @return KoinApplication instance
 */
fun startKoin(appDeclaration: KoinAppDeclaration): KoinApplication

/**
 * Start Koin with pre-configured KoinApplication
 * @param koinApplication - Pre-configured KoinApplication instance
 * @return KoinApplication instance
 */
fun startKoin(koinApplication: KoinApplication): KoinApplication

/**
 * Stop the global Koin context and clean up resources
 */
fun stopKoin()

/**
 * Create KoinApplication instance with configuration
 * @param createEagerInstances - Whether to create eager instances (default: true)
 * @param appDeclaration - Optional configuration block
 * @return KoinApplication instance
 */
fun koinApplication(createEagerInstances: Boolean = true, appDeclaration: KoinAppDeclaration? = null): KoinApplication

/**
 * Create KoinApplication instance with configuration block
 * @param appDeclaration - Configuration block
 * @return KoinApplication instance
 */
fun koinApplication(appDeclaration: KoinAppDeclaration?): KoinApplication

/**
 * Create KoinApplication instance with KoinConfiguration
 * @param configuration - KoinConfiguration instance
 * @return KoinApplication instance
 */
fun koinApplication(configuration: KoinConfiguration?): KoinApplication

import org.koin.core.context.startKoin
import org.koin.core.context.stopKoin
import org.koin.dsl.module
import org.koin.dsl.koinApplication

// Simple startup with modules
startKoin {
    modules(appModule, networkModule)
}

// Advanced startup with configuration
startKoin {
    modules(listOf(appModule, networkModule))
    printLogger(Level.DEBUG)
    allowOverride(false)
    properties(mapOf("api.url" to "https://api.example.com"))
}

// Using koinApplication for more control
val app = koinApplication {
    modules(appModule)
    printLogger(Level.INFO)
}
startKoin(app)

// Pre-configured application
val configuredApp = koinApplication(createEagerInstances = false) {
    modules(testModules)
    allowOverride(true)
}
startKoin(configuredApp)

// Programmatic startup
val koinApp = koinApplication {
    modules(appModule)
}
startKoin(koinApp)

// Shutdown
stopKoin()

/**
 * Load module into running Koin application
 * @param module - Module to load
 */
fun loadKoinModules(module: Module)

/**
 * Load multiple modules into running Koin application
 * @param modules - List of modules to load
 */
fun loadKoinModules(modules: List<Module>)

/**
 * Unload module from running Koin application
 * @param module - Module to unload
 */
fun unloadKoinModules(module: Module)

/**
 * Unload multiple modules from running Koin application  
 * @param modules - List of modules to unload
 */
fun unloadKoinModules(modules: List<Module>)

import org.koin.core.context.loadKoinModules
import org.koin.core.context.unloadKoinModules

// Load additional modules at runtime
fun enableFeature() {
    val featureModule = module {
        single<FeatureService> { FeatureServiceImpl() }
    }
    loadKoinModules(featureModule)
}

// Load multiple modules
fun loadPluginModules(plugins: List<Plugin>) {
    val pluginModules = plugins.map { plugin ->
        module {
            single { plugin.getService() }
        }
    }
    loadKoinModules(pluginModules)
}

// Unload modules when feature is disabled
fun disableFeature() {
    unloadKoinModules(featureModule)
}

class KoinApplication {
    /**
     * Get the Koin instance
     */
    val koin: Koin
    
    companion object {
        /**
         * Initialize new KoinApplication
         * @return KoinApplication instance
         */
        fun init(): KoinApplication
    }
    /**
     * Add modules to the application
     * @param modules - Variable number of Module instances
     * @return KoinApplication for chaining
     */
    fun modules(vararg modules: Module): KoinApplication
    
    /**
     * Add modules to the application
     * @param modules - List of Module instances
     * @return KoinApplication for chaining
     */
    fun modules(modules: List<Module>): KoinApplication
    
    /**
     * Set properties for the application
     * @param values - Map of property key-value pairs
     * @return KoinApplication for chaining
     */
    fun properties(values: Map<String, Any>): KoinApplication
    
    /**
     * Set custom logger for the application
     * @param logger - Logger instance
     * @return KoinApplication for chaining
     */
    fun logger(logger: Logger): KoinApplication
    
    /**
     * Enable console printing logger with specified level
     * @param level - Log level (DEBUG, INFO, WARNING, ERROR, NONE)
     * @return KoinApplication for chaining
     */
    fun printLogger(level: Level = Level.INFO): KoinApplication
    
    /**
     * Allow definition override (disabled by default)
     * @param override - Whether to allow overriding existing definitions
     */
    fun allowOverride(override: Boolean)
    
    /**
     * Create eager instances for definitions marked as createdAtStart
     */
    fun createEagerInstances()
    
    /**
     * Set options for the application
     * @param optionValue - Variable number of option pairs
     * @return KoinApplication for chaining
     */
    fun options(vararg optionValue: Pair<KoinOption, Any>): KoinApplication
    
    /**
     * Close the application and clean up resources
     */
    fun close()
    
    companion object {
        /**
         * Create a new KoinApplication instance
         * @return Empty KoinApplication ready for configuration
         */
        fun init(): KoinApplication
    }
}

import org.koin.core.KoinApplication
import org.koin.core.logger.Level
import org.koin.dsl.koinApplication

// Fluent configuration
val app = koinApplication {
    modules(coreModule, dataModule)
    properties(mapOf(
        "db.url" to "jdbc:postgresql://localhost/mydb",
        "api.timeout" to 30
    ))
    printLogger(Level.DEBUG)
    allowOverride(true)
    createEagerInstances()
}

// Programmatic configuration
val app = KoinApplication.init()
    .modules(coreModule)
    .logger(CustomLogger())
    .properties(loadProperties())
    .createEagerInstances()

// Close when done
app.close()

/**
 * Create a KoinApplication instance with DSL configuration
 * @param createEagerInstances - Whether to create eager instances immediately
 * @param appDeclaration - Optional configuration block
 * @return Configured KoinApplication instance
 */
fun koinApplication(
    createEagerInstances: Boolean = true,
    appDeclaration: KoinAppDeclaration? = null
): KoinApplication

import org.koin.dsl.koinApplication

// Simple creation
val app = koinApplication {
    modules(myModule)
}

// With eager instance control
val app = koinApplication(createEagerInstances = false) {
    modules(myModule)
    printLogger()
}

// Just create empty application
val app = koinApplication(createEagerInstances = false)

/**
 * Load additional modules into the global Koin context
 * @param module - Single module to load
 */
fun loadKoinModules(module: Module)

/**
 * Load additional modules into the global Koin context
 * @param modules - List of modules to load
 */
fun loadKoinModules(modules: List<Module>)

/**
 * Unload modules from the global Koin context
 * @param module - Single module to unload
 */
fun unloadKoinModules(module: Module)

/**
 * Unload modules from the global Koin context
 * @param modules - List of modules to unload
 */
fun unloadKoinModules(modules: List<Module>)

import org.koin.core.context.loadKoinModules
import org.koin.core.context.unloadKoinModules

// Load single module
loadKoinModules(featureModule)

// Load multiple modules
loadKoinModules(listOf(featureAModule, featureBModule))

// Unload modules
unloadKoinModules(featureModule)
unloadKoinModules(listOf(featureAModule, featureBModule))

typealias KoinAppDeclaration = KoinApplication.() -> Unit

enum class Level {
    DEBUG, INFO, WARNING, ERROR, NONE
}

abstract class Logger(val level: Level = Level.INFO) {
    abstract fun display(level: Level, msg: MESSAGE)
    fun debug(msg: MESSAGE)
    fun info(msg: MESSAGE) 
    fun warn(msg: MESSAGE)
    fun error(msg: MESSAGE)
    fun log(level: Level, msg: MESSAGE)
    fun isAt(level: Level): Boolean
}

typealias MESSAGE = String

class EmptyLogger : Logger(Level.NONE)