val service = retrofit.create(WanAndroidService::class.java).proxyRetrofit()
// 执行 test
service.test()
	.onSuccess { println("execute test success ==> $it") }
	.onFailure { println("execute test() failure ==> $it") }
	// 执行 userInfo
	.onFailureThen { service.userInfo() }
	?.onSuccess { println("execute userInfo success ==> $it") }
	?.onFailure { println("execute userInfo() failure ==> $it") }
	// 执行 banner
	?.onFailureThen { service.banner() }
	?.onSuccess { println("execute banner() success ==> $it") }
	?.onFailure { println("execute banner() failure ==> $it") }

suspend fun <T : Any> Call<T>.await(): T {
  return suspendCancellableCoroutine { continuation ->
    continuation.invokeOnCancellation {
      cancel()
    }
    enqueue(object : Callback<T> {
      override fun onResponse(call: Call<T>, response: Response<T>) {
        if (response.isSuccessful) {
          val body = response.body()
          if (body == null) {
            val invocation = call.request().tag(Invocation::class.java)!!
            val method = invocation.method()
            val e = KotlinNullPointerException("Response from " +
                method.declaringClass.name +
                '.' +
                method.name +
                " was null but response body type was declared as non-null")
            // 请求失败
            continuation.resumeWithException(e)
          } else {
            // 请求成功
            continuation.resume(body)
          }
        } else {
          continuation.resumeWithException(HttpException(response))
        }
      }

      override fun onFailure(call: Call<T>, t: Throwable) {
        // 请求失败
        continuation.resumeWithException(t)
      }
    })
  }
}

// resume 方法会返回 success
public inline fun <T> Continuation<T>.resume(value: T): Unit =
    resumeWith(Result.success(value))

// resumeWithException 方法会返回 failure
public inline fun <T> Continuation<T>.resumeWithException(exception: Throwable): Unit =
    resumeWith(Result.failure(exception))

/**
* ThrowableResolver 的作用是在运行时遇到异常后如果处理异常
*/
interface ThrowableResolver<T> {
    // 处理异常，并返回一个处理后的数据
    fun resolve(throwable: Throwable): T
}

/**
* `proxyRetrofit` 方法主要作用是重新对接口进行动态代理，这样就可以在
* `InvocationHandler#invoke` 中对异常进行拦截，这样调用方就不用显示地调用
* `try catch` 了。
*/
inline fun <reified T> T.proxyRetrofit(): T {
    // 获取原先的 retrofit 的代理对象的的 InvocationHandler
    // 这样我就可以继续使用 retrofit 的能力进行网络请求
    val retrofitHandler = Proxy.getInvocationHandler(this)
    return Proxy.newProxyInstance(
        T::class.java.classLoader, arrayOf(T::class.java)
    ) { proxy, method, args ->
        // 判断当前是为 suspend 方法
        method.takeIf { it.isSuspendMethod }?.getSuspendReturnType()
            // 通过方法的返回值获取一个 ThrowableResolver 处理异常
            ?.let { FactoryRegistry.getThrowableResolver(it) }
            ?.let { resolver ->
                // 替换原始的 Contiuation 对象，这样我们就可以对异常进行拦截
                args.updateAt(
                    args.lastIndex,
                    FakeSuccessContinuationWrapper(
                        args.last() as Continuation<Any>,
                        resolver as ThrowableResolver<Any>
                    )
                )
            }
        retrofitHandler.invoke(proxy, method, args)
    } as T
}

/**
 * 给 Method 添加的一个扩展属性，判断当前方法是不是 suspend 方法
 */
val Method.isSuspendMethod: Boolean
    get() = genericParameterTypes.lastOrNull()
        ?.let { it as? ParameterizedType }?.rawType == Continuation::class.java

/**
 * 给 Method 添加的扩展方法，获取当前 suspend 方法的返回值类型
 */
fun Method.getSuspendReturnType(): Type? {
    return genericParameterTypes.lastOrNull()
        ?.let { it as? ParameterizedType }?.actualTypeArguments?.firstOrNull()
        ?.let { it as? WildcardType }?.lowerBounds?.firstOrNull()
}

/**
 * Array 的扩展方法，更新指定 index 的值
 */
fun Array<Any?>.updateAt(index: Int, updated: Any?) {
    this[index] = updated
}

/**
 * Continuation 包装类，通过返回一个假的 Success（里面包含异常信息）拦截异常抛出
 */
class FakeSuccessContinuationWrapper<T>(
    private val original: Continuation<T>,
    private val throwableResolver: ThrowableResolver<T>,
) : Continuation<T> {

    override val context: CoroutineContext = original.context

    override fun resumeWith(result: Result<T>) {
        // 判断 result 是否为 success
        result.onSuccess {
            // 如果为 success 直接返回
            original.resumeWith(result)
        }.onFailure {
            // 如果为 failure, 返回一个假的 success, 这样协程判断当前为 success
            // 就不会抛出异常了，这样我们就达到了拦截异常的作用
            val fakeSuccessResult = throwableResolver.resolve(it)
            original.resumeWith(Result.success(fakeSuccessResult))
        }
    }
}