#pragma once

#include <string>

#include <vector>

#include "envoy/stats/stats.h"

#include "envoy/stats/tag.h"

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

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

namespace Envoy {

namespace Stats {

/**

 * Helper class for implementing Metrics. This does not participate in any

 * inheritance chains, but can be instantiated by classes that do. It just

 * implements the mechanics of representing the name, tag-extracted-name,

 * and all tags as a StatNameList.

 */

class MetricHelper {

public:

  MetricHelper(StatName name, StatName tag_extracted_name, const StatNameTagVector& stat_name_tags,

               SymbolTable& symbol_table);

  ~MetricHelper();

  StatName statName() const;

  std::string name(const SymbolTable& symbol_table) const;

  TagVector tags(const SymbolTable& symbol_table) const;

  StatName tagExtractedStatName() const;

  void iterateTagStatNames(const Metric::TagStatNameIterFn& fn) const;

  // Hasher for metrics.

  struct Hash {

    using is_transparent = void; // NOLINT(readability-identifier-naming)

  };

  // Comparator for metrics.

  struct Compare {

    using is_transparent = void; // NOLINT(readability-identifier-naming)

  };

private:

  StatNameList stat_names_;

};

// An unordered set of stat pointers. which keys off Metric::statName().

// This necessitates a custom comparator and hasher, using the StatNamePtr's

// own StatNamePtrHash and StatNamePtrCompare operators.

//

// This is used by Allocator for counters, gauges, and text-readouts, and

// is also used by thread_local_store.h for histograms.

template <class StatType>

using StatSet = absl::flat_hash_set<StatType*, MetricHelper::Hash, MetricHelper::Compare>;

/**

 * Partial implementation of the Metric interface on behalf of Counters, Gauges,

 * and Histograms. It leaves symbolTable() unimplemented so that implementations

 * of stats managed by an allocator, specifically Counters and Gauges, can keep

 * a reference to the allocator instead, and derive the symbolTable() from that.

 *

 * We templatize on the base class (Counter, Gauge, or Histogram), rather than

 * using multiple virtual inheritance, as this avoids the overhead of an extra

 * vptr per instance. This is important for stats because there can be many

 * stats in systems with large numbers of clusters and hosts, and a few 8-byte

 * pointers per-stat here and there can add up to significant amounts of memory.

 *

 * Note the delegation of the implementation to a helper class, which is neither

 * templatized nor virtual. This avoids having the compiler elaborate complete

 * copies of the underlying implementation for each base class during template

 * expansion.

 */

template <class BaseClass> class MetricImpl : public BaseClass {

public:

  MetricImpl(StatName name, StatName tag_extracted_name, const StatNameTagVector& stat_name_tags,

             SymbolTable& symbol_table)

  // Empty construction of a MetricImpl; used for null stats.

  explicit MetricImpl(SymbolTable& symbol_table)

    // Cast our 'this', which is of type `const MetricImpl*` to a non-const

    // pointer, so we can use it to call the subclass implementation of

    // symbolTable(). That will be returned as a non-const SymbolTable&,

    // which will become const on return.

    //

    // This pattern is used to share a single non-trivial implementation to

    // provide const and non-const variants of a method.

protected:

private:

  MetricHelper helper_;

};

} // namespace Stats

} // namespace Envoy