#pragma once

#include <cstdint>

#include <list>

#include <memory>

#include "envoy/common/random_generator.h"

#include "envoy/event/deferred_deletable.h"

#include "envoy/event/timer.h"

#include "envoy/http/codec.h"

#include "envoy/http/header_validator.h"

#include "envoy/network/connection.h"

#include "envoy/network/filter.h"

#include "envoy/upstream/upstream.h"

#include "source/common/common/assert.h"

#include "source/common/common/linked_object.h"

#include "source/common/common/logger.h"

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

#include "source/common/network/filter_impl.h"

namespace Envoy {

namespace Http {

/**

 * Callbacks specific to a codec client.

 */

class CodecClientCallbacks {

public:

  // Called in onPreDecodeComplete

  /**

   * Called every time an owned stream is destroyed, whether complete or not.

   */

  virtual void onStreamDestroy() PURE;

  /**

   * Called when a stream is reset by the client.

   * @param reason supplies the reset reason.

   */

  virtual void onStreamReset(StreamResetReason reason) PURE;

};

/**

 * This is an HTTP client that multiple stream management and underlying connection management

 * across multiple HTTP codec types.

 */

class CodecClient : protected Logger::Loggable<Logger::Id::client>,

                    public Http::ConnectionCallbacks,

                    public Network::ConnectionCallbacks,

                    public Event::DeferredDeletable {

public:

  /**

   * Type of HTTP codec to use.

   */

  // This is a legacy alias.

  using Type = Envoy::Http::CodecType;

  /**

   * Add a connection callback to the underlying network connection.

   */

  /**

   * Return if half-close semantics are enabled on the underlying connection.

   */

  /**

   * Initialize all of the installed read filters on the underlying connection.

   * This effectively calls onNewConnection() on each of them.

   */

  /**

   * Close the underlying network connection. This is immediate and will not attempt to flush any

   * pending write data.

   */

  void close(Network::ConnectionCloseType type = Network::ConnectionCloseType::NoFlush,

             absl::string_view details = "");

  /**

   * Send a codec level go away indication to the peer.

   */

  /**

   * @return the underlying connection ID.

   */

  /**

   * @return the underlying codec protocol.

   */

  /**

   * @return the underlying connection error.

   */

  /**

   * @return size_t the number of outstanding requests that have not completed or been reset.

   */

  /**

   * Create a new stream. Note: The CodecClient will NOT buffer multiple requests for HTTP1

   * connections. Thus, calling newStream() before the previous request has been fully encoded

   * is an error. Pipelining is supported however.

   * @param response_decoder supplies the decoder to use for response callbacks.

   * @return StreamEncoder& the encoder to use for encoding the request.

   */

  RequestEncoder& newStream(ResponseDecoder& response_decoder);

  /**

   * Create a new stream. Note: The CodecClient will NOT buffer multiple requests for HTTP1

   * connections. Thus, calling newStream() before the previous request has been fully encoded

   * is an error. Pipelining is supported however.

   * @param response_decoder_handle supplies the decoder to use for response callbacks if it's still

   * alive.

   * @return StreamEncoder& the encoder to use for encoding the request.

   */

  RequestEncoder& newStream(ResponseDecoderHandlePtr response_decoder_handle);

  // Note this is the L4 stream info, not L7.

  /**

   * Connect to the host.

   * Needs to be called after codec_ is instantiated.

   */

  void connect();

protected:

  /**

   * Create a codec client and connect to a remote host/port.

   * @param type supplies the codec type.

   * @param connection supplies the connection to communicate on.

   * @param host supplies the owning host.

   */

  CodecClient(CodecType type, Network::ClientConnectionPtr&& connection,

              Upstream::HostDescriptionConstSharedPtr host, Event::Dispatcher& dispatcher);

  // Http::ConnectionCallbacks

    // Bug fix (default): only enable idle timer when connection is established.

    // Old behavior (when flag is disabled): enable idle timer even when connection is not yet

    // established.

  const CodecType type_;

  // The order of host_, connection_, and codec_ matter as during destruction each can refer to

  // the previous, at least in tests.

  Upstream::HostDescriptionConstSharedPtr host_;

  Network::ClientConnectionPtr connection_;

  ClientConnectionPtr codec_;

  Event::TimerPtr idle_timer_;

  const absl::optional<std::chrono::milliseconds> idle_timeout_;

  const bool enable_idle_timer_only_when_connected_;

private:

  /**

   * Wrapper read filter to drive incoming connection data into the codec. We could potentially

   * support other filters in the future.

   */

  struct CodecReadFilter : public Network::ReadFilterBaseImpl {

    // Network::ReadFilter

        // Note that this results in the connection closed as if it was closed

        // locally, it would be more correct to convey the end stream to the

        // response decoder, but it would require some refactoring.

    CodecClient& parent_;

  };

  struct ActiveRequest;

  /**

   * Wrapper for an outstanding request. Designed for handling stream multiplexing.

   */

  struct ActiveRequest : LinkedObject<ActiveRequest>,

                         public Event::DeferredDeletable,

                         public StreamCallbacks,

                         public ResponseDecoderWrapper,

                         public RequestEncoderWrapper {

    ActiveRequest(CodecClient& parent, ResponseDecoder& inner)

          header_validator_(

        // HTTP/1.1 codec does not support half-close on the response completion.

    ActiveRequest(CodecClient& parent, ResponseDecoderHandlePtr inner_handle)

        // HTTP/1.1 codec does not support half-close on the response completion.

    void decodeHeaders(ResponseHeaderMapPtr&& headers, bool end_stream) override;

    // StreamCallbacks

    // StreamDecoderWrapper

    // RequestEncoderWrapper

    // RequestEncoder

    Status encodeHeaders(const RequestHeaderMap& headers, bool end_stream) override;

    CodecClient& parent_;

    Http::ClientHeaderValidatorPtr header_validator_;

    bool wait_encode_complete_{true};

    bool encode_complete_{false};

    bool decode_complete_{false};

  };

  using ActiveRequestPtr = std::unique_ptr<ActiveRequest>;

  /**

   * Called when a response finishes decoding. This is called *before* forwarding on to the

   * wrapped decoder.

   */

  void responsePreDecodeComplete(ActiveRequest& request);

  void requestEncodeComplete(ActiveRequest& request);

  void completeRequest(ActiveRequest& request);

  void deleteRequest(ActiveRequest& request);

  void onReset(ActiveRequest& request, StreamResetReason reason);

  void onData(Buffer::Instance& data);

  // Network::ConnectionCallbacks

  void onEvent(Network::ConnectionEvent event) override;

  // Pass watermark events from the connection on to the codec which will pass it to the underlying

  // streams.

  RequestEncoder& enlistAndCreateEncoder(ActiveRequestPtr request);

  std::list<ActiveRequestPtr> active_requests_;

  Http::ConnectionCallbacks* codec_callbacks_{};

  CodecClientCallbacks* codec_client_callbacks_{};

  bool connected_{};

  bool remote_closed_{};

  bool protocol_error_{false};

  bool connect_called_{false};

};

using CodecClientPtr = std::unique_ptr<CodecClient>;

/**

 * Production implementation that installs a real codec.

 */

class CodecClientProd : public CodecClient {

public:

  CodecClientProd(CodecType type, Network::ClientConnectionPtr&& connection,

                  Upstream::HostDescriptionConstSharedPtr host, Event::Dispatcher& dispatcher,

                  Random::RandomGenerator& random_generator,

                  const Network::TransportSocketOptionsConstSharedPtr& options,

                  bool should_connect_on_creation = true);

};

} // namespace Http

} // namespace Envoy