#pragma once

#include <memory>

#include "envoy/api/api.h"

#include "envoy/common/random_generator.h"

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

#include "envoy/event/deferred_deletable.h"

#include "envoy/init/manager.h"

#include "envoy/singleton/instance.h"

#include "envoy/thread_local/thread_local.h"

#include "envoy/upstream/cluster_manager.h"

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

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

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

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

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

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

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

#include "absl/types/optional.h"

namespace Envoy {

namespace Config {

namespace DataSource {

template <class DataType> class DataSourceProvider;

using ProtoDataSource = envoy::config::core::v3::DataSource;

using ProtoWatchedDirectory = envoy::config::core::v3::WatchedDirectory;

template <class DataType>

using DataSourceProviderPtr = std::unique_ptr<DataSourceProvider<DataType>>;

template <class DataType>

using DataSourceProviderSharedPtr = std::shared_ptr<DataSourceProvider<DataType>>;

/**

 * Read contents of the file.

 * @param path file path.

 * @param api reference to the Api.

 * @param allow_empty return an empty string if the file is empty.

 * @param max_size max size limit of file to read, default 0 means no limit, and if the file data

 * would exceed the limit, it will return an error status.

 * @return std::string with file contents. or an error status if the file does not exist or

 * cannot be read.

 */

absl::StatusOr<std::string> readFile(const std::string& path, Api::Api& api, bool allow_empty,

                                     uint64_t max_size = 0);

/**

 * Read contents of the DataSource.

 * @param source data source.

 * @param allow_empty return an empty string if no DataSource case is specified.

 * @param api reference to the Api.

 * @param max_size max size limit of file to read, default 0 means no limit, and if the file data

 * would exceed the limit, it will return an error status.

 * @return std::string with DataSource contents. or an error status if no DataSource case is

 * specified and !allow_empty.

 */

absl::StatusOr<std::string> read(const envoy::config::core::v3::DataSource& source,

                                 bool allow_empty, Api::Api& api, uint64_t max_size = 0);

/**

 * @param source data source.

 * @return absl::optional<std::string> path to DataSource if a filename, otherwise absl::nullopt.

 */

absl::optional<std::string> getPath(const envoy::config::core::v3::DataSource& source);

template <class DataType>

using DataTransform = std::function<absl::StatusOr<std::shared_ptr<DataType>>(absl::string_view)>;

struct ProviderOptions {

  // Use an empty string if no DataSource case is specified.

  bool allow_empty{false};

  // Limit of file to read, default 0 means no limit.

  uint64_t max_size{0};

  // Watch for file modifications.

  bool modify_watch{false};

  // Hash content before transforming, and skip transforming if hash is the same.

  bool hash_content{false};

};

// DynamicData registers the file watches and a thread local slot. This class

// must be created and deleted on the dispatcher thread.

template <class DataType> class DynamicData {

public:

  struct ThreadLocalData : public ThreadLocal::ThreadLocalObject {

    std::shared_ptr<DataType> data_;

  };

  DynamicData(const ProtoDataSource& source, Event::Dispatcher& main_dispatcher,

              ThreadLocal::SlotAllocator& tls, Api::Api& api,

              DataTransform<DataType> data_transform_cb, const ProviderOptions& options,

              std::shared_ptr<DataType> initial_data, uint64_t initial_hash,

              absl::AnyInvocable<void()> cleanup, absl::Status& creation_status)

private:

      // Log an error but don't fail the watch to avoid throwing EnvoyException at runtime.

      // Log an error but don't fail the watch to avoid throwing EnvoyException at runtime.

  Event::Dispatcher& dispatcher_;

  Api::Api& api_;

  const ProviderOptions options_;

  const std::string filename_;

  DataTransform<DataType> data_transform_;

  uint64_t hash_;

  absl::AnyInvocable<void()> cleanup_;

  ThreadLocal::TypedSlotPtr<ThreadLocalData> slot_;

  WatchedDirectoryPtr watcher_;

  Filesystem::WatcherPtr modify_watcher_;

};

/** Checks whether data source uses file watching. */

bool usesFileWatching(const ProtoDataSource& source, const ProviderOptions& options);

/**

 * DataSourceProvider provides a way to get the DataSource contents and watch the possible

 * content changes. The watch only works for filename-based DataSource and watched directory

 * is provided explicitly or with modify-watch enabled.

 *

 * NOTE: This should only be used when the envoy.config.core.v3.DataSource is necessary and

 * file watch is required.

 */

template <class DataType> class DataSourceProvider {

public:

  /**

   * Create a DataSourceProvider from a DataSource.

   * @param source data source.

   * @param main_dispatcher reference to the main dispatcher.

   * @param tls reference to the thread local slot allocator.

   * @param api reference to the Api.

   * @param allow_empty return an empty string if no DataSource case is specified.

   * @param data_transform_cb transforms content of the DataSource (type std::string)

   *        to the desired `DataType` type.

   * @param max_size max size limit of file to read, default 0 means no limit.

   * @return absl::StatusOr<DataSourceProvider> with DataSource contents. or an error

   * status if any error occurs.

   * NOTE: If file watch is enabled and the new file content does not meet the

   * requirements (allow_empty, max_size), the provider will keep the old content.

   */

  static absl::StatusOr<DataSourceProviderPtr<DataType>>

  create(const ProtoDataSource& source, Event::Dispatcher& main_dispatcher,

         ThreadLocal::SlotAllocator& tls, Api::Api& api, bool allow_empty,

  static absl::StatusOr<DataSourceProviderPtr<DataType>>

  create(const ProtoDataSource& source, Event::Dispatcher& main_dispatcher,

         ThreadLocal::SlotAllocator& tls, Api::Api& api, DataTransform<DataType> data_transform_cb,

    // read() only validates the size of the file and does not check the size of inline data.

    // We check the size of inline data here.

    // TODO(wbpcode): consider moving this check to read() to avoid duplicate checks.

      // Schedule destruction on the dispatcher thread. This ensures that close()

      // stops any inotify events on the same thread.

private:

  absl::variant<std::shared_ptr<DataType>, std::unique_ptr<DynamicData<DataType>>> data_;

};

/**

 * ProviderSingleton allows sharing of dynamic DataSourceProviders using a process-wide

 * singleton instance. Only providers that rely on the file watching are shared, the rest

 * are created on-demand. This singleton reduces the resource pressure on the file watchers

 * and storage needed by the data type.

 */

template <class DataType>

class ProviderSingleton : public Singleton::Instance,

                          public std::enable_shared_from_this<ProviderSingleton<DataType>> {

public:

  ProviderSingleton(Event::Dispatcher& main_dispatcher, ThreadLocal::SlotAllocator& tls,

                    Api::Api& api, DataTransform<DataType> data_transform_cb,

                    const ProviderOptions& options)

    // Cleanup is guaranteed to execute on the main dispatcher during destruction but may happen

    // after the singleton is released.

private:

  Event::Dispatcher& dispatcher_;

  ThreadLocal::SlotAllocator& tls_;

  Api::Api& api_;

  DataTransform<DataType> data_transform_;

  const ProviderOptions options_;

  absl::flat_hash_map<size_t, std::weak_ptr<DataSourceProvider<DataType>>> dynamic_providers_;

};

} // namespace DataSource

} // namespace Config

} // namespace Envoy