#pragma once

#include "envoy/api/api.h"

#include "envoy/common/random_generator.h"

#include "envoy/config/bootstrap/v3/bootstrap.pb.h"

#include "envoy/config/cluster/v3/cluster.pb.h"

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

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

#include "envoy/config/endpoint/v3/endpoint.pb.h"

#include "envoy/config/grpc_mux.h"

#include "envoy/config/subscription.h"

#include "envoy/local_info/local_info.h"

#include "envoy/registry/registry.h"

#include "envoy/server/filter_config.h"

#include "envoy/upstream/cluster_manager.h"

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

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

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

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

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

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

#include "source/common/protobuf/utility.h"

#include "source/common/runtime/runtime_features.h"

#include "source/common/singleton/const_singleton.h"

#include "source/common/version/api_version.h"

#include "source/common/version/api_version_struct.h"

#include "absl/types/optional.h"

#include "udpa/type/v1/typed_struct.pb.h"

#include "xds/type/v3/typed_struct.pb.h"

namespace Envoy {

namespace Config {

constexpr absl::string_view Wildcard = "*";

/**

 * Constant Api Type Values, used by envoy::config::core::v3::ApiConfigSource.

 */

class ApiTypeValues {

public:

  const std::string UnsupportedRestLegacy{"REST_LEGACY"};

  const std::string Rest{"REST"};

  const std::string Grpc{"GRPC"};

};

/**

 * RateLimitSettings for discovery requests.

 */

struct RateLimitSettings {

  // Default Max Tokens.

  static const uint32_t DefaultMaxTokens = 100;

  // Default Fill Rate.

  static constexpr double DefaultFillRate = 10;

  uint32_t max_tokens_{DefaultMaxTokens};

  double fill_rate_{DefaultFillRate};

  bool enabled_{false};

};

using ApiType = ConstSingleton<ApiTypeValues>;

/**

 * General config API utilities.

 */

class Utility {

public:

  /**

   * Legacy APIs uses JSON and do not have an explicit version.

   * @param input the input to hash.

   * @return std::pair<std::string, uint64_t> the string is the hash converted into

   *         a hex string, pre-pended by a user friendly prefix. The uint64_t is the

   *         raw hash.

   */

  /**

   * Extract initial_fetch_timeout as a std::chrono::milliseconds from

   * envoy::config::core::v3::ApiConfigSource. If request_timeout isn't set in the config source, a

   * default value of 15s will be returned.

   */

  static std::chrono::milliseconds

  configSourceInitialFetchTimeout(const envoy::config::core::v3::ConfigSource& config_source);

  /**

   * Check cluster info for API config sanity.

   * @param error_prefix supplies the prefix to use in error messages.

   * @param cluster_name supplies the cluster name to check.

   * @param cm supplies the cluster manager.

   * @param allow_added_via_api indicates whether a cluster is allowed to be added via api

   *                            rather than be a static resource from the bootstrap config.

   * @return the main thread cluster if it exists, or an error status if problematic.

   */

  static absl::StatusOr<Upstream::ClusterConstOptRef>

  checkCluster(absl::string_view error_prefix, absl::string_view cluster_name,

               Upstream::ClusterManager& cm, bool allow_added_via_api = false);

  /**

   * Check local info for API config sanity.

   * @param error_prefix supplies the prefix to use in error messages.

   * @param local_info supplies the local info.

   * @return a status indicating if the config is sane.

   */

  static absl::Status checkLocalInfo(absl::string_view error_prefix,

                                     const LocalInfo::LocalInfo& local_info);

  /**

   * Check the existence of a path for a filesystem subscription.

   * @param path the path to validate.

   * @param api reference to the Api object

   * @return a status indicating if the path exists.

   */

  static absl::Status checkFilesystemSubscriptionBackingPath(const std::string& path,

                                                             Api::Api& api);

  /**

   * Check the validity of a cluster backing an api config source. Throws on error.

   * @param primary_clusters the API config source eligible clusters.

   * @param cluster_name the cluster name to validate.

   * @param config_source the config source typed name.

   * @returns failure when an API config doesn't have a statically defined non-EDS cluster.

   */

  static absl::Status

  validateClusterName(const Upstream::ClusterManager::ClusterSet& primary_clusters,

                      absl::string_view cluster_name, absl::string_view config_source);

  /**

   * Potentially calls Utility::validateClusterName, if a cluster name can be found.

   * @param primary_clusters the API config source eligible clusters.

   * @param api_config_source the config source to validate.

   * @return a status indicating if config is valid.

   */

  static absl::Status checkApiConfigSourceSubscriptionBackingCluster(

      const Upstream::ClusterManager::ClusterSet& primary_clusters,

      const envoy::config::core::v3::ApiConfigSource& api_config_source);

  /**

   * Gets the gRPC control plane management server from the API config source. The result is either

   * a cluster name or a host name.

   * @param api_config_source the config source to validate.

   * @return the gRPC control plane server, or absl::nullopt if it couldn't be extracted.

   */

  static absl::optional<std::string>

  getGrpcControlPlane(const envoy::config::core::v3::ApiConfigSource& api_config_source);

  /**

   * Validate transport_api_version field in ApiConfigSource.

   * @param api_config_source the config source to extract transport API version from.

   * @returns a failure status when the transport version is disabled.

   */

  /**

   * Parses RateLimit configuration from envoy::config::core::v3::ApiConfigSource to

   * RateLimitSettings.

   * @param api_config_source ApiConfigSource.

   * @return absl::StatusOr<RateLimitSettings> - returns an error when an

   *         invalid RateLimit config settings are provided.

   */

  static absl::StatusOr<RateLimitSettings>

  parseRateLimitSettings(const envoy::config::core::v3::ApiConfigSource& api_config_source);

  /**

   * Generate a ControlPlaneStats object from stats scope.

   * @param scope for stats.

   * @return ControlPlaneStats for scope.

   */

  /**

   * Generate a SubscriptionStats object from stats scope.

   * @param scope for stats.

   * @return SubscriptionStats for scope.

   */

  /**

   * Get a Factory from the registry with a particular name (and templated type) with error checking

   * to ensure the name and factory are valid.

   * @param name string identifier for the particular implementation.

   * @param is_optional exception will be throw when the value is false and no factory found.

   * @return factory the factory requested or nullptr if it does not exist.

   */

  template <class Factory>

  /**

   * Get a Factory from the registry with a particular name (and templated type) with error checking

   * to ensure the name and factory are valid.

   * @param name string identifier for the particular implementation.

   * @return factory the factory requested or nullptr if it does not exist.

   */

  /**

   * Get a Factory from the registry with a particular name or return nullptr.

   * @param name string identifier for the particular implementation.

   */

  /**

   * Get a Factory from the registry or return nullptr.

   * @param message proto that contains fields 'name' and 'typed_config'.

   */

  template <class Factory, class ProtoMessage>

  /**

   * Get a Factory from the registry with error checking to ensure the name and the factory are

   * valid. And a flag to control return nullptr or throw an exception.

   * @param message proto that contains fields 'name' and 'typed_config'.

   * @param is_optional an exception will be throw when the value is false and no factory found.

   * @return factory the factory requested or nullptr if it does not exist.

   */

  template <class Factory, class ProtoMessage>

  /**

   * Get a Factory from the registry with error checking to ensure the name and the factory are

   * valid.

   * @param message proto that contains fields 'name' and 'typed_config'.

   */

  template <class Factory, class ProtoMessage>

  /**

   * Get type URL from a typed config.

   * @param typed_config for the extension config.

   */

    // Unpack methods will only use the fully qualified type name after the last '/'.

    // https://github.com/protocolbuffers/protobuf/blob/3.6.x/src/google/protobuf/any.proto#L87

      // Not handling nested structs or typed structs in typed structs

      // Not handling nested structs or typed structs in typed structs

  /**

   * Get a Factory from the registry by type URL.

   * @param typed_config for the extension config.

   */

  /**

   * Translate a nested config into a proto message provided by the implementation factory.

   * @param enclosing_message proto that contains a field 'typed_config'. Note: the enclosing proto

   * is provided because for statically registered implementations, a custom config is generally

   * optional, which means the conversion must be done conditionally.

   * @param validation_visitor message validation visitor instance.

   * @param factory implementation factory with the method 'createEmptyConfigProto' to produce a

   * proto to be filled with the translated configuration.

   */

  template <class ProtoMessage, class Factory>

  static ProtobufTypes::MessagePtr

  translateToFactoryConfig(const ProtoMessage& enclosing_message,

                           ProtobufMessage::ValidationVisitor& validation_visitor,

    // Fail in an obvious way if a plugin does not return a proto.

    // Check that the config type is not google.protobuf.Empty

  /**

   * Translate the typed any field into a proto message provided by the implementation factory.

   * @param typed_config typed configuration.

   * @param validation_visitor message validation visitor instance.

   * @param factory implementation factory with the method 'createEmptyConfigProto' to produce a

   * proto to be filled with the translated configuration.

   */

  template <class Factory>

  static ProtobufTypes::MessagePtr

  translateAnyToFactoryConfig(const Protobuf::Any& typed_config,

                              ProtobufMessage::ValidationVisitor& validation_visitor,

    // Fail in an obvious way if a plugin does not return a proto.

    // Check that the config type is not google.protobuf.Empty

  /**

   * Truncates the message to a length less than default GRPC trailers size limit (by default 8KiB).

   */

  static std::string truncateGrpcStatusMessage(absl::string_view error_message);

  /**

   * Obtain Grpc service config from the api config source.

   * @param api_config_source envoy::config::core::v3::ApiConfigSource. Must have config type GRPC.

   * @param grpc_service_idx index of the grpc service in the api_config_source. If there's no entry

   *                         in the given index, a nullptr factory will be returned.

   * @param xdstp_config_source whether the config source will be used for xdstp config source.

   *                            These sources must be of type AGGREGATED_GRPC or

   *                            AGGREGATED_DELTA_GRPC.

   * @return OptRef to either const envoy::config::core::v3::GrpcService or nullptr if there's no

   *         grpc_service in the given index.

   */

  static absl::StatusOr<Envoy::OptRef<const envoy::config::core::v3::GrpcService>>

  getGrpcConfigFromApiConfigSource(

      const envoy::config::core::v3::ApiConfigSource& api_config_source, int grpc_service_idx,

      bool xdstp_config_source);

  /**

   * Obtain gRPC async client factory from a envoy::config::core::v3::ApiConfigSource.

   * @param async_client_manager gRPC async client manager.

   * @param api_config_source envoy::config::core::v3::ApiConfigSource. Must have config type GRPC.

   * @param skip_cluster_check whether to skip cluster validation.

   * @param grpc_service_idx index of the grpc service in the api_config_source. If there's no entry

   *                         in the given index, a nullptr factory will be returned.

   * @param xdstp_config_source whether the config source will be used for xdstp config source.

   *                            These sources must be of type AGGREGATED_GRPC or

   *                            AGGREGATED_DELTA_GRPC.

   * @return Grpc::AsyncClientFactoryPtr gRPC async client factory, or nullptr if there's no

   *         grpc_service in the given index.

   */

  static absl::StatusOr<Grpc::AsyncClientFactoryPtr>

  factoryForGrpcApiConfigSource(Grpc::AsyncClientManager& async_client_manager,

                                const envoy::config::core::v3::ApiConfigSource& api_config_source,

                                Stats::Scope& scope, bool skip_cluster_check, int grpc_service_idx,

                                bool xdstp_config_source);

  /**

   * Translate opaque config from google.protobuf.Any to defined proto message.

   * @param typed_config opaque config packed in google.protobuf.Any

   * @param validation_visitor message validation visitor instance.

   * @param out_proto the proto message instantiated by extensions

   * @return a status indicating if translation was a success

   */

  static absl::Status translateOpaqueConfig(const Protobuf::Any& typed_config,

                                            ProtobufMessage::ValidationVisitor& validation_visitor,

                                            Protobuf::Message& out_proto);

  /**

   * Verify that any filter designed to be terminal is configured to be terminal, and vice versa.

   * @param name the name of the filter.

   * @param filter_type the type of filter.

   * @param filter_chain_type the type of filter chain.

   * @param is_terminal_filter true if the filter is designed to be terminal.

   * @param last_filter_in_current_config true if the filter is last in the configuration.

   * @return a status indicating if there is a mismatch between design and configuration.

   */

  static absl::Status validateTerminalFilters(const std::string& name,

                                              const std::string& filter_type,

                                              const std::string& filter_chain_type,

                                              bool is_terminal_filter,

                                              bool last_filter_in_current_config);

  /**

   * Prepares the DNS failure refresh backoff strategy given the cluster configuration.

   * @param config the config that contains dns refresh information.

   * @param dns_refresh_rate_ms the default DNS refresh rate.

   * @param random the random generator.

   * @return BackOffStrategyPtr for scheduling refreshes.

   */

  template <typename T>

  static BackOffStrategyPtr prepareDnsRefreshStrategy(const T& config, uint64_t dns_refresh_rate_ms,

  /**

   * Returns Jittered Exponential BackOff Strategy from BackoffStrategy config if present or

   * provided default timer values

   * @param api_config_source config

   * @param random random generator

   * @param default_base_interval_ms  Default base interval, must be > 0

   * @param default_max_interval_ms (optional) Default maximum interval

   * @return JitteredExponentialBackOffStrategyPtr if 1. Backoff Strategy is

   * found in the config or 2. default base interval and default maximum interval is specified or 3.

   * max interval is set to 10*default base interval

   */

  static absl::StatusOr<JitteredExponentialBackOffStrategyPtr>

  prepareJitteredExponentialBackOffStrategy(

      const envoy::config::core::v3::ApiConfigSource& api_config_source,

      Random::RandomGenerator& random, const uint32_t default_base_interval_ms,

  /**

   * Prepares Jittered Exponential BackOff Strategy from config containing the Retry Policy

   * @param config config containing RetryPolicy <envoy_v3_api_msg_config.core.v3.RetryPolicy>

   * @param random random generator

   * @param default_base_interval_ms  Default base interval, must be > 0

   * @param default_max_interval_ms (optional) Default maximum interval

   * @return JitteredExponentialBackOffStrategyPtr if 1. RetryPolicy containing backoff values is

   * found in config or 2. default base interval and default maximum interval is specified or 3.

   * default max interval is set to 10*default base interval

   */

  template <typename T>

  static absl::StatusOr<JitteredExponentialBackOffStrategyPtr>

  prepareJitteredExponentialBackOffStrategy(

      const T& config, Random::RandomGenerator& random, const uint32_t default_base_interval_ms,

private:

  /**

   * Returns Jittered Exponential BackOff Strategy from BackoffStrategy config or default

   * values

   * @param config (optional) BackoffStrategy config

   * @param random random generator

   * @param default_base_interval_ms  Default base interval, must be > 0

   * @param default_max_interval_ms (optional) Default maximum interval

   * @return JitteredExponentialBackOffStrategyPtr if 1. Backoff Strategy is

   * specified or 2. default base interval and default maximum interval is specified or 3.

   * max interval is set to 10*default base interval

   */

  static absl::StatusOr<JitteredExponentialBackOffStrategyPtr>

  buildJitteredExponentialBackOffStrategy(

      absl::optional<const envoy::config::core::v3::BackoffStrategy> backoff,

      Random::RandomGenerator& random, const uint32_t default_base_interval_ms,

      absl::optional<const uint32_t> default_max_interval_ms);

};

} // namespace Config

} // namespace Envoy