#ifndef PRODUCTION_BORG_MGMT_NODE_PROXY_SAFEPOWER_SAFEPOWER_AGENT_CONDITION_H_
#define PRODUCTION_BORG_MGMT_NODE_PROXY_SAFEPOWER_SAFEPOWER_AGENT_CONDITION_H_

#include <memory>
#include <string>
#include <tuple>
#include <vector>

#include "safepower_agent.pb.h"
#include "state_updater.h"
#include "absl/base/nullability.h"
#include "absl/functional/any_invocable.h"
#include "absl/status/status.h"
#include "absl/strings/string_view.h"
#include "absl/time/time.h"
#include "google/protobuf/repeated_ptr_field.h"

namespace safepower_agent {

class Condition {
  class Listener
      : public StateUpdater<safepower_agent_proto::SystemState>::Listener {
   public:
    explicit Listener(Condition& condition) : condition_(condition) {}
    void UpdateState(const safepower_agent_proto::SystemState& current_state,
                     const safepower_agent_proto::SystemState& update) override;
    void Done() override {}

   private:
    Condition& condition_;
  };

 public:
  explicit Condition(const safepower_agent_proto::Condition& condition,
                     absl::Time original_start_time);
  ~Condition();

  using MatchList =
      std::vector<const safepower_agent_proto::Condition* >;

  static constexpr absl::Duration kTimeoutPadding = absl::Milliseconds(250);

  absl::Status WaitForMatch(
      absl::string_view unique_id,
      
      std::shared_ptr<StateUpdater<safepower_agent_proto::SystemState>>
          state_updater,
      const 
      std::shared_ptr<StateUpdater<safepower_agent_proto::SystemState>>&
          global_state_updater,
      absl::AnyInvocable<void(absl::Status, MatchList matches) &&> callback);
  std::tuple<absl::Status, MatchList> CheckState(
      const safepower_agent_proto::SystemState& state);

  absl::Status TriggerCallback(absl::Status match_status, MatchList match_list);

  bool active() const { return callback_ != nullptr; }

  static std::tuple<absl::Status, MatchList> Matches(
      const safepower_agent_proto::Condition& condition,
      const safepower_agent_proto::SystemState& state, absl::Time start_time,
      absl::Time current_time);

 private:
  void ExecuteCallback(absl::Status match_status, MatchList match_list);
  absl::Status RegisterTimeouts(
      const safepower_agent_proto::Condition& condition,
      absl::string_view job_name_prefix);
  absl::Status RegisterTimeouts(
      const google::protobuf::RepeatedPtrField<safepower_agent_proto::Condition>&
          conditions,
      absl::string_view job_name_prefix);

  Listener listener_;
  std::string complete_job_name_;
  const safepower_agent_proto::Condition& condition_;
  std::vector<std::string> pending_jobs_;
  absl::Time start_time_;
  absl::AnyInvocable<void(absl::Status, MatchList matches) &&> callback_;
  std::shared_ptr<StateUpdater<safepower_agent_proto::SystemState>>
      state_updater_;
};

}  // namespace safepower_agent

#endif  // PRODUCTION_BORG_MGMT_NODE_PROXY_SAFEPOWER_SAFEPOWER_AGENT_CONDITION_H_