#ifndef THIRD_PARTY_MILOTIC_EXTERNAL_CC_TLBMC_SENSORS_HWMON_BASED_SENSOR_H_
#define THIRD_PARTY_MILOTIC_EXTERNAL_CC_TLBMC_SENSORS_HWMON_BASED_SENSOR_H_

#include <array>
#include <atomic>
#include <cstddef>
#include <memory>
#include <optional>
#include <string>
#include <string_view>

#include "absl/functional/any_invocable.h"
#include "absl/status/statusor.h"
#include "boost/asio.hpp"  //NOLINT: boost::asio is commonly used in BMC
#include "boost/filesystem.hpp"  // NOLINT: boost::filesystem is commonly used in BMC
#include "sensor.pb.h"
#include "tlbmc/sensors/hwmon_input_device.h"
#include "tlbmc/sensors/sensor.h"

namespace milotic_tlbmc {

// This class is a base class for sensors that are based on HWMon devices.
// All public interfaces are thread-safe.
// The `io_context` shall run only on a single thread.
// The successor will probably need to implement the
// CreateDeviceAndReturnsHwmonPath function.
class HwmonBasedSensor : public Sensor,
                         public std::enable_shared_from_this<HwmonBasedSensor> {
 public:
  HwmonBasedSensor(const std::string& input_dev_path,
                   const std::shared_ptr<boost::asio::io_context>& io_context,
                   SensorAttributesStatic&& sensor_attributes_static,
                   const ThresholdConfigs& threshold_configs,
                   std::optional<NotificationCb> on_batch_notify);

  ~HwmonBasedSensor() override;

  void RefreshOnceAsync(
      absl::AnyInvocable<void(const std::shared_ptr<const SensorValue>&)>
          callback) override;

 protected:
  HwmonBasedSensor() = default;
  explicit HwmonBasedSensor(
      const std::shared_ptr<boost::asio::io_context>& io_context)
      : io_context_(io_context) {}

  bool IsInputDeviceUsable() const { return input_device_usable_; }

  void SetInputDeviceUsable(bool input_device_usable) {
    input_device_usable_ = input_device_usable;
  }

  const std::array<char, 128>& GetConstReadBuffer() const {
    return read_buffer_;
  }

  std::array<char, 128>& GetMutableReadBuffer() { return read_buffer_; }

  const std::shared_ptr<HwmonInputDevice>& GetInputDevice() const {
    return input_device_;
  }

  // This function must be called on the `io_context_` thread.
  std::string GetInputDevicePath() const { return input_dev_path_; }

  // This function must be called on the `io_context_` thread.
  void SetInputDevicePath(const std::string& input_dev_path) {
    input_dev_path_ = input_dev_path;
  }

  // Sets up the input device. This function shall be called on the
  // `io_context_` thread or at construction time.
  // This function must be called on the `io_context_` thread.
  void SetUpInput();

  // Descendants shall implement this function to handle the buffer that reads
  // from the input device. This function will be called on the `io_context_`
  // thread.
  virtual void HandleRefreshResult(const boost::system::error_code& error,
                                   size_t bytes_read) = 0;

  // Given an input file, returns the unit of the sensor.
  static absl::StatusOr<SensorUnit> GetSensorUnit(std::string_view input_file);

  std::string input_dev_path_;
  std::shared_ptr<boost::asio::io_context> io_context_;
  // The buffer to read the value from.
  std::array<char, 128> read_buffer_ = {};
  // This variable is used to cancel any outstanding async read operations on
  // `input_device_` when sensor is being destroyed.
  std::atomic<bool> input_device_usable_ = false;

  std::shared_ptr<HwmonInputDevice> input_device_;

 private:
};

}  // namespace milotic_tlbmc

#endif  // THIRD_PARTY_MILOTIC_EXTERNAL_CC_TLBMC_SENSORS_HWMON_BASED_SENSOR_H_