Application Setup

/**
 * Start a new Koin Application context and setup Compose context
 * if Koin's Default Context is already set, throw an error
 * 
 * @param application - Koin Application declaration lambda
 * @param content - following compose function
 * @throws KoinApplicationAlreadyStartedException
 */
@Composable
fun KoinApplication(
    application: KoinAppDeclaration,
    content: @Composable () -> Unit
)

import org.koin.compose.KoinApplication
import org.koin.dsl.module

val appModule = module {
    single<ApiService> { ApiServiceImpl() }
    single<Repository> { RepositoryImpl(get()) }
}

@Composable
fun App() {
    KoinApplication(
        application = {
            modules(appModule)
            // Additional Koin configuration
        }
    ) {
        MainContent()
    }
}

/**
 * Start a new Koin Application context, configure default context binding (android) & logger, setup Compose context
 * if Koin's Default Context is already set, throw an error
 *
 * Call composeMultiplatformConfiguration to help prepare/anticipate context setup, and avoid to have different configuration in KMP app
 * this function takes care to setup Android context (androidContext, androidLogger) for you
 * 
 * @param config - Koin Application Configuration (use koinConfiguration { } to declare your Koin application)
 * @param logLevel - KMP active logger (androidLogger or printLogger)
 * @param content - following compose function
 * @throws KoinApplicationAlreadyStartedException
 */
@Composable
@KoinExperimentalAPI
fun KoinMultiplatformApplication(
    config: KoinConfiguration,
    logLevel: Level = Level.INFO,
    content: @Composable () -> Unit
)

import org.koin.compose.KoinMultiplatformApplication
import org.koin.core.logger.Level
import org.koin.dsl.koinConfiguration

@Composable
fun App() {
    KoinMultiplatformApplication(
        config = koinConfiguration {
            modules(appModule)
        },
        logLevel = Level.DEBUG
    ) {
        MainContent()
    }
}

/**
 * Provides Koin Isolated context to be setup into LocalKoinApplication & LocalKoinScope via CompositionLocalProvider,
 * to be used by child Composable.
 *
 * This allows to use an isolated context, directly in all current Composable API
 *
 * Koin isolated context has to created with koinApplication() function, storing the instance in a static field
 *
 * @param context - Koin isolated context
 * @param content - child Composable
 */
@Composable
fun KoinIsolatedContext(
    context: KoinApplication,
    content: @Composable () -> Unit
)

import org.koin.compose.KoinIsolatedContext
import org.koin.dsl.koinApplication

// Create isolated Koin application
val isolatedKoin = koinApplication {
    modules(testModule)
}

@Composable
fun TestComponent() {
    KoinIsolatedContext(
        context = isolatedKoin
    ) {
        // This content uses the isolated Koin context
        ComponentUsingKoin()
    }
}

/**
 * Composable Function to run a local Koin application and to help run Compose preview
 * This function is lighter than KoinApplication, and allow parallel recomposition in Android Studio
 *
 * @param application - Koin application config
 * @param content
 */
@Composable
fun KoinApplicationPreview(
    application: KoinAppDeclaration,
    content: @Composable () -> Unit
)

import androidx.compose.ui.tooling.preview.Preview
import org.koin.compose.KoinApplicationPreview
import org.koin.dsl.module

val previewModule = module {
    single<ApiService> { MockApiService() }
}

@Preview
@Composable
fun UserScreenPreview() {
    KoinApplicationPreview(
        application = {
            modules(previewModule)
        }
    ) {
        UserScreen()
    }
}

/**
 * Use Compose with current existing Koin context, by default 'KoinPlatform.getKoin()'
 *
 * @param content - following compose function
 */
@Composable
@Deprecated("KoinContext is not needed anymore. This can be removed. Compose Koin context is setup with StartKoin()")
fun KoinContext(
    context: Koin = retrieveDefaultInstance(),
    content: @Composable () -> Unit
)

@Composable
internal actual fun composeMultiplatformConfiguration(
    loggerLevel: Level, 
    config: KoinConfiguration
): KoinConfiguration {
    val appContext = LocalContext.current.applicationContext
    return koinConfiguration {
        androidContext(appContext)
        androidLogger(loggerLevel)
        includes(config)
    }
}

@Composable
internal actual fun composeMultiplatformConfiguration(
    loggerLevel: Level,
    config: KoinConfiguration  
): KoinConfiguration {
    return koinConfiguration {
        printLogger(loggerLevel)
        includes(config)
    }
}

// From koin-core
interface KoinConfiguration {
    fun modules(vararg modules: Module): KoinConfiguration
    fun modules(modules: List<Module>): KoinConfiguration
    // Platform-specific extensions added automatically
}

// From koin-dsl
typealias KoinAppDeclaration = KoinApplication.() -> Unit

// Logger levels
enum class Level {
    NONE, ERROR, INFO, DEBUG
}