#pragma once

#include <functional>

#include <list>

#include <utility>

#include "absl/container/flat_hash_map.h"

#include "absl/strings/string_view.h"

namespace Envoy {

namespace Stats {

// Remembers the last 'Capacity' items passed to lookup().

class RecentLookups {

public:

  /**

   * Records a lookup of a string. Only the last 'Capacity' lookups are remembered.

   *

   * @param str the item being looked up.

   */

  void lookup(absl::string_view str);

  using IterFn = std::function<void(absl::string_view, uint64_t)>;

  /**

   * Calls fn(item, count) for each of the remembered lookups.

   *

   * @param fn The function to call for every recently looked up item.

   */

  void forEach(const IterFn& fn) const;

  /**

   * @return the total number of lookups since tracking began.

   */

  uint64_t total() const { return total_; }

  /**

   * Clears out all contents.

   */

  void clear() {

    total_ = 0;

    map_.clear();

    list_.clear();

  }

  /**

   * Controls the maximum number of recent lookups to remember. If set to 0,

   * then only lookup counts is tracked.

   * @param capacity The number of lookups to remember.

   */

  void setCapacity(uint64_t capacity);

  /**

   * @return The configured capacity.

   */

  uint64_t capacity() const { return capacity_; }

private:

  void evictOne();

  struct ItemCount {

    std::string item_;

    uint64_t count_;

  };

  using List = std::list<ItemCount>;

  List list_;

  // TODO(jmarantz): we could make this more compact by making this a set of

  // list-iterators with heterogeneous hash/compare functors.

  using Map = absl::flat_hash_map<absl::string_view, List::iterator>;

  Map map_;

  uint64_t total_{0};

  uint64_t capacity_{0};

};

} // namespace Stats

} // namespace Envoy