Configuration & Logging

/**
 * Configuration container for KoinApplication setup
 * @param config - Configuration block for KoinApplication
 */
class KoinConfiguration(val config: KoinApplication.() -> Unit) {
    /**
     * Invoke the configuration
     * @return Configuration function
     */
    operator fun invoke(): KoinApplication.() -> Unit
    
    /**
     * Get the application declaration
     */
    val appDeclaration: KoinApplication.() -> Unit
}

/**
 * Create a reusable Koin configuration
 * @param declaration - Configuration block
 * @return KoinConfiguration instance
 */
fun koinConfiguration(declaration: KoinAppDeclaration): KoinConfiguration

import org.koin.core.context.startKoin
import org.koin.dsl.koinConfiguration

// Create reusable configuration
val baseConfig = koinConfiguration {
    logger(PrintLogger(Level.DEBUG))
    allowOverride(false)
    properties(mapOf(
        "api.baseUrl" to "https://api.example.com",
        "db.connectionPool" to "10"
    ))
}

val testConfig = koinConfiguration {
    baseConfig()
    properties(mapOf(
        "api.baseUrl" to "https://test-api.example.com"
    ))
}

// Use in different contexts
fun startProduction() {
    startKoin(baseConfig) {
        modules(productionModules)
    }
}

fun startTesting() {
    startKoin(testConfig) {
        modules(testModules)
    }
}

/**
 * Include configuration declarations in KoinApplication
 * @param configurations - Variable number of configuration declarations
 * @return KoinApplication for chaining
 */
fun KoinApplication.includes(vararg configurations: KoinAppDeclaration?): KoinApplication

/**
 * Include KoinConfiguration instances in KoinApplication
 * @param configurations - Variable number of KoinConfiguration instances
 * @return KoinApplication for chaining
 */
fun KoinApplication.includes(vararg configurations: KoinConfiguration?): KoinApplication

import org.koin.core.context.startKoin
import org.koin.dsl.koinConfiguration

val loggingConfig = koinConfiguration {
    printLogger(Level.INFO)
}

val propertiesConfig = koinConfiguration {
    properties(mapOf("env" to "production"))
}

val securityConfig: KoinAppDeclaration = {
    allowOverride(false)
}

// Compose configurations
startKoin {
    includes(loggingConfig, propertiesConfig, securityConfig)
    modules(appModules)
}

/**
 * Abstract base class for Koin logging implementations
 * @param level - Default logging level
 */
abstract class Logger(var level: Level = Level.INFO) {
    /**
     * Display message at specified level
     * @param level - Log level for the message
     * @param msg - Message to display
     */
    abstract fun display(level: Level, msg: MESSAGE)
    
    /**
     * Log debug message
     * @param msg - Debug message
     */
    fun debug(msg: MESSAGE)
    
    /**
     * Log info message
     * @param msg - Info message
     */
    fun info(msg: MESSAGE)
    
    /**
     * Log warning message
     * @param msg - Warning message
     */
    fun warn(msg: MESSAGE)
    
    /**
     * Log error message
     * @param msg - Error message
     */
    fun error(msg: MESSAGE)
    
    /**
     * Check if logger is at specified level
     * @param lvl - Level to check
     * @return True if logger is at or above the level
     */
    inline fun isAt(lvl: Level): Boolean
    
    /**
     * Log message at specified level
     * @param lvl - Log level
     * @param msg - Message string
     */
    fun log(lvl: Level, msg: String)
    
    /**
     * Log message at specified level with lazy evaluation
     * @param lvl - Log level
     * @param msg - Message function (evaluated only if level is active)
     */
    inline fun log(lvl: Level, msg: () -> String)
}

/**
 * Logging levels for Koin framework
 */
enum class Level {
    /** Detailed debugging information */
    DEBUG,
    /** General information messages */
    INFO,
    /** Warning messages for potential issues */
    WARNING,
    /** Error messages for failures */
    ERROR,
    /** No logging */
    NONE
}

typealias MESSAGE = String
const val KOIN_TAG = "[Koin]"

import org.koin.core.logger.Logger
import org.koin.core.logger.Level
import org.koin.core.context.startKoin

// Custom logger implementation
class FileLogger(level: Level = Level.INFO) : Logger(level) {
    override fun display(level: Level, msg: MESSAGE) {
        val timestamp = System.currentTimeMillis()
        val logEntry = "[$timestamp] [${level.name}] $KOIN_TAG $msg"
        writeToFile(logEntry)
    }
    
    private fun writeToFile(entry: String) {
        // File writing implementation
    }
}

// Use custom logger
startKoin {
    logger(FileLogger(Level.DEBUG))
    modules(appModule)
}

// Built-in print logger with different levels
startKoin {
    printLogger(Level.WARNING) // Only warnings and errors
    modules(appModule)
}

// Conditional logging
class ConditionalLogger : Logger() {
    override fun display(level: Level, msg: MESSAGE) {
        if (isAt(level)) {
            println("$KOIN_TAG [$level] $msg")
        }
    }
}

/**
 * Built-in logger using standard output
 * @param level - Logging level (default: INFO)
 */
class PrintLogger(level: Level = Level.INFO) : Logger(level)

/**
 * Configure KoinApplication with print logger
 * @param level - Logging level (default: INFO)
 * @return KoinApplication for chaining
 */
fun KoinApplication.printLogger(level: Level = Level.INFO): KoinApplication

import org.koin.core.logger.Level
import org.koin.core.logger.PrintLogger
import org.koin.core.context.startKoin

// Direct logger instantiation
val logger = PrintLogger(Level.DEBUG)
startKoin {
    logger(logger)
    modules(appModule)
}

// Using convenience method
startKoin {
    printLogger(Level.INFO)
    modules(appModule)
}

// Different levels for different environments
fun configureLogging(isDevelopment: Boolean) {
    val logLevel = if (isDevelopment) Level.DEBUG else Level.WARNING
    
    startKoin {
        printLogger(logLevel)
        modules(appModule)
    }
}

typealias KoinAppDeclaration = KoinApplication.() -> Unit
typealias MESSAGE = String

const val KOIN_TAG = "[Koin]"