Component Integration & Injection

/**
 * Base component interface for Koin integration
 * Provides access to the Koin container for dependency resolution
 */
interface KoinComponent {
    /**
     * Get the Koin instance
     * @return Current Koin instance
     */
    fun getKoin(): Koin
}

import org.koin.core.component.KoinComponent
import org.koin.core.component.inject
import org.koin.core.component.get

class UserController : KoinComponent {
    // Lazy injection - resolved on first access
    private val userService: UserService by inject()
    
    // Direct injection - resolved immediately
    private val logger = get<Logger>()
    
    fun createUser(userData: UserData): User {
        logger.info("Creating user")
        return userService.create(userData)
    }
}

class DataProcessor : KoinComponent {
    override fun getKoin(): Koin {
        // Custom Koin instance if needed
        return customKoinInstance
    }
}

/**
 * Lazy inject dependency with optional qualifier and parameters
 * @param qualifier - Optional qualifier to distinguish instances
 * @param mode - Thread safety mode for lazy initialization
 * @param parameters - Optional parameters for dependency creation
 * @return Lazy delegate for the dependency
 */
inline fun <reified T> KoinComponent.inject(
    qualifier: Qualifier? = null,
    mode: LazyThreadSafetyMode = LazyThreadSafetyMode.SYNCHRONIZED,
    noinline parameters: ParametersDefinition? = null
): Lazy<T>

/**
 * Lazy inject dependency with nullable result
 * @param qualifier - Optional qualifier to distinguish instances
 * @param mode - Thread safety mode for lazy initialization  
 * @param parameters - Optional parameters for dependency creation
 * @return Lazy delegate for the nullable dependency
 */
inline fun <reified T> KoinComponent.injectOrNull(
    qualifier: Qualifier? = null,
    mode: LazyThreadSafetyMode = LazyThreadSafetyMode.SYNCHRONIZED,
    noinline parameters: ParametersDefinition? = null
): Lazy<T?>

import org.koin.core.component.KoinComponent
import org.koin.core.component.inject
import org.koin.core.component.injectOrNull
import org.koin.core.qualifier.named

class OrderService : KoinComponent {
    // Basic lazy injection
    private val userService: UserService by inject()
    
    // Injection with qualifier
    private val primaryDb: Database by inject(named("primary"))
    private val cacheDb: Database by inject(named("cache"))
    
    // Injection with parameters
    private val apiClient: ApiClient by inject {
        parametersOf("https://api.example.com", 30)
    }
    
    // Nullable injection
    private val optionalService: OptionalService? by injectOrNull()
    
    // Non-synchronized lazy injection for performance
    private val logger: Logger by inject(mode = LazyThreadSafetyMode.NONE)
    
    fun processOrder(orderId: String) {
        logger.info("Processing order $orderId")
        val user = userService.findById(orderId)
        // Dependencies resolved on first access
    }
}

/**
 * Get dependency directly from container
 * @param qualifier - Optional qualifier to distinguish instances
 * @param parameters - Optional parameters for dependency creation
 * @return Resolved dependency instance
 */
inline fun <reified T> KoinComponent.get(
    qualifier: Qualifier? = null,
    noinline parameters: ParametersDefinition? = null
): T

/**
 * Get dependency with nullable result
 * @param qualifier - Optional qualifier to distinguish instances
 * @param parameters - Optional parameters for dependency creation
 * @return Resolved dependency instance or null if not found
 */
inline fun <reified T> KoinComponent.getOrNull(
    qualifier: Qualifier? = null,
    noinline parameters: ParametersDefinition? = null
): T?

/**
 * Get all instances of a given type
 * @return List of all resolved instances
 */
inline fun <reified T> KoinComponent.getAll(): List<T>

import org.koin.core.component.KoinComponent
import org.koin.core.component.get
import org.koin.core.component.getOrNull
import org.koin.core.component.getAll
import org.koin.core.qualifier.named

class ServiceManager : KoinComponent {
    
    fun initializeServices() {
        // Direct retrieval
        val logger = get<Logger>()
        logger.info("Initializing services")
        
        // Retrieval with qualifier
        val primaryDb = get<Database>(named("primary"))
        val cacheDb = get<Database>(named("cache"))
        
        // Retrieval with parameters
        val httpClient = get<HttpClient> {
            parametersOf("https://api.example.com", timeout = 30)
        }
        
        // Nullable retrieval
        val optionalService = getOrNull<OptionalService>()
        optionalService?.initialize()
        
        // Get all instances
        val allValidators = getAll<Validator>()
        allValidators.forEach { it.configure() }
    }
}

/**
 * Inject dependency into mutable property
 * @param qualifier - Optional qualifier to distinguish instances
 * @param parameters - Optional parameters for dependency creation
 */
fun <T> KMutableProperty0<T>.inject(
    qualifier: Qualifier? = null,
    parameters: ParametersDefinition? = null
)

/**
 * Inject dependency into mutable property using specific Koin instance
 * @param koin - Koin instance to use for injection
 * @param qualifier - Optional qualifier to distinguish instances
 * @param parameters - Optional parameters for dependency creation
 */
fun <T> KMutableProperty0<T>.inject(
    koin: Koin,
    qualifier: Qualifier? = null,
    parameters: ParametersDefinition? = null
)

/**
 * Inject dependency into mutable property using specific scope
 * @param scope - Scope to use for injection
 * @param qualifier - Optional qualifier to distinguish instances
 * @param parameters - Optional parameters for dependency creation
 */
fun <T> KMutableProperty0<T>.inject(
    scope: Scope,
    qualifier: Qualifier? = null,
    parameters: ParametersDefinition? = null
)

import org.koin.ext.inject
import org.koin.core.component.KoinComponent

class ConfigurableService : KoinComponent {
    // Mutable properties for injection
    lateinit var logger: Logger
    lateinit var database: Database
    
    fun configure() {
        // Inject into properties
        ::logger.inject()
        ::database.inject(named("primary"))
        
        // Now properties are initialized
        logger.info("Service configured")
    }
}

// Standalone property injection
class GlobalConfig {
    lateinit var appSettings: AppSettings
    
    fun initialize(koin: Koin) {
        ::appSettings.inject(koin)
    }
}

/**
 * Scoped component interface extending KoinComponent
 * Provides direct access to a specific scope
 */
interface KoinScopeComponent : KoinComponent {
    /**
     * The scope associated with this component
     */
    val scope: Scope
}

import org.koin.core.component.KoinScopeComponent
import org.koin.core.scope.Scope
import org.koin.core.qualifier.named

class UserSessionComponent(override val scope: Scope) : KoinScopeComponent {
    // Inject from component's scope
    private val userPreferences: UserPreferences by scope.inject()
    private val sessionData: SessionData by scope.inject()
    
    fun getUserData(): UserData {
        return UserData(
            preferences = userPreferences,
            session = sessionData
        )
    }
}

// Scope creation and component usage
class UserController : KoinComponent {
    fun createUserSession(userId: String): UserSessionComponent {
        val userScope = getKoin().createScope(userId, named<UserScope>())
        return UserSessionComponent(userScope)
    }
}

/**
 * Create a new scope for the component
 * @param scopeId - Unique identifier for the scope
 * @param qualifier - Scope qualifier/type
 * @return New scope instance
 */
fun KoinScopeComponent.createScope(
    scopeId: String = generateId(),
    qualifier: Qualifier
): Scope

/**
 * Get existing scope or null
 * @param scopeId - Scope identifier
 * @param qualifier - Scope qualifier/type
 * @return Existing scope or null
 */  
fun KoinScopeComponent.getScopeOrNull(
    scopeId: String,
    qualifier: Qualifier
): Scope?

/**
 * Create scope lazily
 * @param scopeId - Scope identifier
 * @param qualifier - Scope qualifier/type
 * @return Lazy delegate for scope
 */
fun KoinScopeComponent.newScope(
    scopeId: String = generateId(),
    qualifier: Qualifier
): Lazy<Scope>

/**
 * Get existing scope or create new one
 * @param scopeId - Scope identifier  
 * @param qualifier - Scope qualifier/type
 * @return Existing or new scope
 */
fun KoinScopeComponent.getOrCreateScope(
    scopeId: String = generateId(),
    qualifier: Qualifier
): Scope

import org.koin.core.component.KoinScopeComponent
import org.koin.core.component.createScope
import org.koin.core.component.getOrCreateScope
import org.koin.core.qualifier.named

class FeatureComponent : KoinScopeComponent {
    // Lazy scope creation
    override val scope: Scope by newScope(qualifier = named<FeatureScope>())
    
    // Alternative: explicit scope management
    private val featureScope = createScope("feature-123", named<FeatureScope>())
    
    fun processFeature() {
        // Use scoped dependencies
        val processor = scope.get<FeatureProcessor>()
        processor.process()
    }
    
    fun cleanup() {
        scope.close()
    }
}

typealias ParametersDefinition = () -> ParametersHolder

class Koin {
    inline fun <reified T> inject(
        qualifier: Qualifier? = null,
        mode: LazyThreadSafetyMode = LazyThreadSafetyMode.SYNCHRONIZED,
        noinline parameters: ParametersDefinition? = null
    ): Lazy<T>
    
    inline fun <reified T> get(
        qualifier: Qualifier? = null,
        noinline parameters: ParametersDefinition? = null
    ): T
    
    fun createScope(scopeId: String, qualifier: Qualifier): Scope
    fun getScope(scopeId: String): Scope
    fun deleteScope(scopeId: String)
    fun close()
}

enum class LazyThreadSafetyMode {
    SYNCHRONIZED, PUBLICATION, NONE
}