#ifndef THIRD_PARTY_MILOTIC_EXTERNAL_CC_TLBMC_PACEMAKER_PACEMAKER_H_
#define THIRD_PARTY_MILOTIC_EXTERNAL_CC_TLBMC_PACEMAKER_PACEMAKER_H_

#include <cstdint>
#include <memory>
#include <string>
#include <utility>

#include "absl/base/thread_annotations.h"
#include "absl/memory/memory.h"
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/synchronization/mutex.h"
#include "absl/time/time.h"
#include "boost/circular_buffer.hpp"
#include "time/clock.h"
#include <nlohmann/json.hpp>
#include "tlbmc/scheduler/scheduler.h"

namespace milotic_tlbmc {

class ShellCommandExecutor {
 public:
  virtual ~ShellCommandExecutor() = default;

  virtual absl::StatusOr<std::string> Execute(const std::string& command);
};

enum class ErrorType : uint8_t {
  kUnknown = 0,
  kServiceInactive,
  kPortNotListening,
  kMemoryUsageAboveThreshold,
};

class Pacemaker {
 public:
  struct ErrorInfo {
    nlohmann::json ToJson() const;

    ErrorType type;
    absl::Time timestamp;
  };

  struct MonitoredData {
    nlohmann::json ToJson() const;

    boost::circular_buffer<int> memory_usage_bytes =
        boost::circular_buffer<int>(50);
    boost::circular_buffer<ErrorInfo> restart_log =
        boost::circular_buffer<ErrorInfo>(50);
    int pid = -1;
    int cpu_usage = -1;
    // ActiveEnterTimestampMonotonic value of the process as captured from
    // systemctl show --property=ActiveEnterTimestampMonotonic.
    // This is only used to detect if the process was restarted outside of
    // pacemaker.
    int64_t last_active_timestamp = -1;
    absl::Time last_reset_time = absl::InfinitePast();
    bool restart_triggered = false;
    int consecutive_restart_attempts = 0;
  };

  static std::unique_ptr<Pacemaker> Create(
      absl::Duration interval,
      std::unique_ptr<ShellCommandExecutor> shell_command_executor =
          std::make_unique<ShellCommandExecutor>(),
      ecclesia::Clock* clock = ecclesia::Clock::RealClock()) {
    return absl::WrapUnique(
        new Pacemaker(interval, std::move(shell_command_executor), clock));
  }

  nlohmann::json GetMonitoringData() const ABSL_LOCKS_EXCLUDED(mutex_);

  absl::Status PerformChecks();
  absl::StatusOr<int> GetPid(const std::string& process_name) const;
  absl::StatusOr<bool> IsPortListening(int port) const;
  absl::StatusOr<bool> IsServiceActive(const std::string& service_name) const;
  absl::StatusOr<int> GetMemoryUsage(int pid) const;
  absl::StatusOr<int> GetCpuUsage(const std::string& process_name) const;
  absl::StatusOr<int64_t> GetLastActiveTimestamp(
      const std::string& process_name) const;
  absl::Status RestartService(const std::string& service_name)
      ABSL_LOCKS_EXCLUDED(mutex_);
  void RecordError(ErrorType type) ABSL_LOCKS_EXCLUDED(mutex_);

  ~Pacemaker() { scheduler_.Stop(); }

 private:
  explicit Pacemaker(
      absl::Duration interval,
      std::unique_ptr<ShellCommandExecutor> shell_command_executor,
      ecclesia::Clock* clock);

  mutable absl::Mutex mutex_;
  std::unique_ptr<ShellCommandExecutor> shell_command_executor_;
  TaskScheduler scheduler_;
  MonitoredData monitored_data_ ABSL_GUARDED_BY(mutex_);
};

}  // namespace milotic_tlbmc

#endif  // THIRD_PARTY_MILOTIC_EXTERNAL_CC_TLBMC_PACEMAKER_PACEMAKER_H_