: type_(type), host_(host), connection_(std::move(connection)),

      idle_timeout_(host_->cluster().idleTimeout()),

      enable_idle_timer_only_when_connected_(Runtime::runtimeFeatureEnabled(

          "envoy.reloadable_features.codec_client_enable_idle_timer_only_when_connected")) {

  if (type_ != CodecType::HTTP3) {

    connection_->detectEarlyCloseWhenReadDisabled(false);

  }

  connection_->addConnectionCallbacks(*this);

  connection_->addReadFilter(Network::ReadFilterSharedPtr{new CodecReadFilter(*this)});

  if (idle_timeout_) {

    idle_timer_ = dispatcher.createTimer([this]() -> void { onIdleTimeout(); });

    if (!enable_idle_timer_only_when_connected_) {

      enableIdleTimer();

    }

  }

  connection_->noDelay(true);

}

void CodecClient::connect() {

  ASSERT(!connect_called_);

  connect_called_ = true;

  ASSERT(codec_ != nullptr);

  if (!connection_->connecting()) {

    ASSERT(connection_->state() == Network::Connection::State::Open);

    connected_ = true;

    enableIdleTimer();

  } else {

    ENVOY_CONN_LOG(debug, "connecting", *connection_);

    connection_->connect();

  }

}

void CodecClient::close(Network::ConnectionCloseType type, absl::string_view details) {

  connection_->close(type, details);

}

void CodecClient::deleteRequest(ActiveRequest& request) {

  connection_->dispatcher().deferredDelete(request.removeFromList(active_requests_));

  if (codec_client_callbacks_) {

    codec_client_callbacks_->onStreamDestroy();

  }

  if (numActiveRequests() == 0) {

    enableIdleTimer();

  }

}

RequestEncoder& CodecClient::newStream(ResponseDecoderHandlePtr response_decoder_handle) {

  return enlistAndCreateEncoder(

      std::make_unique<ActiveRequest>(*this, std::move(response_decoder_handle)));

}

RequestEncoder& CodecClient::newStream(ResponseDecoder& response_decoder) {

  return enlistAndCreateEncoder(std::make_unique<ActiveRequest>(*this, response_decoder));

}

RequestEncoder& CodecClient::enlistAndCreateEncoder(ActiveRequestPtr request) {

  request->setEncoder(codec_->newStream(*request));

  LinkedList::moveIntoList(std::move(request), active_requests_);

  auto upstream_info = connection_->streamInfo().upstreamInfo();

  upstream_info->setUpstreamNumStreams(upstream_info->upstreamNumStreams() + 1);

  disableIdleTimer();

  return *active_requests_.front();

}

void CodecClient::onEvent(Network::ConnectionEvent event) {

  if (event == Network::ConnectionEvent::Connected) {

    ENVOY_CONN_LOG(debug, "connected", *connection_);

    connected_ = true;

    enableIdleTimer();

    return;

  }

  if (event == Network::ConnectionEvent::RemoteClose) {

    remote_closed_ = true;

  }

  if (type_ == CodecType::HTTP1 && event == Network::ConnectionEvent::RemoteClose &&

      !active_requests_.empty()) {

    Buffer::OwnedImpl empty;

    onData(empty);

  }

  if (event == Network::ConnectionEvent::RemoteClose ||

      event == Network::ConnectionEvent::LocalClose) {

    ENVOY_CONN_LOG(debug, "disconnect. resetting {} pending requests", *connection_,

                   active_requests_.size());

    disableIdleTimer();

    idle_timer_.reset();

    StreamResetReason reason = event == Network::ConnectionEvent::RemoteClose

                                   ? StreamResetReason::RemoteConnectionFailure

                                   : StreamResetReason::LocalConnectionFailure;

    if (connected_) {

      reason = StreamResetReason::ConnectionTermination;

      if (protocol_error_) {

        reason = StreamResetReason::ProtocolError;

        connection_->streamInfo().setResponseFlag(

            StreamInfo::CoreResponseFlag::UpstreamProtocolError);

      }

    }

    while (!active_requests_.empty()) {

      active_requests_.front()->getStream().resetStream(reason);

    }

  }

}

void CodecClient::responsePreDecodeComplete(ActiveRequest& request) {

  ENVOY_CONN_LOG(debug, "response complete", *connection_);

  if (codec_client_callbacks_) {

    codec_client_callbacks_->onStreamPreDecodeComplete();

  }

  request.decode_complete_ = true;

  if (request.encode_complete_ || !request.wait_encode_complete_) {

    completeRequest(request);

  } else {

    ENVOY_CONN_LOG(debug, "waiting for encode to complete", *connection_);

  }

}

void CodecClient::requestEncodeComplete(ActiveRequest& request) {

  ENVOY_CONN_LOG(debug, "encode complete", *connection_);

  request.encode_complete_ = true;

  if (request.decode_complete_) {

    completeRequest(request);

  }

}

void CodecClient::completeRequest(ActiveRequest& request) {

  deleteRequest(request);

  request.removeEncoderCallbacks();

}

void CodecClient::onReset(ActiveRequest& request, StreamResetReason reason) {

  ENVOY_CONN_LOG(debug, "Request reset. Reason {}", *connection_, static_cast<int>(reason));

  if (codec_client_callbacks_) {

    codec_client_callbacks_->onStreamReset(reason);

  }

  deleteRequest(request);

}

void CodecClient::onData(Buffer::Instance& data) {

  const Status status = codec_->dispatch(data);

  if (!status.ok()) {

    ENVOY_CONN_LOG(debug, "Error dispatching received data: {}", *connection_, status.message());

    const bool not_408 =

        !isPrematureResponseError(status) ||

        (!active_requests_.empty() || getPrematureResponseHttpCode(status) != Code::RequestTimeout);

    const bool is_goaway = isGoAwayGracefulCloseError(status);

    if (not_408 && !is_goaway) {

      host_->cluster().trafficStats()->upstream_cx_protocol_error_.inc();

      protocol_error_ = true;

    }

    close();

  }

  ASSERT(data.length() == 0 || connection_->state() != Network::Connection::State::Open,

         absl::StrCat("extraneous bytes after response complete: ", data.length()));

}

Status CodecClient::ActiveRequest::encodeHeaders(const RequestHeaderMap& headers, bool end_stream) {

  return RequestEncoderWrapper::encodeHeaders(headers, end_stream);

}

void CodecClient::ActiveRequest::decodeHeaders(ResponseHeaderMapPtr&& headers, bool end_stream) {

  ResponseDecoderWrapper::decodeHeaders(std::move(headers), end_stream);

}

    : CodecClient(type, std::move(connection), host, dispatcher) {

  switch (type) {

  case CodecType::HTTP1: {

    bool proxied = false;

    if (options && options->http11ProxyInfo().has_value()) {

      proxied = true;

    }

    codec_ = std::make_unique<Http1::ClientConnectionImpl>(

        *connection_, host->cluster().http1CodecStats(), *this,

        host->cluster().httpProtocolOptions().http1Settings(),

        host->cluster().maxResponseHeadersKb(), host->cluster().maxResponseHeadersCount(), proxied);

    break;

  case CodecType::HTTP2:

    codec_ = std::make_unique<Http2::ClientConnectionImpl>(

        *connection_, *this, host->cluster().http2CodecStats(), random_generator,

        host->cluster().httpProtocolOptions().http2Options(),

        host->cluster().maxResponseHeadersKb().value_or(Http::DEFAULT_MAX_REQUEST_HEADERS_KB),

        host->cluster().maxResponseHeadersCount(), Http2::ProdNghttp2SessionFactory::get());

    break;

  case CodecType::HTTP3: {

#ifdef ENVOY_ENABLE_QUIC

    auto& quic_session = dynamic_cast<Quic::EnvoyQuicClientSession&>(*connection_);

    codec_ = std::make_unique<Quic::QuicHttpClientConnectionImpl>(

        quic_session, *this, host->cluster().http3CodecStats(),

        host->cluster().httpProtocolOptions().http3Options(),

        host->cluster().maxResponseHeadersKb().value_or(Http::DEFAULT_MAX_REQUEST_HEADERS_KB),

        host->cluster().maxResponseHeadersCount());

    quic_session.Initialize();

    break;

  }

  if (should_connect) {

    connect();

  }

}