#pragma once

#include "envoy/event/timer.h"

#include "envoy/runtime/runtime.h"

#include "envoy/server/platform.h"

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

#include "source/common/event/real_time_system.h"

#include "source/common/grpc/google_grpc_context.h"

#include "source/common/stats/symbol_table.h"

#include "source/common/stats/thread_local_store.h"

#include "source/common/thread_local/thread_local_impl.h"

#include "source/exe/process_wide.h"

#include "source/server/listener_hooks.h"

#include "source/server/server.h"

#ifdef ENVOY_HANDLE_SIGNALS

#include "source/common/signal/signal_action.h"

#include "source/exe/terminate_handler.h"

#endif

namespace Envoy {

class ProdComponentFactory : public Server::ComponentFactory {

public:

  // Server::DrainManagerFactory

  Server::DrainManagerPtr createDrainManager(Server::Instance& server) override;

  Runtime::LoaderPtr createRuntime(Server::Instance& server,

                                   Server::Configuration::Initial& config) override;

};

// This is the common main between Envoy and Envoy mobile.

// It is stripped down to functionality required by Envoy Mobile: anything

// server-specific should live in MainCommonBase or MainCommon which remain

// separate for legacy reasons.

class StrippedMainBase {

public:

  using CreateInstanceFunction = std::function<std::unique_ptr<Server::Instance>(

      Init::Manager& init_manager, const Server::Options& options, Event::TimeSystem& time_system,

      ListenerHooks& hooks, Server::HotRestart& restarter, Stats::StoreRoot& store,

      Thread::BasicLockable& access_log_lock, Server::ComponentFactory& component_factory,

      Random::RandomGeneratorPtr&& random_generator, ThreadLocal::Instance& tls,

      Thread::ThreadFactory& thread_factory, Filesystem::Instance& file_system,

      std::unique_ptr<ProcessContext> process_context,

      Buffer::WatermarkFactorySharedPtr watermark_factory)>;

  static std::string hotRestartVersion(bool hot_restart_enabled);

  // Consumer must guarantee that all passed references are alive until this object is

  // destructed, except for `random_generator` which only needs to be alive until the constructor

  // completes execution.

  StrippedMainBase(const Server::Options& options, Server::ComponentFactory& component_factory,

                   std::unique_ptr<Server::Platform> platform_impl,

                   Random::RandomGenerator& random_generator);

  // Initialize the Envoy server instance. Must be called prior to any other method to use the

  // server. Separated from the constructor to allow for globals to be initialized first.

  void init(Event::TimeSystem& time_system, ListenerHooks& listener_hooks,

            std::unique_ptr<Random::RandomGenerator>&& random_generator,

            std::unique_ptr<ProcessContext> process_context,

            CreateInstanceFunction create_instance);

  // Will be null if options.mode() == Server::Mode::Validate

protected:

  std::unique_ptr<Server::Platform> platform_impl_;

  ProcessWide process_wide_; // Process-wide state setup/teardown (excluding grpc).

  // We instantiate this class regardless of ENVOY_GOOGLE_GRPC, to avoid having

  // an ifdef in a header file exposed in a C++ library. It is too easy to have

  // the ifdef be inconsistent across build-system boundaries.

  Grpc::GoogleGrpcContext google_grpc_context_;

  const Envoy::Server::Options& options_;

  Server::ComponentFactory& component_factory_;

  Stats::SymbolTableImpl symbol_table_;

  Stats::Allocator stats_allocator_;

  ThreadLocal::InstanceImplPtr tls_;

  std::unique_ptr<Server::HotRestart> restarter_;

  Stats::ThreadLocalStoreImplPtr stats_store_;

  // logging_context_ is only used in (some) subclasses, but it must be declared here so that it's

  // destructed after the server_. This is necessary because the Server and its threads may log

  // during destruction, causing data race issues with the Context's destruction and activation of

  // the saved context.

  std::unique_ptr<Logger::Context> logging_context_;

  std::unique_ptr<Init::Manager> init_manager_{std::make_unique<Init::ManagerImpl>("Server")};

  std::unique_ptr<Server::Instance> server_;

  // Only used for validation mode

  std::unique_ptr<ProcessContext> process_context_;

private:

  void configureComponentLogLevels();

  void configureHotRestarter(Random::RandomGenerator& random_generator);

  // Declaring main thread here allows custom integrations to instantiate

  // StrippedMainBase directly, with environment-specific dependency injection.

  // Note that MainThread must also be declared in MainCommon.

  Thread::MainThread main_thread_;

};

} // namespace Envoy