#pragma once

#include <cstdint>

#include <memory>

#include "envoy/common/optref.h"

#include "envoy/http/persistent_quic_info.h"

#include "envoy/server/overload/overload_manager.h"

#include "envoy/upstream/upstream.h"

#include "source/common/http/codec_client.h"

#include "source/common/http/conn_pool_base.h"

#ifdef ENVOY_ENABLE_QUIC

#include "source/common/quic/client_connection_factory_impl.h"

#include "source/common/quic/envoy_quic_network_observer_registry_factory.h"

#include "source/common/quic/envoy_quic_utils.h"

#include "source/common/quic/quic_transport_socket_factory.h"

#include "quiche/quic/core/deterministic_connection_id_generator.h"

#else

#error "http3 conn pool should not be built with QUIC disabled"

#endif

namespace Envoy {

namespace Http {

namespace Http3 {

class ActiveClient : public MultiplexedActiveClientBase {

public:

  ActiveClient(Envoy::Http::HttpConnPoolImplBase& parent,

               Upstream::Host::CreateConnectionData& data);

  // Http::ConnectionCallbacks

  void onMaxStreamsChanged(uint32_t num_streams) override;

    // Each time a quic stream is allocated the quic capacity needs to get

    // decremented. See comments by quiche_capacity_.

  // Overload the default capacity calculations to return the quic capacity

  // (modified by any stream limits in Envoy config)

  // Overridden to return true as long as the client is doing handshake even when it is ready for

  // early data streams.

  // Overridden to include ReadyForEarlyData state.

    // Each time we update the capacity make sure to reflect the update in the

    // connection pool.

    //

    // Due to interplay between the max number of concurrent streams Envoy will

    // allow and the max number of streams per connection this is not as simple

    // as just updating based on the delta between quiche_capacity_ and

    // new_quiche_capacity, so we use the delta between the actual calculated

    // capacity before and after the update.

protected:

private:

  // Unlike HTTP/2 and HTTP/1, rather than having a cap on the number of active

  // streams, QUIC has a fixed number of streams available which is updated via

  // the MAX_STREAMS frame.

  //

  // As such each time we create a new stream for QUIC, the capacity goes down

  // by one, but unlike the other two codecs it is _not_ restored on stream

  // closure.

  //

  // We track the QUIC capacity here, and overload currentUnusedCapacity so the

  // connection pool can accurately keep track of when it is safe to create new

  // streams.

  //

  // Though HTTP/3 should arguably start out with 0 stream capacity until the

  // initial handshake is complete and MAX_STREAMS frame has been received,

  // assume optimistically it will get ~100 streams, so that the connection pool

  // won't fetch a connection for each incoming stream but will assume that the

  // first connection will likely be able to serve 100.

  // This number will be updated to the correct value before the connection is

  // deemed connected, at which point further connections will be established if

  // necessary.

  uint64_t quiche_capacity_ = 100;

  // Used to schedule a deferred connect() call. Because HTTP/3 codec client can

  // do 0-RTT during connect(), deferring it to avoid handling network events during CodecClient

  // construction.

  Event::SchedulableCallbackPtr async_connect_callback_;

  // True if newStream() is ever called.

  bool has_created_stream_{false};

};

// An interface to propagate H3 handshake result.

// TODO(danzh) add an API to propagate 0-RTT handshake failure.

class PoolConnectResultCallback {

public:

  // Called when the mandatory handshake is complete. This is when a HTTP/3 connection is regarded

  // as connected and is able to send requests.

  virtual void onHandshakeComplete() PURE;

  // Called upon connection close event from a client who hasn't finish handshake but already sent

  // early data.

  // TODO(danzh) actually call it from h3 pool.

  virtual void onZeroRttHandshakeFailed() PURE;

};

// Http3 subclass of FixedHttpConnPoolImpl which exists to store quic data.

class Http3ConnPoolImpl : public FixedHttpConnPoolImpl {

public:

  Http3ConnPoolImpl(Upstream::HostConstSharedPtr host, Upstream::ResourcePriority priority,

                    Event::Dispatcher& dispatcher,

                    const Network::ConnectionSocket::OptionsSharedPtr& options,

                    const Network::TransportSocketOptionsConstSharedPtr& transport_socket_options,

                    Random::RandomGenerator& random_generator,

                    Upstream::ClusterConnectivityState& state, CreateClientFn client_fn,

                    CreateCodecFn codec_fn, std::vector<Http::Protocol> protocol,

                    OptRef<PoolConnectResultCallback> connect_callback,

                    Http::PersistentQuicInfo& quic_info,

                    OptRef<Quic::EnvoyQuicNetworkObserverRegistry> network_observer_registry,

                    Server::OverloadManager& overload_manager, bool attempt_happy_eyeballs = false);

  ~Http3ConnPoolImpl() override;

  ConnectionPool::Cancellable* newStream(Http::ResponseDecoder& response_decoder,

                                         ConnectionPool::Callbacks& callbacks,

                                         const Instance::StreamOptions& options) override;

      // If connection migration is enabled, don't drain existing connections.

      // Each connection will observe network change signals and decide whether

      // to migrate or drain.

  // For HTTP/3 the base connection pool does not track stream capacity, rather

  // the HTTP3 active client does.

  std::unique_ptr<Network::ClientConnection>

  createClientConnection(Quic::QuicStatNames& quic_stat_names,

                         OptRef<Http::HttpServerPropertiesCache> rtt_cache, Stats::Scope& scope);

protected:

  void onConnected(Envoy::ConnectionPool::ActiveClient&) override;

  void onConnectFailed(Envoy::ConnectionPool::ActiveClient&) override;

private:

  friend class Http3ConnPoolImplPeer;

  // Latches Quic helpers shared across the cluster

  Quic::PersistentQuicInfoImpl& quic_info_;

  // server-id can change over the lifetime of Envoy but will be consistent for a

  // given connection pool.

  quic::QuicServerId server_id_;

  // If not nullopt, called when the handshake state changes.

  OptRef<PoolConnectResultCallback> connect_callback_;

  quic::DeterministicConnectionIdGenerator connection_id_generator_{

      quic::kQuicDefaultConnectionIdLength};

  // Make a best effort attempt to find an address family other than the initial

  // address. This fails over to using the primary address if the second address

  // in the list isn't of a different address family.

  bool attempt_happy_eyeballs_;

  OptRef<Quic::EnvoyQuicNetworkObserverRegistry> network_observer_registry_;

};

std::unique_ptr<Http3ConnPoolImpl>

allocateConnPool(Event::Dispatcher& dispatcher, Random::RandomGenerator& random_generator,

                 Upstream::HostConstSharedPtr host, Upstream::ResourcePriority priority,

                 const Network::ConnectionSocket::OptionsSharedPtr& options,

                 const Network::TransportSocketOptionsConstSharedPtr& transport_socket_options,

                 Upstream::ClusterConnectivityState& state, Quic::QuicStatNames& quic_stat_names,

                 OptRef<Http::HttpServerPropertiesCache> rtt_cache, Stats::Scope& scope,

                 OptRef<PoolConnectResultCallback> connect_callback,

                 Http::PersistentQuicInfo& quic_info,

                 OptRef<Quic::EnvoyQuicNetworkObserverRegistry> network_observer_registry,

                 Server::OverloadManager& overload_manager, bool attempt_happy_eyeballs = false);

} // namespace Http3

} // namespace Http

} // namespace Envoy