#pragma once

#include "envoy/common/pure.h"

#include "envoy/config/tap/v3/common.pb.h"

#include "envoy/data/tap/v3/wrapper.pb.h"

#include "envoy/extensions/filters/http/tap/v3/tap.pb.h"

#include "envoy/http/header_map.h"

#include "source/extensions/common/matcher/matcher.h"

#include "absl/strings/string_view.h"

namespace Envoy {

namespace Extensions {

namespace Common {

namespace Tap {

using Matcher = Envoy::Extensions::Common::Matcher::Matcher;

using TraceWrapperPtr = std::unique_ptr<envoy::data::tap::v3::TraceWrapper>;

/**

 * A handle for a per-tap sink. This allows submitting either a single buffered trace, or a series

 * of trace segments that the sink can aggregate in whatever way it chooses.

 */

class PerTapSinkHandle {

public:

  /**

   * Send a trace wrapper to the sink. This may be a fully buffered trace or a segment of a larger

   * trace depending on the contents of the wrapper.

   * @param trace supplies the trace to send.

   * @param format supplies the output format to use.

   */

  virtual void submitTrace(TraceWrapperPtr&& trace,

                           envoy::config::tap::v3::OutputSink::Format format) PURE;

};

using PerTapSinkHandlePtr = std::unique_ptr<PerTapSinkHandle>;

/**

 * Wraps potentially multiple PerTapSinkHandle instances and any common pre-submit functionality.

 * Each active tap will have a reference to one of these, which in turn may have references to

 * one or more PerTapSinkHandle.

 */

class PerTapSinkHandleManager {

public:

  /**

   * Submit a buffered or streamed trace segment to all managed per-tap sink handles.

   */

  virtual void submitTrace(TraceWrapperPtr&& trace) PURE;

};

using PerTapSinkHandleManagerPtr = std::unique_ptr<PerTapSinkHandleManager>;

/**

 * Sink for sending tap messages.

 */

class Sink {

public:

  /**

   * Create a per tap sink handle for use in submitting either buffered traces or trace segments.

   * @param trace_id supplies a locally unique trace ID. Some sinks use this for output generation.

   * @param type     Indicates the type of Sink specified in request body

   */

  virtual PerTapSinkHandlePtr

  createPerTapSinkHandle(uint64_t trace_id,

                         envoy::config::tap::v3::OutputSink::OutputSinkTypeCase type) PURE;

};

using SinkPtr = std::unique_ptr<Sink>;

/**

 * Abstract tap sink factory. Produces a factory that can instantiate SinkPtr objects

 */

class TapSinkFactory : public Config::TypedFactory {

public:

  /**

   * Create a Sink that can be used for writing out data produced by the tap filter.

   * @param config supplies the protobuf configuration for the sink factory

   * @param  http_context supplies HTTP context

   */

  virtual SinkPtr createSinkPtr(const Protobuf::Message& config,

                                Server::Configuration::GenericFactoryContext& http_context) PURE;

};

using TapSinkFactoryPtr = std::unique_ptr<TapSinkFactory>;

/**

 * Generic configuration for a tap extension (filter, transport socket, etc.).

 */

class ExtensionConfig {

public:

  /**

   * @return the ID to use for admin extension configuration tracking (if applicable).

   */

  virtual const absl::string_view adminId() PURE;

  /**

   * Clear any active tap configuration.

   */

  virtual void clearTapConfig() PURE;

  /**

   * Install a new tap configuration.

   * @param proto_config supplies the generic tap config to install. Not all configuration fields

   *        may be applicable to an extension (e.g. HTTP fields). The extension is free to fail

   *        the configuration load via exception if it wishes.

   * @param admin_streamer supplies the singleton admin sink to use for output if the configuration

   *        specifies that output type. May not be used if the configuration does not specify

   *        admin output. May be nullptr if admin is not used to supply the config.

   */

  virtual void newTapConfig(const envoy::config::tap::v3::TapConfig& proto_config,

                            Sink* admin_streamer) PURE;

};

/**

 * Abstract tap configuration base class.

 */

class TapConfig {

public:

  /**

   * Return a per-tap sink handle manager for use by a tap session.

   * @param trace_id supplies a locally unique trace ID. Some sinks use this for output generation.

   */

  virtual PerTapSinkHandleManagerPtr createPerTapSinkHandleManager(uint64_t trace_id) PURE;

  /**

   * Return the maximum received bytes that can be buffered in memory. Streaming taps are still

   * subject to this limit depending on match status.

   */

  virtual uint32_t maxBufferedRxBytes() const PURE;

  /**

   * Return the maximum transmitted bytes that can be buffered in memory. Streaming taps are still

   * subject to this limit depending on match status.

   */

  virtual uint32_t maxBufferedTxBytes() const PURE;

  /**

   * Return the minimum transmitted bytes that can be buffered in memory. Streaming taps are still

   * subject to this limit depending on match status.

   */

  virtual uint32_t minStreamedSentBytes() const PURE;

  /**

   * Return a new match status vector that is correctly sized for the number of matchers that are in

   * the configuration.

   */

  virtual Matcher::MatchStatusVector createMatchStatusVector() const PURE;

  /**

   * Return the root matcher for use in updating a match status vector.

   */

  virtual const Matcher& rootMatcher() const PURE;

  /**

   * Non-const version of rootMatcher method.

   */

  /**

   * Return whether the tap session should run in streaming or buffering mode.

   */

  virtual bool streaming() const PURE;

};

using TapConfigSharedPtr = std::shared_ptr<TapConfig>;

/**

 * Abstract tap configuration factory. Given a new generic tap configuration, produces an

 * extension specific tap configuration.

 */

class TapConfigFactory {

public:

  /**

   * @return a new configuration given a raw tap service config proto. See

   * ExtensionConfig::newTapConfig() for param info.

   */

  virtual TapConfigSharedPtr

  createConfigFromProto(const envoy::config::tap::v3::TapConfig& proto_config,

                        Sink* admin_streamer) PURE;

};

using TapConfigFactoryPtr = std::unique_ptr<TapConfigFactory>;

} // namespace Tap

} // namespace Common

} // namespace Extensions

} // namespace Envoy