Application Configuration

/**
 * Creates a new KoinApplication with optional eager instance creation and configuration
 * @param createEagerInstances - Whether to create eager instances immediately (default: true)
 * @param appDeclaration - Optional DSL configuration block
 * @return KoinApplication instance for further configuration
 */
fun koinApplication(createEagerInstances: Boolean = true, appDeclaration: KoinAppDeclaration? = null): KoinApplication

/**
 * Creates a new KoinApplication with DSL configuration
 * @param appDeclaration - DSL configuration block
 * @return KoinApplication instance
 */
fun koinApplication(appDeclaration: KoinAppDeclaration?): KoinApplication

/**
 * Creates a new KoinApplication from existing configuration
 * @param configuration - Pre-built configuration
 * @return KoinApplication instance
 */
fun koinApplication(configuration: KoinConfiguration?): KoinApplication

/**
 * Creates a new KoinApplication with eager instance creation flag
 * @param createEagerInstances - Whether to create eager instances immediately
 * @return KoinApplication instance
 */
fun koinApplication(createEagerInstances: Boolean): KoinApplication

import org.koin.dsl.koinApplication
import org.koin.dsl.module

// Basic application creation
val app = koinApplication()

// Application with configuration
val app = koinApplication {
    modules(appModule)
    logger(PrintLogger())
}

// Application without eager instances
val app = koinApplication(createEagerInstances = false) {
    modules(appModule)
}

class KoinApplication {
    /** Access to the underlying Koin container */
    val koin: Koin
    
    /** Load a single module into the application */
    fun modules(modules: Module): KoinApplication
    
    /** Load multiple modules into the application */
    fun modules(vararg modules: Module): KoinApplication
    
    /** Load a list of modules into the application */
    fun modules(modules: List<Module>): KoinApplication
    
    /** Create all eager instances immediately */
    fun createEagerInstances()
    
    /** Allow definition overrides in modules */
    fun allowOverride(override: Boolean)
    
    /** Load properties into the application */
    fun properties(values: Map<String, Any>): KoinApplication
    
    /** Set configuration options */
    fun options(vararg optionValue: Pair<KoinOption, Any>): KoinApplication
    
    /** Set a custom logger implementation */
    fun logger(logger: Logger): KoinApplication
    
    /** Set a print logger with specified level */
    fun printLogger(level: Level = Level.INFO): KoinApplication
    
    /** Close the application and cleanup resources */
    fun close()
    
    companion object {
        /** Create a new KoinApplication instance */
        fun init(): KoinApplication
    }
}

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

val userModule = module {
    single { UserService() }
}

val dataModule = module {
    single { DatabaseClient() }
}

// Configure application
val app = KoinApplication.init()
    .modules(userModule, dataModule)
    .properties(mapOf("db.url" to "localhost:5432"))
    .allowOverride(true)
    .printLogger(Level.DEBUG)
    .createEagerInstances()

// Access the Koin container
val koin = app.koin

// Close when done
app.close()

/**
 * Type alias for application configuration DSL blocks
 */
typealias KoinAppDeclaration = KoinApplication.() -> Unit


/**
 * Logger interface for custom logging implementations
 */
interface Logger {
    fun debug(msg: String)
    fun info(msg: String)
    fun error(msg: String)
}

/**
 * Log levels for print logger
 */
enum class Level {
    DEBUG, INFO, ERROR, NONE
}