#pragma once

#include <iostream>

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

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

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

#include "envoy/config/listener/v3/listener_components.pb.h"

#include "envoy/event/timer.h"

#include "envoy/server/drain_manager.h"

#include "envoy/server/instance.h"

#include "envoy/ssl/context_manager.h"

#include "envoy/tracing/tracer.h"

#include "source/common/access_log/access_log_manager_impl.h"

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

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

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

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

#include "source/common/network/dns_resolver/dns_factory_util.h"

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

#include "source/common/quic/quic_stat_names.h"

#include "source/common/router/context_impl.h"

#include "source/common/router/rds_impl.h"

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

#include "source/common/secret/secret_manager_impl.h"

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

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

#include "source/server/config_validation/admin.h"

#include "source/server/config_validation/api.h"

#include "source/server/config_validation/cluster_manager.h"

#include "source/server/hot_restart_nop_impl.h"

#include "source/server/server.h"

#include "absl/types/optional.h"

namespace Envoy {

namespace Server {

/**

 * validateConfig() takes over from main() for a config-validation run of Envoy. It returns true if

 * the config is valid, false if invalid.

 */

bool validateConfig(const Options& options,

                    const Network::Address::InstanceConstSharedPtr& local_address,

                    ComponentFactory& component_factory, Thread::ThreadFactory& thread_factory,

                    Filesystem::Instance& file_system,

                    const ProcessContextOptRef& process_context = absl::nullopt);

/**

 * ValidationInstance does the bulk of the work for config-validation runs of Envoy. It implements

 * Server::Instance, but some functionality not needed until serving time, such as updating

 * health-check status, is not implemented. Everything else is written in terms of other

 * validation-specific interface implementations, with the end result that we can load and

 * initialize a configuration, skipping any steps that affect the outside world (such as

 * hot-restarting or connecting to upstream clusters) but otherwise exercising the entire startup

 * flow.

 *

 * If we finish initialization, and reach the point where an ordinary Envoy run would begin serving

 * requests, the validation is considered successful.

 */

class ValidationInstance final : Logger::Loggable<Logger::Id::main>,

                                 public Instance,

                                 public ServerLifecycleNotifier,

                                 public WorkerFactory {

public:

  ValidationInstance(const Options& options, Event::TimeSystem& time_system,

                     const Network::Address::InstanceConstSharedPtr& local_address,

                     Stats::IsolatedStoreImpl& store, Thread::BasicLockable& access_log_lock,

                     ComponentFactory& component_factory, Thread::ThreadFactory& thread_factory,

                     Filesystem::Instance& file_system,

                     const ProcessContextOptRef& process_context = absl::nullopt);

  ~ValidationInstance() override;

  // Server::Instance

  Network::DnsResolverSharedPtr dnsResolver() override;

  void shutdown() override;

  // Server::WorkerFactory

  WorkerPtr createWorker(uint32_t, OverloadManager&, OverloadManager&,

    // Returned workers are not currently used so we can return nothing here safely vs. a

    // validation mock.

  // ServerLifecycleNotifier

private:

  void initialize(const Options& options,

                  const Network::Address::InstanceConstSharedPtr& local_address,

                  ComponentFactory& component_factory);

  // init_manager_ must come before any member that participates in initialization, and destructed

  // only after referencing members are gone, since initialization continuation can potentially

  // occur at any point during member lifetime.

  Init::ManagerImpl init_manager_{"Validation server"};

  // secret_manager_ must come before listener_manager_, config_ and dispatcher_, and destructed

  // only after these members can no longer reference it, since:

  // - There may be active filter chains referencing it in listener_manager_.

  // - There may be active clusters referencing it in config_.cluster_manager_.

  // - There may be active connections referencing it.

  std::unique_ptr<Secret::SecretManager> secret_manager_;

  const Options& options_;

  ProtobufMessage::ProdValidationContextImpl validation_context_;

  Stats::IsolatedStoreImpl& stats_store_;

  ThreadLocal::InstanceImpl thread_local_;

  envoy::config::bootstrap::v3::Bootstrap bootstrap_;

  Api::ApiPtr api_;

  // ssl_context_manager_ must come before dispatcher_, since ClusterInfo

  // references SslSocketFactory and is deleted on the main thread via the dispatcher.

  std::unique_ptr<Ssl::ContextManager> ssl_context_manager_;

  Event::DispatcherPtr dispatcher_;

  std::unique_ptr<Server::ValidationAdmin> admin_;

  Singleton::ManagerImpl singleton_manager_;

  std::unique_ptr<Runtime::Loader> runtime_;

  Random::RandomGeneratorImpl random_generator_;

  Configuration::MainImpl config_;

  LocalInfo::LocalInfoPtr local_info_;

  AccessLog::AccessLogManagerImpl access_log_manager_;

  std::unique_ptr<Http::HttpServerPropertiesCacheManager> http_server_properties_cache_manager_;

  Config::XdsManagerPtr xds_manager_;

  std::unique_ptr<Upstream::ValidationClusterManagerFactory> cluster_manager_factory_;

  std::unique_ptr<ListenerManager> listener_manager_;

  std::unique_ptr<OverloadManager> overload_manager_;

  std::unique_ptr<OverloadManager> null_overload_manager_;

  MutexTracer* mutex_tracer_{nullptr};

  Grpc::ContextImpl grpc_context_;

  Http::ContextImpl http_context_;

  Router::ContextImpl router_context_;

  Event::TimeSystem& time_system_;

  ServerFactoryContextImpl server_contexts_;

  Quic::QuicStatNames quic_stat_names_;

  Filter::TcpListenerFilterConfigProviderManagerImpl tcp_listener_config_provider_manager_;

  Server::DrainManagerPtr drain_manager_;

  HotRestartNopImpl nop_hot_restart_;

  Regex::EnginePtr regex_engine_;

};

} // namespace Server

} // namespace Envoy