#pragma once

#include <cstdint>

#include <memory>

#include <string>

#include "envoy/api/api.h"

#include "envoy/common/exception.h"

#include "envoy/common/random_generator.h"

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

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

#include "envoy/config/subscription.h"

#include "envoy/init/manager.h"

#include "envoy/runtime/runtime.h"

#include "envoy/service/discovery/v3/discovery.pb.h"

#include "envoy/service/runtime/v3/rtds.pb.h"

#include "envoy/service/runtime/v3/rtds.pb.validate.h"

#include "envoy/stats/stats_macros.h"

#include "envoy/stats/store.h"

#include "envoy/thread_local/thread_local.h"

#include "envoy/type/v3/percent.pb.h"

#include "envoy/upstream/cluster_manager.h"

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

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

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

#include "source/common/config/subscription_base.h"

#include "source/common/init/manager_impl.h"

#include "source/common/init/target_impl.h"

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

#include "absl/container/node_hash_map.h"

#include "absl/status/statusor.h"

#include "spdlog/spdlog.h"

namespace Envoy {

namespace Runtime {

using RuntimeSingleton = ThreadSafeSingleton<Loader>;

/**

 * All runtime stats. @see stats_macros.h

 */

#define ALL_RUNTIME_STATS(COUNTER, GAUGE)                                                          \

/**

 * Struct definition for all runtime stats. @see stats_macros.h

 */

struct RuntimeStats {

  ALL_RUNTIME_STATS(GENERATE_COUNTER_STRUCT, GENERATE_GAUGE_STRUCT)

};

/**

 * Implementation of Snapshot whose source is the vector of layers passed to the constructor.

 */

class SnapshotImpl : public Snapshot, Logger::Loggable<Logger::Id::runtime> {

public:

  SnapshotImpl(Random::RandomGenerator& generator, RuntimeStats& stats,

               std::vector<OverrideLayerConstPtr>&& layers);

  // Runtime::Snapshot

  bool deprecatedFeatureEnabled(absl::string_view key, bool default_value) const override;

  bool runtimeFeatureEnabled(absl::string_view key) const override;

  bool featureEnabled(absl::string_view key, uint64_t default_value, uint64_t random_value,

                      uint64_t num_buckets) const override;

  bool featureEnabled(absl::string_view key, uint64_t default_value) const override;

  bool featureEnabled(absl::string_view key, uint64_t default_value,

                      uint64_t random_value) const override;

  bool featureEnabled(absl::string_view key,

                      const envoy::type::v3::FractionalPercent& default_value) const override;

  bool featureEnabled(absl::string_view key,

                      const envoy::type::v3::FractionalPercent& default_value,

                      uint64_t random_value) const override;

  ConstStringOptRef get(absl::string_view key) const override;

  uint64_t getInteger(absl::string_view key, uint64_t default_value) const override;

  double getDouble(absl::string_view key, double default_value) const override;

  bool getBoolean(absl::string_view key, bool value) const override;

  const std::vector<OverrideLayerConstPtr>& getLayers() const override;

  const EntryMap& values() const;

  static Entry createEntry(const Protobuf::Value& value, absl::string_view raw_string);

  static void addEntry(Snapshot::EntryMap& values, const std::string& key,

                       const Protobuf::Value& value, absl::string_view raw_string = "");

private:

  const std::vector<OverrideLayerConstPtr> layers_;

  EntryMap values_;

  Random::RandomGenerator& generator_;

  RuntimeStats& stats_;

};

using SnapshotImplPtr = std::unique_ptr<SnapshotImpl>;

/**

 * Base implementation of OverrideLayer that by itself provides an empty values map.

 */

class OverrideLayerImpl : public Snapshot::OverrideLayer {

public:

protected:

  Snapshot::EntryMap values_;

  const std::string name_;

};

/**

 * Extension of OverrideLayerImpl that maintains an in-memory set of values. These values can be

 * modified programmatically via mergeValues(). AdminLayer is so named because it

 * can be accessed and manipulated by Envoy's admin interface.

 */

class AdminLayer : public OverrideLayerImpl {

public:

  explicit AdminLayer(absl::string_view name, RuntimeStats& stats)

  /**

   * Copy-constructible so that it can snapshotted.

   */

  /**

   * Merge the provided values into our entry map. An empty value indicates that a key should be

   * removed from our map.

   */

  absl::Status mergeValues(const absl::node_hash_map<std::string, std::string>& values);

private:

  RuntimeStats& stats_;

};

using AdminLayerPtr = std::unique_ptr<AdminLayer>;

/**

 * Extension of OverrideLayerImpl that loads values from the file system upon construction.

 */

class DiskLayer : public OverrideLayerImpl, Logger::Loggable<Logger::Id::runtime> {

public:

  DiskLayer(absl::string_view name, const std::string& path, Api::Api& api,

            absl::Status& creation_status);

private:

  absl::Status walkDirectory(const std::string& path, const std::string& prefix, uint32_t depth,

                             Api::Api& api);

  const std::string path_;

  const Filesystem::WatcherPtr watcher_;

};

/**

 * Extension of OverrideLayerImpl that loads values from a proto Struct representation.

 */

class ProtoLayer : public OverrideLayerImpl, Logger::Loggable<Logger::Id::runtime> {

public:

  ProtoLayer(absl::string_view name, const Protobuf::Struct& proto, absl::Status& creation_status);

private:

  absl::Status walkProtoValue(const Protobuf::Value& v, const std::string& prefix);

};

class LoaderImpl;

struct RtdsSubscription : Envoy::Config::SubscriptionBase<envoy::service::runtime::v3::Runtime>,

                          Logger::Loggable<Logger::Id::runtime> {

  RtdsSubscription(LoaderImpl& parent,

                   const envoy::config::bootstrap::v3::RuntimeLayer::RtdsLayer& rtds_layer,

                   Stats::Store& store, ProtobufMessage::ValidationVisitor& validation_visitor);

  // Config::SubscriptionCallbacks

  absl::Status onConfigUpdate(const std::vector<Config::DecodedResourceRef>& resources,

                              const std::string& version_info) override;

  absl::Status onConfigUpdate(const std::vector<Config::DecodedResourceRef>& added_resources,

                              const Protobuf::RepeatedPtrField<std::string>& removed_resources,

                              const std::string&) override;

  void onConfigUpdateFailed(Envoy::Config::ConfigUpdateFailureReason reason,

                            const EnvoyException* e) override;

  void start();

  absl::Status validateUpdateSize(uint32_t added_resources_num, uint32_t removed_resources_num);

  absl::Status onConfigRemoved(const Protobuf::RepeatedPtrField<std::string>& removed_resources);

  absl::Status createSubscription();

  LoaderImpl& parent_;

  const envoy::config::core::v3::ConfigSource config_source_;

  Stats::Store& store_;

  Stats::ScopeSharedPtr stats_scope_;

  Config::SubscriptionPtr subscription_;

  std::string resource_name_;

  Init::TargetImpl init_target_;

  Protobuf::Struct proto_;

};

using RtdsSubscriptionPtr = std::unique_ptr<RtdsSubscription>;

/**

 * Implementation of Loader that provides Snapshots of values added via mergeValues().

 * A single snapshot is shared among all threads and referenced by shared_ptr such that

 * a new runtime can be swapped in by the main thread while workers are still using the previous

 * version.

 */

class LoaderImpl : public Loader, Logger::Loggable<Logger::Id::runtime> {

public:

  static absl::StatusOr<std::unique_ptr<LoaderImpl>>

  create(Event::Dispatcher& dispatcher, ThreadLocal::SlotAllocator& tls,

         const envoy::config::bootstrap::v3::LayeredRuntime& config,

         const LocalInfo::LocalInfo& local_info, Stats::Store& store,

         Random::RandomGenerator& generator, ProtobufMessage::ValidationVisitor& validation_visitor,

         Api::Api& api);

  // Runtime::Loader

  absl::Status initialize(Upstream::ClusterManager& cm) override;

  const Snapshot& snapshot() const override;

  SnapshotConstSharedPtr threadsafeSnapshot() override;

  absl::Status mergeValues(const absl::node_hash_map<std::string, std::string>& values) override;

  void startRtdsSubscriptions(ReadyCallback on_done) override;

  Stats::Scope& getRootScope() override;

  void countDeprecatedFeatureUse() const override;

private:

  friend RtdsSubscription;

  LoaderImpl(ThreadLocal::SlotAllocator& tls,

             const envoy::config::bootstrap::v3::LayeredRuntime& config,

             const LocalInfo::LocalInfo& local_info, Stats::Store& store,

             Random::RandomGenerator& generator, Api::Api& api);

  absl::Status initLayers(Event::Dispatcher& dispatcher,

                          ProtobufMessage::ValidationVisitor& validation_visitor);

  // Create a new Snapshot

  absl::StatusOr<SnapshotImplPtr> createNewSnapshot();

  // Load a new Snapshot into TLS

  absl::Status loadNewSnapshot();

  RuntimeStats generateStats(Stats::Store& store);

  void onRtdsReady();

  Random::RandomGenerator& generator_;

  RuntimeStats stats_;

  AdminLayerPtr admin_layer_;

  ThreadLocal::SlotPtr tls_;

  const envoy::config::bootstrap::v3::LayeredRuntime config_;

  const std::string service_cluster_;

  Filesystem::WatcherPtr watcher_;

  Api::Api& api_;

  ReadyCallback on_rtds_initialized_;

  Init::WatcherImpl init_watcher_;

  Init::ManagerImpl init_manager_{"RTDS"};

  std::vector<RtdsSubscriptionPtr> subscriptions_;

  Upstream::ClusterManager* cm_{};

  Stats::Store& store_;

  absl::Mutex snapshot_mutex_;

  SnapshotConstSharedPtr thread_safe_snapshot_ ABSL_GUARDED_BY(snapshot_mutex_);

};

} // namespace Runtime

} // namespace Envoy