#pragma once

#include <cstdint>

#include <memory>

#include "envoy/buffer/buffer.h"

#include "envoy/config/core/v3/protocol.pb.h"

#include "envoy/event/dispatcher.h"

#include "envoy/http/codec.h"

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

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

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

#ifdef ENVOY_ENABLE_HTTP_DATAGRAMS

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

#endif

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

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

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

#include "quiche/http2/adapter/header_validator.h"

#include "quiche/quic/core/http/quic_spdy_stream.h"

namespace Envoy {

namespace Quic {

// Base class for EnvoyQuicServer|ClientStream.

class EnvoyQuicStream : public virtual Http::StreamEncoder,

                        public Http::MultiplexedStreamImplBase,

                        public SendBufferMonitor,

                        public HeaderValidator,

                        protected Logger::Loggable<Logger::Id::quic_stream> {

public:

  // |buffer_limit| is the high watermark of the stream send buffer, and the low

  // watermark will be half of it.

  EnvoyQuicStream(quic::QuicSpdyStream& quic_stream, quic::QuicSession& quic_session,

                  uint32_t buffer_limit, QuicFilterManagerConnectionImpl& filter_manager_connection,

                  std::function<void()> below_low_watermark,

                  std::function<void()> above_high_watermark, Http::Http3::CodecStats& stats,

                  const envoy::config::core::v3::Http3ProtocolOptions& http3_options)

        async_stream_blockage_change_(

  // Http::StreamEncoder

  void encodeData(Buffer::Instance& data, bool end_stream) override;

  void encodeMetadata(const Http::MetadataMapVector& metadata_map_vector) override;

  // Http::Stream

    // If the status transiently changed from unblocked to blocked and then unblocked, the quic

    // stream will be spuriously unblocked and call OnDataAvailable(). This call shouldn't take any

    // effect because any available data should have been processed already upon arrival or they

    // were blocked by some condition other than flow control, i.e. Qpack decoding.

  // SendBufferMonitor

    // If buffered bytes changed, update stream and session's watermark book

    // keeping.

    // This value can momentarily be inconsistent with new_buffered_bytes when

    // the buffer goes below low watermark and triggers a write in the

    // onBelowWriteBufferLowWatermark() callstack. In this case, any buffered data from the nested

    // write will increase reported_buffered_bytes_ and the connection level bookkeeping before the

    // reduction of the value in the nesting call to be reported.

  Http::HeaderUtility::HeaderValidationResult

      // If any regular header appears before pseudo headers, the request or response is malformed.

protected:

  virtual void switchStreamBlockState() PURE;

  // Needed for ENVOY_STREAM_LOG.

  virtual uint32_t streamId() PURE;

  virtual Network::Connection* connection() PURE;

  // Either reset the stream or close the connection according to

  // should_close_connection and configured http3 options.

  virtual void

  onStreamError(absl::optional<bool> should_close_connection,

                quic::QuicRstStreamErrorCode rst = quic::QUIC_BAD_APPLICATION_PAYLOAD) PURE;

  // TODO(danzh) remove this once QUICHE enforces content-length consistency.

      // Reset instead of closing the connection to align with nghttp2.

  void encodeTrailersImpl(quiche::HttpHeaderBlock&& trailers);

  // Converts `header_list` into a new `Http::MetadataMap`.

  std::unique_ptr<Http::MetadataMap>

  metadataMapFromHeaderList(const quic::QuicHeaderList& header_list);

  // Returns true if the cumulative limit on METADATA headers has been reached

  // after adding `bytes`.

  std::string quicStreamState();

#ifdef ENVOY_ENABLE_HTTP_DATAGRAMS

  // Setting |http_datagram_handler_| enables HTTP Datagram support.

  std::unique_ptr<HttpDatagramHandler> http_datagram_handler_;

#endif

  quiche::QuicheReferenceCountedPointer<QuicStatsGatherer> stats_gatherer_;

  // True once end of stream is propagated to Envoy. Envoy doesn't expect to be

  // notified more than once about end of stream. So once this is true, no need

  // to set it in the callback to Envoy stream any more.

  bool end_stream_decoded_{false};

  // The latest state a QUIC stream blockage state change callback should look at. As

  // more readDisable() calls may happen between the callback is posted and it's

  // executed, the stream might be unblocked and blocked several times. If this

  // counter is 0, the callback should unblock the stream. Otherwise it should

  // block the stream.

  uint32_t read_disable_counter_{0u};

  Http::Http3::CodecStats& stats_;

  const envoy::config::core::v3::Http3ProtocolOptions& http3_options_;

  bool close_connection_upon_invalid_header_{false};

  absl::string_view details_;

  // TODO(kbaichoo): bind the account to the QUIC buffers to enable tracking of

  // memory allocated within QUIC buffers.

  Buffer::BufferMemoryAccountSharedPtr buffer_memory_account_ = nullptr;

  bool got_304_response_{false};

  bool sent_head_request_{false};

  // True if a regular (non-pseudo) HTTP header has been seen before.

  bool saw_regular_headers_{false};

private:

  // QUIC stream and session that this EnvoyQuicStream wraps.

  quic::QuicSpdyStream& quic_stream_;

  quic::QuicSession& quic_session_;

  // Keeps track of bytes buffered in the stream send buffer in QUICHE and reacts

  // upon crossing high and low watermarks.

  // Its high watermark is also the buffer limit of stream read/write filters in

  // HCM.

  // There is no receive buffer simulation because Quic stream's

  // OnBodyDataAvailable() hands all the ready-to-use request data from stream sequencer to HCM

  // directly and buffers them in filters if needed. Itself doesn't buffer request data.

  EnvoyQuicSimulatedWatermarkBuffer send_buffer_simulation_;

  QuicFilterManagerConnectionImpl& filter_manager_connection_;

  // Used to block or unblock stream in the next event loop. QUICHE doesn't like stream blockage

  // state change in its own call stack. And Envoy upstream doesn't like quic stream to be unblocked

  // in its callstack either because the stream will push data right away.

  Event::SchedulableCallbackPtr async_stream_blockage_change_;

  StreamInfo::BytesMeterSharedPtr bytes_meter_{std::make_shared<StreamInfo::BytesMeter>()};

  absl::optional<size_t> content_length_;

  size_t received_content_bytes_{0};

  http2::adapter::HeaderValidator header_validator_;

  size_t received_metadata_bytes_{0};

  // Track the buffered bytes reported to connection in the

  // most recent call of updateBytesBuffered().

  uint64_t reported_buffered_bytes_{0u};

};

// Object used for updating a BytesMeter to track bytes sent on a QuicStream since this object was

// constructed.

class IncrementalBytesSentTracker {

public:

  IncrementalBytesSentTracker(const quic::QuicStream& stream, StreamInfo::BytesMeter& bytes_meter,

                              bool update_header_bytes)

private:

  // Returns the number of newly sent bytes since the tracker was constructed.

  // Returns total number of stream bytes written, including buffered bytes.

  const quic::QuicStream& stream_;

  StreamInfo::BytesMeter& bytes_meter_;

  bool update_header_bytes_;

  uint64_t initial_bytes_sent_;

};

} // namespace Quic

} // namespace Envoy