#pragma once

#include <functional>

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

#include "spdlog/spdlog.h"

namespace Envoy {

namespace Quic {

// A class, together with a stand alone buffer, used to achieve the purpose of WatermarkBuffer.

// Itself doesn't have buffer or bookkeep buffered bytes. But provided with buffered_bytes,

// it reacts upon crossing high/low watermarks.

// It's no-op if provided low and high watermark are 0.

class EnvoyQuicSimulatedWatermarkBuffer {

public:

  EnvoyQuicSimulatedWatermarkBuffer(uint32_t low_watermark, uint32_t high_watermark,

                                    std::function<void()> below_low_watermark,

                                    std::function<void()> above_high_watermark,

                                    spdlog::logger& logger)

      // Transitioning from below low watermark to above high watermark.

      // Transitioning from above high watermark to below low watermark.

  // True after the buffer goes above high watermark and hasn't come down below low

  // watermark yet, even though the buffered data might be between high and low

  // watermarks.

  // True before the buffer crosses the high watermark for the first time and after the buffer goes

  // below low watermark and hasn't come up above high watermark yet, even though the buffered data

  // might be between high and low watermarks.

private:

  uint32_t low_watermark_{0};

  uint32_t high_watermark_{0};

  bool is_full_{false};

  std::function<void()> below_low_watermark_;

  std::function<void()> above_high_watermark_;

  spdlog::logger& logger_;

};

} // namespace Quic

} // namespace Envoy