kotlinx-coroutines-core

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.channels.*
import kotlinx.coroutines.sync.*

// Core coroutine builders and scope
import kotlinx.coroutines.launch
import kotlinx.coroutines.async
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.MainScope

// Flow API
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.MutableStateFlow

// Channels
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.channels.produce

// Dispatchers
import kotlinx.coroutines.Dispatchers

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

// Create a coroutine scope
val scope = MainScope()

// Launch a fire-and-forget coroutine
val job = scope.launch {
    delay(1000)
    println("Coroutine completed!")
}

// Launch a coroutine that returns a result
val deferred = scope.async {
    delay(500)
    "Hello from async!"
}

// Create and collect a Flow
val numberFlow = flow {
    for (i in 1..5) {
        emit(i)
        delay(100)
    }
}

scope.launch {
    numberFlow.collect { value ->
        println("Received: $value")
    }
}

// Wait for results
scope.launch {
    val result = deferred.await()
    println(result)
}

interface CoroutineScope {
    val coroutineContext: CoroutineContext
}

fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job

fun <T> CoroutineScope.async(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> T
): Deferred<T>

fun CoroutineScope(context: CoroutineContext): CoroutineScope
fun MainScope(): CoroutineScope

interface Job : CoroutineContext.Element {
    val isActive: Boolean
    val isCompleted: Boolean
    val isCancelled: Boolean
    val children: Sequence<Job>
    
    fun start(): Boolean
    fun cancel(cause: CancellationException? = null)
    suspend fun join()
}

interface Deferred<out T> : Job {
    suspend fun await(): T
    fun getCompleted(): T
    val onAwait: SelectClause1<T>
}

interface CompletableJob : Job {
    fun complete(): Boolean
    fun completeExceptionally(exception: Throwable): Boolean
}

abstract class CoroutineDispatcher : AbstractCoroutineContextElement(ContinuationInterceptor), ContinuationInterceptor {
    abstract fun dispatch(context: CoroutineContext, block: Runnable)
    open fun isDispatchNeeded(context: CoroutineContext): Boolean
    fun limitedParallelism(parallelism: Int): CoroutineDispatcher
}

object Dispatchers {
    val Default: CoroutineDispatcher
    val Main: MainCoroutineDispatcher
    val Unconfined: CoroutineDispatcher
}

abstract class MainCoroutineDispatcher : CoroutineDispatcher() {
    abstract val immediate: MainCoroutineDispatcher
}

interface Flow<out T> {
    suspend fun collect(collector: FlowCollector<T>)
}

interface FlowCollector<in T> {
    suspend fun emit(value: T)
}

interface StateFlow<out T> : SharedFlow<T> {
    val value: T
}

interface MutableStateFlow<T> : StateFlow<T>, MutableSharedFlow<T> {
    override var value: T
    fun compareAndSet(expect: T, update: T): Boolean
}

fun <T> MutableStateFlow<T>.update(function: (T) -> T)
fun <T> MutableStateFlow<T>.updateAndGet(function: (T) -> T): T
fun <T> MutableStateFlow<T>.getAndUpdate(function: (T) -> T): T

interface SharedFlow<out T> : Flow<T> {
    val replayCache: List<T>
    val subscriptionCount: StateFlow<Int>
}

interface MutableSharedFlow<T> : SharedFlow<T>, FlowCollector<T> {
    fun tryEmit(value: T): Boolean
    fun resetReplayCache()
}

interface Channel<E> : SendChannel<E>, ReceiveChannel<E>

interface SendChannel<in E> {
    val isClosedForSend: Boolean
    suspend fun send(element: E)
    fun trySend(element: E): ChannelResult<Unit>
    fun close(cause: Throwable? = null): Boolean
}

interface ReceiveChannel<out E> {
    val isClosedForReceive: Boolean
    suspend fun receive(): E
    fun tryReceive(): ChannelResult<E>
    fun cancel(cause: CancellationException? = null)
}

fun <E> Channel(
    capacity: Int = Channel.RENDEZVOUS,
    onBufferOverflow: BufferOverflow = BufferOverflow.SUSPEND,
    onUndeliveredElement: ((E) -> Unit)? = null
): Channel<E>

interface Mutex {
    val isLocked: Boolean
    suspend fun lock(owner: Any? = null)
    fun tryLock(owner: Any? = null): Boolean
    fun unlock(owner: Any? = null)
    suspend fun <T> withLock(owner: Any? = null, action: suspend () -> T): T
}

interface Semaphore {
    val availablePermits: Int
    suspend fun acquire()
    fun tryAcquire(): Boolean
    fun release()
    suspend fun <T> withPermit(action: suspend () -> T): T
}

fun Mutex(locked: Boolean = false): Mutex
fun Semaphore(permits: Int, acquiredPermits: Int = 0): Semaphore

suspend fun <T> coroutineScope(block: suspend CoroutineScope.() -> T): T
suspend fun <T> supervisorScope(block: suspend CoroutineScope.() -> T): T
suspend fun <T> withContext(context: CoroutineContext, block: suspend CoroutineScope.() -> T): T
suspend fun <T> withTimeout(timeoutMillis: Long, block: suspend CoroutineScope.() -> T): T
suspend fun <T> withTimeoutOrNull(timeoutMillis: Long, block: suspend CoroutineScope.() -> T): T?

suspend fun delay(timeMillis: Long)
suspend fun delay(duration: Duration)
suspend fun yield()
suspend fun awaitCancellation(): Nothing
suspend fun currentCoroutineContext(): CoroutineContext
fun CoroutineContext.ensureActive()

suspend fun <R> select(builder: SelectBuilder<R>.() -> Unit): R
suspend fun <R> selectUnbiased(builder: SelectBuilder<R>.() -> Unit): R

interface SelectBuilder<in R> {
    fun onTimeout(timeMillis: Long, block: suspend () -> R)
}

// Select clauses available on various types
val Job.onJoin: SelectClause0
val <T> Deferred<T>.onAwait: SelectClause1<T>
val <E> SendChannel<E>.onSend: SelectClause2<E, SendChannel<E>>
val <E> ReceiveChannel<E>.onReceive: SelectClause1<E>
val <E> ReceiveChannel<E>.onReceiveCatching: SelectClause1<ChannelResult<E>>

interface CoroutineExceptionHandler : CoroutineContext.Element {
    fun handleException(context: CoroutineContext, exception: Throwable)
}

open class CancellationException(message: String? = null, cause: Throwable? = null) : IllegalStateException(message, cause)
class TimeoutCancellationException(message: String?, coroutine: Job) : CancellationException(message)

object NonCancellable : AbstractCoroutineContextElement(Job), Job
fun SupervisorJob(parent: Job? = null): CompletableJob

enum class CoroutineStart {
    DEFAULT, LAZY, ATOMIC, UNDISPATCHED
}

data class CoroutineName(val name: String) : AbstractCoroutineContextElement(CoroutineName)

enum class BufferOverflow {
    SUSPEND, DROP_OLDEST, DROP_LATEST
}

object GlobalScope : CoroutineScope {
    override val coroutineContext: CoroutineContext
}

// Select clause interfaces
interface SelectClause0
interface SelectClause1<out T>
interface SelectClause2<in P, out T>

// Duration support
typealias Duration = kotlin.time.Duration

interface SharingStarted {
    companion object {
        val Eagerly: SharingStarted
        val Lazily: SharingStarted
        fun WhileSubscribed(
            stopTimeoutMillis: Long = Long.MAX_VALUE,
            replayExpirationMillis: Long = Long.MAX_VALUE
        ): SharingStarted
    }
}

object Channel {
    const val RENDEZVOUS = 0
    const val CONFLATED = -1
    const val UNLIMITED = Int.MAX_VALUE
    const val BUFFERED = -2
    const val CHANNEL_DEFAULT_CAPACITY = 64
}

value class ChannelResult<out T> {
    val isSuccess: Boolean
    val isClosed: Boolean
    val isFailure: Boolean
    
    fun getOrNull(): T?
    fun exceptionOrNull(): Throwable?
}