class Exchange(
  internal val call: RealCall,
  internal val finder: ExchangeFinder,
  private val codec: ExchangeCodec,
) {
  /** True if the request body need not complete before the response body starts. */
  internal var isDuplex: Boolean = false
    private set

  /** True if there was an exception on the connection to the peer. */
  internal var hasFailure: Boolean = false
    private set

  internal val connection: RealConnection

  override val isResponseComplete: Boolean
    get() = state == STATE_CLOSED

  override fun createRequestBody(
    request: Request,
    contentLength: Long,
  ): Sink =
    when {
      request.body?.isDuplex() == true -> {
        throw ProtocolException(
          "Duplex connections are not supported for HTTP/1",
        )
      }

      request.isChunked -> {
        newChunkedSink()
      }

    delay: Long,
    timeUnit: TimeUnit,
  ) : RequestBody() {
    private val delayMillis = timeUnit.toMillis(delay)

    override fun contentType() = delegate.contentType()

    override fun isDuplex() = true

    override fun writeTo(sink: BufferedSink) {
      executorService.schedule({
        try {
          delegate.writeTo(sink)
          sink.close()
        } catch (e: IOException) {

        override fun contentType(): MediaType? = null

        override fun writeTo(sink: BufferedSink) {
          sink.writeUtf8("Hello request!")
          sink.close()
        }

        override fun isDuplex(): Boolean = true
      }
    val request =
      request()
        .post(asyncRequestBody)
        .build()
    val response = client.newCall(request).execute()

          logger.log("--> END ${request.method}")
        } else if (bodyHasUnknownEncoding(request.headers)) {
          logger.log("--> END ${request.method} (encoded body omitted)")
        } else if (requestBody.isDuplex()) {
          logger.log("--> END ${request.method} (duplex request body omitted)")
        } else if (requestBody.isOneShot()) {
          logger.log("--> END ${request.method} (one-shot body omitted)")
        } else {

            .build()

        val exchange = call.interceptorScopedExchange
        val followUp = followUpRequest(response, exchange, chain)

        if (followUp == null) {
          if (exchange != null && exchange.isDuplex) {
            call.timeoutEarlyExit()
          }
          closeActiveExchange = false
          call.eventListener.followUpDecision(call, response, null)
          return response
        }

 *
 * This nesting is typical but not strict. For example, when calls use "Expect: continue" the
 * request body start and end events occur within the response header events. Similarly,
 * [duplex calls][RequestBody.isDuplex] interleave the request and response bodies.
 *
 * Since connections may be reused, the proxy selection, DNS, and connect events may not be present