#pragma once

#include <chrono>

#include <string>

#include "envoy/common/random_generator.h"

#include "envoy/config/subscription.h"

#include "envoy/event/dispatcher.h"

#include "envoy/runtime/runtime.h"

#include "envoy/upstream/cluster_manager.h"

namespace Envoy {

namespace Http {

/**

 * A helper base class used to fetch a REST API at a jittered periodic interval. Once initialize()

 * is called, the API will be fetched and events raised.

 */

class RestApiFetcher : public Http::AsyncClient::Callbacks {

protected:

  RestApiFetcher(Upstream::ClusterManager& cm, const std::string& remote_cluster_name,

                 Event::Dispatcher& dispatcher, Random::RandomGenerator& random,

                 std::chrono::milliseconds refresh_interval,

                 std::chrono::milliseconds request_timeout);

  ~RestApiFetcher() override;

  /**

   * Start the fetch sequence. This should be called once.

   */

  void initialize();

  /**

   * This will be called when a fetch is about to happen. It should be overridden to fill the

   * request message with a valid request.

   */

  virtual void createRequest(RequestMessage& request) PURE;

  /**

   * This will be called when a 200 response is returned by the API with the response message.

   */

  virtual void parseResponse(const ResponseMessage& response) PURE;

  /**

   * This will be called either in the success case or in the failure case for each fetch. It can

   * be used to hold common post request logic.

   */

  virtual void onFetchComplete() PURE;

  /**

   * This will be called if the fetch fails (either due to non-200 response, network error, etc.).

   * @param reason supplies the fetch failure reason.

   * @param e supplies any exception data on why the fetch failed. May be nullptr.

   */

  virtual void onFetchFailure(Config::ConfigUpdateFailureReason reason,

                              const EnvoyException* e) PURE;

protected:

  const std::string remote_cluster_name_;

  Upstream::ClusterManager& cm_;

private:

  void refresh();

  void requestComplete();

  // Http::AsyncClient::Callbacks

  void onSuccess(const Http::AsyncClient::Request&, Http::ResponseMessagePtr&& response) override;

  void onFailure(const Http::AsyncClient::Request&,

                 Http::AsyncClient::FailureReason reason) override;

  void onBeforeFinalizeUpstreamSpan(Envoy::Tracing::Span&,

  Random::RandomGenerator& random_;

  const std::chrono::milliseconds refresh_interval_;

  const std::chrono::milliseconds request_timeout_;

  Event::TimerPtr refresh_timer_;

  Http::AsyncClient::Request* active_request_{};

};

} // namespace Http

} // namespace Envoy