public fun <E> Channel(
    capacity: Int = RENDEZVOUS,
    onBufferOverflow: BufferOverflow = BufferOverflow.SUSPEND,
    onUndeliveredElement: ((E) -> Unit)? = null
): Channel<E> =
    when (capacity) {
        RENDEZVOUS -> {
            if (onBufferOverflow == BufferOverflow.SUSPEND)
                BufferedChannel(RENDEZVOUS, onUndeliveredElement) // an efficient implementation of rendezvous channel
            else
                ConflatedBufferedChannel(
                    1,
                    onBufferOverflow,
                    onUndeliveredElement
                ) // support buffer overflow with buffered channel
        }
        CONFLATED -> {
            require(onBufferOverflow == BufferOverflow.SUSPEND) {
                "CONFLATED capacity cannot be used with non-default onBufferOverflow"
            }
            ConflatedBufferedChannel(1, BufferOverflow.DROP_OLDEST, onUndeliveredElement)
        }
        UNLIMITED -> BufferedChannel(
            UNLIMITED,
            onUndeliveredElement
        ) // ignores onBufferOverflow: it has buffer, but it never overflows
        BUFFERED -> { // uses default capacity with SUSPEND
            if (onBufferOverflow == BufferOverflow.SUSPEND) BufferedChannel(
                CHANNEL_DEFAULT_CAPACITY,
                onUndeliveredElement
            )
            else ConflatedBufferedChannel(1, onBufferOverflow, onUndeliveredElement)
        }
        else -> {
            if (onBufferOverflow === BufferOverflow.SUSPEND) BufferedChannel(capacity, onUndeliveredElement)
            else ConflatedBufferedChannel(capacity, onBufferOverflow, onUndeliveredElement)
        }
    }

suspend fun demonstrateRendezvousChannel() {
    // 創(chuàng)建 RENDEZVOUS Channel（默認容量為 0），默認什么都不傳就是 rendezvous 模式，Channel<String>()
    val rendezvousChannel = Channel<String>(Channel.RENDEZVOUS)
    // 啟動發(fā)送者協(xié)程
    val senderJob = GlobalScope.launch {
        println("[發(fā)送者] 準備發(fā)送消息...")
        rendezvousChannel.send("Hello from RENDEZVOUS!")
        println("[發(fā)送者] 消息已發(fā)送")
        rendezvousChannel.send("Second message")
        println("[發(fā)送者] 第二條消息已發(fā)送")
        rendezvousChannel.close()
    }
    // 啟動接收者協(xié)程
    val receiverJob = GlobalScope.launch {
        delay(1000) // 延遲1秒，發(fā)送者會等待接收者準備好
        println("[接收者] 開始接收消息...")
        for (message in rendezvousChannel) {
            println("[接收者] 收到消息: $message")
            delay(500) // 模擬處理時間
        }
        println("[接收者] Channel已關閉")
    }
    // 等待所有協(xié)程完成
    joinAll(senderJob, receiverJob)
}

CONFLATED -> {
    require(onBufferOverflow == BufferOverflow.SUSPEND) {
        "CONFLATED capacity cannot be used with non-default onBufferOverflow"
    }
    ConflatedBufferedChannel(1, BufferOverflow.DROP_OLDEST, onUndeliveredElement)
}

suspend fun demonstrateConflatedChannel() {
    // 創(chuàng)建 CONFLATED Channel，相當于：Channel<String>(1, BufferOverflow.DROP_OLDEST)
    val conflatedChannel = Channel<String>(Channel.CONFLATED)
    // 快速發(fā)送多個消息
    val senderJob = GlobalScope.launch {
        repeat(5) { i ->
            val message = "Update-$i"
            conflatedChannel.send(message)
            println("[發(fā)送者] 發(fā)送更新: $message")
            delay(100) // 短暫延遲
        }
        conflatedChannel.close()
    }
    // 慢速接收者
    val receiverJob = GlobalScope.launch {
        delay(1000) // 延遲1秒，讓發(fā)送者發(fā)送完所有消息
        println("[接收者] 開始接收（只會收到最新的值）...")
        for (message in conflatedChannel) {
            println("[接收者] 收到: $message")
        }
    }
    joinAll(senderJob, receiverJob)
}

suspend fun demonstrateUnlimitedChannel() {
    val unlimitedChannel = Channel<String>(Channel.UNLIMITED)
    val senderJob = GlobalScope.launch {
        repeat(10) { i ->
            val message = "Message-$i"
            unlimitedChannel.send(message)
            println("[發(fā)送者] 立即發(fā)送: $message")
        }
        unlimitedChannel.close()
        println("[發(fā)送者] 所有消息已發(fā)送，Channel已關閉")
    }
    val receiverJob = GlobalScope.launch {
        delay(1000) // 延遲1秒開始接收
        println("[接收者] 開始慢速接收...")
        for (message in unlimitedChannel) {
            println("[接收者] 處理: $message")
            delay(300) // 模擬處理時間
        }
    }
    joinAll(senderJob, receiverJob)
}

BUFFERED -> {
    if (onBufferOverflow == BufferOverflow.SUSPEND)
        BufferedChannel(CHANNEL_DEFAULT_CAPACITY, onUndeliveredElement)
    else
        ConflatedBufferedChannel(1, onBufferOverflow, onUndeliveredElement)
}

suspend fun demonstrateBufferedDefaultChannel() {
    // 創(chuàng)建 BUFFERED Channel（默認容量為 64）
    val bufferedChannel = Channel<String>(Channel.BUFFERED)
    val senderJob = GlobalScope.launch {
        repeat(100) { i ->
            bufferedChannel.send("Message-$i")
            println("[發(fā)送者] 發(fā)送 Message-$i")
        }
        bufferedChannel.close()
    }
    val receiverJob = GlobalScope.launch {
        delay(1000) // 延遲接收
        for (message in bufferedChannel) {
            println("[接收者] 收到: $message")
            delay(50)
        }
    }
    joinAll(senderJob, receiverJob)
}

else -> {
    if (onBufferOverflow === BufferOverflow.SUSPEND)
        BufferedChannel(capacity, onUndeliveredElement)
    else
        ConflatedBufferedChannel(capacity, onBufferOverflow, onUndeliveredElement)
}

suspend fun demonstrateBufferedChannel() {
    // 創(chuàng)建容量為3的緩沖Channel
    val bufferedChannel = Channel<Int>(capacity = 3)
    // 啟動發(fā)送者協(xié)程
    val senderJob = GlobalScope.launch {
        repeat(5) { i ->
            println("[發(fā)送者] 發(fā)送數(shù)字: $i")
            bufferedChannel.send(i)
            println("[發(fā)送者] 數(shù)字 $i 已發(fā)送")
        }
        bufferedChannel.close()
        println("[發(fā)送者] Channel已關閉")
    }
    // 啟動接收者協(xié)程，延遲接收以觀察緩沖效果
    val receiverJob = GlobalScope.launch {
        delay(2000) // 延遲2秒開始接收
        println("[接收者] 開始接收數(shù)字...")
        for (number in bufferedChannel) {
            println("[接收者] 收到數(shù)字: $number")
            delay(800) // 模擬慢速處理
        }
    }
    joinAll(senderJob, receiverJob)
}

suspend fun demonstrateBasicOperations() {
    //容量為 2，溢出策略為SUSPEND
    val channel = Channel<String>(capacity = 2, onBufferOverflow = BufferOverflow.SUSPEND)
    //發(fā)送的速度快
    val job1 = GlobalScope.launch {
        repeat(5) {
            channel.send("Message-$it")
            println("[發(fā)送者] 發(fā)送 Message-$it")
        }
        channel.close()
    }
    val job2 = GlobalScope.launch {
        //除了用 channel.recrive 外，也可以直接 用 for 循環(huán)接收數(shù)據(jù)
        for (message in channel) {
            //接收的速度慢
            delay(1000)
            println("[接收者] 接收到: $message")
        }
    }
    joinAll(job1, job2)
}

suspend fun demonstrateBasicOperations() {
    val channel = Channel<String>(capacity = 2, onBufferOverflow = BufferOverflow.DROP_LATEST)
    val job1 = GlobalScope.launch {
        repeat(5) {
            channel.send("Message-$it")
            println("[發(fā)送者] 發(fā)送 Message-$it")
        }
        channel.close()
    }
    val job2 = GlobalScope.launch {
        for (message in channel) {
            delay(1000)
            println("[接收者] 接收到: $message")
        }
    }
    joinAll(job1, job2)
}

suspend fun demonstrateBasicOperations() {
    val channel = Channel<String>(capacity = 2, onBufferOverflow = BufferOverflow.DROP_OLDEST)
    val job1 = GlobalScope.launch {
        repeat(5) {
            channel.send("Message-$it")
            println("[發(fā)送者] 發(fā)送 Message-$it")
        }
        channel.close()
    }
    val job2 = GlobalScope.launch {
        for (message in channel) {
            delay(1000)
            println("[接收者] 接收到: $message")
        }
    }
    joinAll(job1, job2)
}

suspend fun demonstrateBasicOperations() {
    val channel = Channel<String>(capacity = 2, onBufferOverflow = BufferOverflow.DROP_OLDEST) {
        println("[Channel] 緩沖區(qū)已滿，無法放到緩沖區(qū),值：${it}")
    }
    // 演示基本的send和receive操作
    val job1 = GlobalScope.launch {
        repeat(5) {
            channel.send("Message-$it")
            println("[發(fā)送者] 發(fā)送 Message-$it")
        }
        channel.close()
    }
    val job2 = GlobalScope.launch {
        for (message in channel) {
            delay(1000)
            println("[接收者] 接收到: $message")
        }
    }
    joinAll(job1, job2)
}

runBlocking {
    val channel = Channel<Int>(2)
    val sendJob = launch {
        repeat(5) {
            delay(100)
            val sendResult = channel.trySend(it)
            sendResult.onSuccess {
                println("發(fā)送成功")
            }.onFailure {
                println("發(fā)送失敗")
            }.onClosed {
                println("通道已關閉")
            }
        }
    }
    val receiveJob = launch {
        for (i in channel) {
            delay(300)
            println("接收到數(shù)據(jù):${i}")
        }
    }
    joinAll(sendJob, receiveJob)
}

    suspend fun demonstrateChannelClose() {
    val channel = Channel<String>(1)
    val producer = GlobalScope.launch {
        try {
            for (i in 1..5) {
                val message = "Message $i"
                println("準備發(fā)送: $message")
                channel.send(message)
                println("成功發(fā)送: $message")
                delay(100)
            }
        } catch (e: ClosedSendChannelException) {
            println("生產(chǎn)者: Channel已關閉，無法發(fā)送數(shù)據(jù) - ${e.message}")
        }
    }
    val consumer = GlobalScope.launch {
        try {
            for (message in channel) {
                println("接收到: $message")
                delay(200)
            }
            println("消費者: Channel已關閉，退出接收循環(huán)")
        } catch (e: Exception) {
            println("消費者異常: ${e.message}")
        }
    }
    delay(300) // 模擬讓一些數(shù)據(jù)能夠被接收到
    // 檢查Channel狀態(tài)
    println("關閉前狀態(tài):")
    println("  isClosedForSend: ${channel.isClosedForSend}")
    println("  isClosedForReceive: ${channel.isClosedForReceive}")
    // 關閉Channel
    println("\n正在關閉Channel...")
    channel.close()
    // 檢查關閉后的狀態(tài)
    println("關閉后狀態(tài):")
    println("  isClosedForSend: ${channel.isClosedForSend}")
    println("  isClosedForReceive: ${channel.isClosedForReceive}")
    // 等待協(xié)程完成
    producer.join()
    consumer.join()
    println("最終狀態(tài):")
    println("  isClosedForSend: ${channel.isClosedForSend}")
    println("  isClosedForReceive: ${channel.isClosedForReceive}")
}

suspend fun demonstrateChannelCancel() {
    val channel = Channel<String>(capacity = 5) {
        println("消息未被接收:${it}")
    }
    val producer = GlobalScope.launch {
        try {
            for (i in 1..8) {
                val message = "Message $i"
                println("嘗試發(fā)送: $message")
                channel.send(message)
                println("成功發(fā)送: $message")
                delay(100)
            }
        } catch (e: CancellationException) {
            println("生產(chǎn)者: Channel被取消 - ${e.message}")
        }
    }
    val consumer = GlobalScope.launch {
        try {
            for (message in channel) {
                println("接收到: $message")
                delay(300)
            }
        } catch (e: CancellationException) {
            println("消費者: 協(xié)程被取消 - ${e.message}")
        }
    }
    delay(400) // 讓一些操作執(zhí)行
    println("\n取消前狀態(tài):")
    println("  isClosedForSend: ${channel.isClosedForSend}")
    println("  isClosedForReceive: ${channel.isClosedForReceive}")
    // 取消Channel
    println("\n正在取消Channel...")
    channel.cancel(CancellationException("主動取消Channel"))
    println("取消后狀態(tài):")
    println("  isClosedForSend: ${channel.isClosedForSend}")
    println("  isClosedForReceive: ${channel.isClosedForReceive}")
    // 等待協(xié)程完成
    producer.join()
    consumer.join()
}

suspend fun demonstrateClosedSendException() {
    val channel = Channel<String>()
    // 關閉 Channel
    channel.close()
    try {
        // 嘗試在已關閉的 Channel 上發(fā)送數(shù)據(jù)
        channel.send("This will throw exception")
    } catch (e: ClosedSendChannelException) {
        println("捕獲異常: ${e.message}")
        println("異常類型: ${e::class.simpleName}")
    }
}

suspend fun demonstrateClosedReceiveException() {
    val channel = Channel<String>()
    // 關閉 Channel
    channel.close()
    try {
        // 嘗試從已關閉且空的 Channel 接收數(shù)據(jù)
        val message = channel.receive()
        println("收到消息: $message")
    } catch (e: ClosedReceiveChannelException) {
        println("捕獲異常: ${e.message}")
        println("異常類型: ${e::class.simpleName}")
    }
}

suspend fun demonstrateCancellationException() {
    val channel = Channel<String>()
    val job = GlobalScope.launch {
        try {
            // 這個操作會被取消
            channel.send("This will be cancelled")
        } catch (e: CancellationException) {
            println("發(fā)送操作被取消: ${e.message}")
            throw e // 重新拋出 CancellationException
        }
    }
    delay(100)
    // 取消 Channel
    channel.cancel(CancellationException("手動取消 Channel"))
    try {
        job.join()
    } catch (e: CancellationException) {
        println("協(xié)程被取消: ${e.message}")
    }
}

suspend fun safeChannelOperations() {
    val channel = Channel<String>()
    // 安全的發(fā)送操作
    val sendResult = channel.trySend("Safe message")
    when {
        sendResult.isSuccess -> println("發(fā)送成功")
        sendResult.isFailure -> println("發(fā)送失敗: ${sendResult.exceptionOrNull()}")
        sendResult.isClosed -> println("Channel 已關閉")
    }
    // 安全的接收操作
    val receiveResult = channel.tryReceive()
    when {
        receiveResult.isSuccess -> println("接收到: ${receiveResult.getOrNull()}")
        receiveResult.isFailure -> println("接收失敗: ${receiveResult.exceptionOrNull()}")
        receiveResult.isClosed -> println("Channel 已關閉")
    }
}

suspend fun robustChannelUsage() {
    val channel = Channel<String>()
    val producer = GlobalScope.launch {
        try {
            repeat(5) { i ->
                if (channel.isClosedForSend) {
                    println("Channel 已關閉，停止發(fā)送")
                    break
                }
                channel.send("Message $i")
                delay(100)
            }
        } catch (e: ClosedSendChannelException) {
            println("生產(chǎn)者: Channel 已關閉")
        } catch (e: CancellationException) {
            println("生產(chǎn)者: 操作被取消")
            throw e // 重新拋出取消異常
        } finally {
            println("生產(chǎn)者: 清理資源")
        }
    }
    val consumer = GlobalScope.launch {
        try {
            while (!channel.isClosedForReceive) {
                try {
                    val message = channel.receive()
                    println("消費者: 收到 $message")
                } catch (e: ClosedReceiveChannelException) {
                    println("消費者: Channel 已關閉且無更多數(shù)據(jù)")
                    break
                }
                delay(200)
            }
        } catch (e: CancellationException) {
            println("消費者: 操作被取消")
            throw e
        } finally {
            println("消費者: 清理資源")
        }
    }
    delay(1000)
    channel.close()
    joinAll(producer, consumer)
}