#pragma once

#include <memory>

#include <string>

#include "envoy/common/pure.h"

#include "envoy/config/subscription.h"

#include "envoy/config/xds_config_tracker.h"

#include "envoy/config/xds_resources_delegate.h"

#include "envoy/event/dispatcher.h"

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

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

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

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

#include "source/extensions/config_subscription/grpc/update_ack.h"

#include "absl/strings/string_view.h"

namespace Envoy {

namespace Config {

namespace XdsMux {

class SubscriptionState {};

// Tracks the protocol state of an individual ongoing xDS-over-gRPC session, for a single type_url.

// There can be multiple SubscriptionStates active, one per type_url. They will all be

// blissfully unaware of each other's existence, even when their messages are being multiplexed

// together by ADS.

// This is the abstract parent class for both the delta and state-of-the-world xDS variants.

template <class RS, class RQ>

class BaseSubscriptionState : public SubscriptionState,

                              public Logger::Loggable<Logger::Id::config> {

public:

  // Note that, outside of tests, we expect callbacks to always be a WatchMap.

  BaseSubscriptionState(std::string type_url, UntypedConfigUpdateCallbacks& callbacks,

                        Event::Dispatcher& dispatcher,

                        XdsConfigTrackerOptRef xds_config_tracker = absl::nullopt,

                        XdsResourcesDelegateOptRef xds_resources_delegate = absl::nullopt,

                        const std::string& target_xds_authority = "")

  // Update which resources we're interested in subscribing to.

  virtual void updateSubscriptionInterest(const absl::flat_hash_set<std::string>& cur_added,

                                          const absl::flat_hash_set<std::string>& cur_removed) PURE;

  // Whether there was a change in our subscription interest we have yet to inform the server of.

  virtual bool subscriptionUpdatePending() const PURE;

  virtual void markStreamFresh(bool should_send_initial_resource_versions) PURE;

  // May modify the order of the resources in response_proto to put all the

  // non-heartbeat resources first.

    // We *always* copy the response's nonce into the next request, even if we're going to make that

    // request a NACK by setting error_detail.

  // Returns the next gRPC request proto to be sent off to the server, based on this object's

  // understanding of the current protocol state, and new resources that Envoy wants to request.

  // The WithAck version first calls the ack-less version, then adds in the passed-in ack.

  // Returns a new'd pointer, meant to be owned by the caller, who is expected to know what type the

  // pointer actually is.

      // Don't needlessly make the field present-but-empty if status is ok.

  virtual void ttlExpiryCallback(const std::vector<std::string>& type_url) PURE;

protected:

  virtual std::unique_ptr<RQ> getNextRequestInternal() PURE;

  // May modify the order of the resources in response_proto to put all the

  // non-heartbeat resources first.

  virtual void handleGoodResponse(RS& message) PURE;

    // Note that error_detail being set is what indicates that a (Delta)DiscoveryRequest is a NACK.

  TtlManager ttl_;

  const std::string type_url_;

  // callbacks_ is expected (outside of tests) to be a WatchMap.

  UntypedConfigUpdateCallbacks& callbacks_;

  Event::Dispatcher& dispatcher_;

  bool dynamic_context_changed_{};

  std::string control_plane_identifier_{};

  XdsConfigTrackerOptRef xds_config_tracker_;

  XdsResourcesDelegateOptRef xds_resources_delegate_;

  const std::string target_xds_authority_;

  bool previously_fetched_data_{};

};

template <class T> class SubscriptionStateFactory {

public:

  // Note that, outside of tests, we expect callbacks to always be a WatchMap.

  virtual std::unique_ptr<T>

  makeSubscriptionState(const std::string& type_url, UntypedConfigUpdateCallbacks& callbacks,

                        OpaqueResourceDecoderSharedPtr resource_decoder,

                        XdsConfigTrackerOptRef xds_config_tracker = absl::nullopt,

                        XdsResourcesDelegateOptRef xds_resources_delegate = absl::nullopt,

                        const std::string& target_xds_authority = "") PURE;

};

} // namespace XdsMux

} // namespace Config

} // namespace Envoy