#pragma once

#include <algorithm>

#include <functional>

#include <map>

#include <string>

#include <vector>

#include "envoy/common/exception.h"

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

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

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

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

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

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

#include "absl/base/attributes.h"

#include "absl/container/flat_hash_map.h"

#include "absl/strings/str_join.h"

#include "absl/strings/string_view.h"

#include "fmt/ranges.h"

namespace Envoy {

namespace Registry {

template <class Base> class FactoryRegistry;

template <class T, class Base> class RegisterFactory;

/**

 * FactoryRegistryProxy is a proxy object that provides access to the

 * static methods of a strongly-typed factory registry.

 */

class FactoryRegistryProxy {

public:

  virtual std::vector<absl::string_view> registeredNames() const PURE;

  // Return all registered factory names, including disabled factories.

  virtual std::vector<absl::string_view> allRegisteredNames() const PURE;

  virtual absl::optional<envoy::config::core::v3::BuildVersion>

  getFactoryVersion(absl::string_view name) const PURE;

  virtual bool disableFactory(absl::string_view) PURE;

  virtual bool isFactoryDisabled(absl::string_view) const PURE;

  virtual absl::flat_hash_map<std::string, std::vector<std::string>> registeredTypes() const PURE;

  virtual absl::string_view canonicalFactoryName(absl::string_view) const PURE;

};

template <class Base> class FactoryRegistryProxyImpl : public FactoryRegistryProxy {

public:

  using FactoryRegistry = Envoy::Registry::FactoryRegistry<Base>;

  absl::optional<envoy::config::core::v3::BuildVersion>

};

/**

 * BaseFactoryCategoryRegistry holds the static factory map for

 * FactoryCategoryRegistry, ensuring that friends of that class

 * cannot get non-const access to it.

 */

class BaseFactoryCategoryRegistry {

protected:

  using MapType = absl::flat_hash_map<std::string, FactoryRegistryProxy*>;

};

/**

 * FactoryCategoryRegistry registers factory registries by their

 * declared category. The category is exposed by a static category()

 * method on the factory base type.

 *

 * Only RegisterFactory instances are able to register factory registries.

 */

class FactoryCategoryRegistry : public BaseFactoryCategoryRegistry {

public:

  /**

   * @return a read-only reference to the map of registered factory

   * registries.

   */

  /**

   * @return whether the given category name is already registered.

   */

private:

  // Allow RegisterFactory and the test helper InjectFactoryCategory to register a category, but

  // no-one else. This enforces correct use of the registration machinery.

  template <class T, class Base> friend class RegisterFactory;

  template <class Base> friend class InjectFactoryCategory;

};

// Forward declaration of test class for friend declaration below.

template <typename T> class InjectFactory;

/**

 * General registry for implementation factories. The registry is templated by the Base class that a

 * set of factories conforms to.

 *

 * Classes are found by name, so a single name cannot be registered twice for the same Base class.

 * Factories are registered by reference and this reference is expected to be valid through the life

 * of the program. Factories cannot be deregistered.

 * Factories should generally be registered by statically instantiating the RegisterFactory class.

 *

 * Note: This class is not thread safe, so registration should only occur in a single threaded

 * environment, which is guaranteed by the static instantiation mentioned above.

 *

 * Example lookup: BaseFactoryType *factory =

 * FactoryRegistry<BaseFactoryType>::getFactory("example_factory_name");

 */

template <class Base> class FactoryRegistry : public Logger::Loggable<Logger::Id::config> {

public:

  /**

   * Return a sorted vector of registered factory names.

   */

  /**

   * Gets the current map of factory implementations.

   */

  /**

   * Gets the current map of vendor specific factory versions.

   */

  static absl::flat_hash_map<std::string, envoy::config::core::v3::BuildVersion>&

  /**

   * Lazily constructs a mapping from the configuration message type to a factory,

   * including the deprecated configuration message types.

   * Must be invoked after factory registration is completed.

   */

  /**

   * instead_value are used when passed name was deprecated.

   */

  static void registerFactory(Base& factory, absl::string_view name,

  /**

   * version is used for registering vendor specific factories that are versioned

   * independently of Envoy.

   */

  static void registerFactory(Base& factory, absl::string_view name,

                              const envoy::config::core::v3::BuildVersion& version,

  /**

   * Permanently disables the named factory by setting the corresponding

   * factory pointer to null. If the factory is registered under multiple

   * (deprecated) names, all the possible names are disabled.

   */

    // First, find the canonical name for this factory.

    // Next, disable the factory by all its deprecated names.

    // Finally, disable the factory by its canonical name.

  /**

   * Gets a factory by name. If the name isn't found in the registry, returns nullptr.

   */

  /**

   * @return the canonical name of the factory. If the given name is a

   * deprecated factory name, the canonical name is returned instead.

   */

  /**

   * @return true if the named factory was disabled.

   */

  /**

   * @return vendor specific version of a factory.

   */

  static absl::optional<envoy::config::core::v3::BuildVersion>

  /**

   * @return set of config type names indexed by the factory name.

   */

private:

  // Allow factory injection only in tests.

  friend class InjectFactory<Base>;

        // Register config types in the mapping.

          // Mark double-registered types with a nullptr for tests only.

          // See issue https://github.com/envoyproxy/envoy/issues/9643.

  // Rebuild the factories-by-type map based on the current factories.

  /**

   * Replaces a factory by name. This method should only be used for testing purposes.

   * @param factory is the factory to inject.

   * @param deprecated_names install the given deprecated names for this factory.

   * @return std::function<void()> a function that will restore the previously registered factories

   *         (by name or type).

   */

  static std::function<void()>

  replaceFactoryForTest(Base& factory,

};

/**

 * Factory registration template. Enables users to register a particular implementation factory with

 * the FactoryRegistry by instantiating this templated class with the specific factory class and the

 * general Base class to which that factory conforms.

 *

 * Because factories are generally registered once and live for the length of the program, the

 * standard use of this class is static instantiation within a linked implementation's translation

 * unit. For an example of a typical use case, @see NamedNetworkFilterConfigFactory.

 *

 * Example registration: REGISTER_FACTORY(SpecificFactory, BaseFactory);

 *                       LEGACY_REGISTER_FACTORY(SpecificFactory, BaseFactory, "deprecated_name");

 */

template <class T, class Base> class RegisterFactory {

public:

  /**

   * Constructor that registers an instance of the factory with the FactoryRegistry.

   */

    // Also register this factory with its category.

    //

    // Each time a factory registers, the registry will attempt to

    // register its category here. This means that we have to ignore

    // multiple attempts to register the same category and can't detect

    // duplicate categories.

  /**

   * Constructor that registers an instance of the factory with the FactoryRegistry along with

   * deprecated names.

   */

  /**

   * Constructor that registers an instance of the factory with the FactoryRegistry along with

   * vendor specific version.

   */

  RegisterFactory(uint32_t major, uint32_t minor, uint32_t patch,

                  const std::map<std::string, std::string>& version_metadata)

  /**

   * Constructor that registers an instance of the factory with the FactoryRegistry along with

   * vendor specific version and deprecated names.

   */

  RegisterFactory(uint32_t major, uint32_t minor, uint32_t patch,

                  const std::map<std::string, std::string>& version_metadata,

private:

  static envoy::config::core::v3::BuildVersion

  makeBuildVersion(uint32_t major, uint32_t minor, uint32_t patch,

  T instance_{};

};

/**

 * RegisterInternalFactory is a special case for registering factories

 * that are considered internal implementation details that should

 * not be exposed to operators via the factory categories.

 *

 * There is no corresponding REGISTER_INTERNAL_FACTORY because

 * this should be used sparingly and only in special cases.

 */

template <class T, class Base> class RegisterInternalFactory {

public:

private:

  T instance_{};

};

#ifdef ENVOY_STATIC_EXTENSION_REGISTRATION

/**

 * Macro used for static registration.

 */

#define REGISTER_FACTORY(FACTORY, BASE)                                                            \

  static Envoy::Registry::RegisterFactory</* NOLINT(fuchsia-statically-constructed-objects) */     \

                                          FACTORY, BASE>                                           \

      FACTORY##_registered

/**

 * Macro used for static registration with deprecated name.

 */

#define LEGACY_REGISTER_FACTORY(FACTORY, BASE, DEPRECATED_NAME)                                    \

  static Envoy::Registry::RegisterFactory</* NOLINT(fuchsia-statically-constructed-objects) */     \

                                          FACTORY, BASE>                                           \

      FACTORY##_registered {                                                                       \

    DEPRECATED_NAME                                                                                \

  }

#else

/**

 * Macro used to define a registration function.

 */

#define REGISTER_FACTORY(FACTORY, BASE)                                                            \

  ABSL_ATTRIBUTE_UNUSED void forceRegister##FACTORY() {                                            \

    ABSL_ATTRIBUTE_UNUSED static auto registered =                                                 \

        new Envoy::Registry::RegisterFactory<FACTORY, BASE>();                                     \

  }

/**

 * Macro used to define a registration function with deprecated name.

 */

#define LEGACY_REGISTER_FACTORY(FACTORY, BASE, DEPRECATED_NAME)                                    \

  ABSL_ATTRIBUTE_UNUSED void forceRegister##FACTORY() {                                            \

    ABSL_ATTRIBUTE_UNUSED static auto registered =                                                 \

        new Envoy::Registry::RegisterFactory<FACTORY, BASE>({DEPRECATED_NAME});                    \

  }

#endif

#define FACTORY_VERSION(major, minor, patch, ...) major, minor, patch, __VA_ARGS__

/**

 * Macro used for static registration declaration.

 * Calling forceRegister...(); can be used to force the static factory initializer to run in a

 * setting in which Envoy is bundled as a static archive. In this case, the static initializer is

 * not run until a function in the compilation unit is invoked. The force function can be invoked

 * from a static library wrapper.

 */

#define DECLARE_FACTORY(FACTORY) ABSL_ATTRIBUTE_UNUSED void forceRegister##FACTORY()

} // namespace Registry

} // namespace Envoy