import kotlinx.coroutines.*
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
import java.lang.RuntimeException
import kotlin.Exception
import kotlin.concurrent.thread
import kotlin.coroutines.resume
import kotlin.coroutines.resumeWithException
import kotlin.coroutines.suspendCoroutine

fun main() {
    // startGlobalCoroutine()
    // commonUsage()
    withContextUsage()
}

fun startGlobalCoroutine() {
    // GlobalScope.launch 函数每次创建的都是顶层协程，
    // 这种协程当应用程序运行结束也会一起结束。
    GlobalScope.launch {
        println("codes run in coroutines scope")
        // delay函数可以让当前协程延迟指定时间后再运行。
        // delay函数只能再协程的作用域或其他挂起函数中调用。
        delay(1500)
        // 下面这条打印没有执行，因为他还没有来的急执行程序已经结束
        println("codes run in coroutines scope finished")
    }
    Thread.sleep(1000)
}

fun startRunBlock() {
    // runBlocking函数同样会创建一个协程的作用域，
    // 但是它可以保证再协程作用域内的所有代码和子协程没有全部执行完之前一直阻塞当前线程
    // runBlocking测试环境使用
    runBlocking {
        println("codes run in coroutines scope")
        // delay函数可以让当前协程延迟指定时间后再运行。
        // delay函数只能再协程的作用域或其他挂起函数中调用。
        delay(1500)
        println("codes run in coroutines scope finished")
    }
}

fun startMutiCoroutine() {
    runBlocking {
        launch {
            println("launch1")
        }
        launch {
            println("launch2")
        }
    }
}

/*
* launch函数逻辑复杂，需要提取函数
* launch函数中的代码是拥有协程作用域的
* 使用suspend关键字将任意函数声明成挂起函数，无法提供协程作用域的
* coroutineScope函数 会继承外部的协程作用域并创建一个子作用域
* coroutineScope函数 保证再协程作用域内的所有代码和子协程没有全部执行完之前一直阻塞当前线程
* */
class Test {
    suspend fun printDot() = coroutineScope {
        launch {
            println(" . ")
            delay(1000)
        }
    }
}

fun commonUsage() {
    val job = Job()
    val scope = CoroutineScope(job)
    // 使用CoroutineScope的launch函数所创建的协程都会被关联再Job对象的作用域下
    scope.launch {
        val result = async {
            5+5
        }.await()
        println("结果：$result")
    }
    Thread.sleep(1000)
    println("结果end/end")
    scope.cancel()
}

fun withContextUsage() {
    runBlocking {
        // withContext()函数是一个挂起函数，可以理解为async函数的简化版写法
        val result = withContext(Dispatchers.Default) {
            55 + 5
        }
        println("withContextUsage结果：$result")
    }
}

// ------使用协程简化回调的写法---------
interface HttpCallbackListener {
    fun onFinish(response: String)
    fun onError(e: Exception)
}

object HttpUtil {
    fun sendHttpRequest(address: String, listener: HttpCallbackListener) {
        thread {

        }
    }
}
// suspendCoroutine函数必须在协程作用域或者挂起函数中才能调用，
// 它接收一个Lambda表达式，主要作用是将当前协程立即挂起，然后在一个普通线程中执行lambda表达式代码

suspend fun request(address: String): String {
    return suspendCoroutine {
        HttpUtil.sendHttpRequest(address, object : HttpCallbackListener{
            override fun onFinish(response: String) {
                it.resume(response)
            }
            override fun onError(e: Exception) {
                it.resumeWithException(e)
            }
        })
    }
}
suspend fun getBaiduResponse() {
    try {
        val response = request("https://www.baidu.com")
    } catch (e: Exception) {
        // 请求异常处理
    }
}

// 简写Retrofit的网络请求
suspend fun <T> Call<T>.waite(): T {
    return suspendCoroutine {
        enqueue(object: Callback<T> {
            override fun onResponse(call: Call<T>, response: Response<T>) {
                val body = response.body()
                if (body != null) {
                    it.resume(body)
                } else {
                    it.resumeWithException(RuntimeException("body is null"))
                }
            }

            override fun onFailure(call: Call<T>, t: Throwable) {
                it.resumeWithException(t)
            }

        })
    }
}