Module Definition & Dependencies

/**
 * Create a new Module with dependency definitions
 * @param createdAtStart - Whether to create instances at application start
 * @param moduleDeclaration - DSL block for defining dependencies
 * @return Module instance with defined dependencies
 */
fun module(createdAtStart: Boolean = false, moduleDeclaration: ModuleDeclaration): Module

import org.koin.dsl.module

// Basic module
val appModule = module {
    single<UserService> { UserServiceImpl() }
    factory<UserRepository> { UserRepositoryImpl() }
}

// Module with eager creation
val eagerModule = module(createdAtStart = true) {
    single<DatabaseConnection> { DatabaseConnectionImpl() }
}

// Module with dependencies
val serviceModule = module {
    single<Database> { PostgreSQLDatabase() }
    single<UserRepository> { UserRepositoryImpl(get()) }
    factory<UserService> { UserServiceImpl(get()) }
}

/**
 * Define a singleton instance
 * @param qualifier - Optional qualifier to distinguish instances
 * @param createdAtStart - Whether to create instance at application start
 * @param definition - Factory function to create the instance
 * @return KoinDefinition for additional configuration
 */
inline fun <reified T> Module.single(
    qualifier: Qualifier? = null,
    createdAtStart: Boolean = false,
    noinline definition: Definition<T>
): KoinDefinition<T>

/**
 * Define a singleton using constructor reference (up to 22 parameters)
 * @param qualifier - Optional qualifier to distinguish instances
 * @param createdAtStart - Whether to create instance at application start
 * @return KoinDefinition for additional configuration
 */
inline fun <reified T> Module.singleOf(
    constructor: () -> T,
    qualifier: Qualifier? = null,
    createdAtStart: Boolean = false
): KoinDefinition<T>

import org.koin.dsl.module
import org.koin.core.qualifier.named

val singletonModule = module {
    // Simple singleton
    single<ApiService> { ApiServiceImpl() }
    
    // Singleton with dependencies
    single<UserRepository> { UserRepositoryImpl(get()) }
    
    // Singleton with qualifier
    single<Database>(named("primary")) { PostgreSQLDatabase() }
    single<Database>(named("cache")) { RedisDatabase() }
    
    // Eager singleton (created at startup)
    single<Logger>(createdAtStart = true) { LoggerImpl() }
    
    // Constructor reference singleton
    singleOf(::UserServiceImpl)
    singleOf(::ApiClientImpl, qualifier = named("v1"))
}

/**
 * Define a factory instance (new instance per request)
 * @param qualifier - Optional qualifier to distinguish instances
 * @param definition - Factory function to create instances
 * @return KoinDefinition for additional configuration
 */
inline fun <reified T> Module.factory(
    qualifier: Qualifier? = null,
    noinline definition: Definition<T>
): KoinDefinition<T>

/**
 * Define a factory using constructor reference (up to 22 parameters)
 * @param qualifier - Optional qualifier to distinguish instances
 * @return KoinDefinition for additional configuration
 */
inline fun <reified T> Module.factoryOf(
    constructor: () -> T,
    qualifier: Qualifier? = null
): KoinDefinition<T>

import org.koin.dsl.module
import org.koin.core.qualifier.named

val factoryModule = module {
    // Simple factory
    factory<HttpClient> { HttpClientImpl() }
    
    // Factory with dependencies
    factory<OrderService> { OrderServiceImpl(get(), get()) }
    
    // Factory with qualifier
    factory<Validator>(named("email")) { EmailValidator() }
    factory<Validator>(named("phone")) { PhoneValidator() }
    
    // Constructor reference factory
    factoryOf(::RequestHandlerImpl)
    factoryOf(::DataProcessorImpl, qualifier = named("json"))
}

/**
 * Create scope definition block
 * @param qualifier - Scope qualifier
 * @param scopeSet - DSL block for defining scoped dependencies
 */
fun Module.scope(qualifier: Qualifier, scopeSet: ScopeDSL.() -> Unit)

class ScopeDSL {
    /**
     * Define a scoped instance
     * @param qualifier - Optional qualifier to distinguish instances
     * @param definition - Factory function to create the instance
     * @return KoinDefinition for additional configuration
     */
    inline fun <reified T> scoped(
        qualifier: Qualifier? = null,
        noinline definition: Definition<T>
    ): KoinDefinition<T>
    
    /**
     * Define a scoped instance using constructor reference
     * @param qualifier - Optional qualifier to distinguish instances
     * @return KoinDefinition for additional configuration
     */
    inline fun <reified T> scopedOf(
        constructor: () -> T,
        qualifier: Qualifier? = null
    ): KoinDefinition<T>
    
    /**
     * Define a factory instance within scope
     * @param qualifier - Optional qualifier to distinguish instances
     * @param definition - Factory function to create instances
     * @return KoinDefinition for additional configuration
     */
    inline fun <reified T> factory(
        qualifier: Qualifier? = null,
        noinline definition: Definition<T>
    ): KoinDefinition<T>
}

import org.koin.dsl.module
import org.koin.core.qualifier.named

// Define scope qualifier
val userScope = named<UserScope>()

val scopedModule = module {
    scope(userScope) {
        // Scoped instance - one per scope
        scoped<UserSession> { UserSessionImpl(get()) }
        
        // Factory within scope - new instance per request within scope
        factory<UserAction> { UserActionImpl(get()) }
        
        // Constructor reference scoped
        scopedOf(::UserPreferencesImpl)
    }
}

/**
 * Bind additional type to the definition
 * @param secondaryType - Additional type to bind
 * @return KoinDefinition for chaining
 */
inline fun <reified T, reified U> KoinDefinition<T>.bind(): KoinDefinition<T>

/**
 * Bind multiple types to the definition
 * @param types - Array of additional types to bind
 * @return KoinDefinition for chaining
 */
fun <T> KoinDefinition<T>.binds(vararg types: KClass<*>): KoinDefinition<T>

/**
 * Add close callback to the definition
 * @param onClose - Callback function executed when instance is closed
 * @return KoinDefinition for chaining
 */
fun <T> KoinDefinition<T>.onClose(onClose: OnCloseCallback<T>): KoinDefinition<T>

import org.koin.dsl.module

val bindingModule = module {
    // Bind interface to implementation
    single<UserRepositoryImpl> { UserRepositoryImpl(get()) }
        .bind<UserRepository>()
    
    // Bind multiple interfaces
    single<DatabaseServiceImpl> { DatabaseServiceImpl() }
        .binds(arrayOf(DatabaseService::class, HealthCheckable::class))
    
    // Add close callback
    single<ConnectionPool> { ConnectionPoolImpl() }
        .onClose { pool -> pool.closeAllConnections() }
}

class Module {
    /**
     * Include other modules in this module
     * @param modules - Modules to include
     */
    fun includes(vararg modules: Module): Module
    
    /**
     * Add this module to another module
     * @param module - Target module
     * @return Combined module
     */
    operator fun plus(module: Module): Module
}

import org.koin.dsl.module

val coreModule = module {
    single<Logger> { LoggerImpl() }
}

val dataModule = module {
    single<Database> { DatabaseImpl() }
}

val serviceModule = module {
    includes(coreModule, dataModule)
    single<UserService> { UserServiceImpl(get(), get()) }
}

// Module composition with plus operator
val combinedModule = coreModule + dataModule + serviceModule

typealias ModuleDeclaration = Module.() -> Unit
typealias Definition<T> = Scope.(ParametersHolder) -> T
typealias OnCloseCallback<T> = (T?) -> Unit

class Module(val createdAtStart: Boolean = false) {
    val id: String
    val isLoaded: Boolean
}

class KoinDefinition<T>(
    val qualifier: Qualifier?,
    val definition: Definition<T>,
    val kind: Kind,
    val secondaryTypes: List<KClass<*>>
) {
    enum class Kind { Single, Factory, Scoped }
}

class ScopeDSL(val qualifier: Qualifier, val module: Module)