ConsoleModel.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <cstdint>
#include <mutex>
#include <optional>
#include <sstream>
#include <string>
 
#include "bus/UiBusClient.hpp"
 
namespace lacte::ui {
 
// optional_text форматирует значение из BoardSnapshot в то же текстовое
// представление, что видит консольный оператор (ConsoleModel::snapshot())
// - вынесены сюда (а не остались file-local в ConsoleUi.cpp) специально
// для того, чтобы ConsoleModel::DisplayState оставался пригоден для
// прямой сборки в GTest (см. LacteApp/tests/ConsoleUiDisplayTest.cpp) без
// копии этой логики форматирования.
inline auto optional_text(const std::optional<std::uint64_t>& value)
    -> std::string {
  if (!value) {
    return "-";
  }
  return std::to_string(*value) + "%";
}
 
inline auto optional_text(const std::optional<std::uint16_t>& value)
    -> std::string {
  if (!value) {
    return "-";
  }
  std::ostringstream out;
  out << "0x" << std::hex << *value;
  return out.str();
}
 
// Консольная модель: политика двери/аэрации/тест-платы поверх шины —
// подключение живёт в UiApp (см. ConsoleUi::exec()), здесь только вызовы
// методов UiBusClient (UiBusClient.hpp) напрямую на m_bus_/m_runtime_.
// Вынесена из ConsoleUi.cpp в собственный заголовок (была в анонимном
// namespace, видна только этому единственному .cpp) специально для того,
// чтобы её можно было собрать напрямую в GTest поверх того же
// BusFixture, что уже использует LacteApp/tests/UiBusTest.cpp - без
// терминала/клавиатуры ConsoleModel не знает вообще ничего о вводе-
// выводе, вся эта логика (TerminalRawMode/read_key/run_console_ansi)
// осталась в ConsoleUi.cpp.
//
// Действия сериализованы через m_mutex_ - методы вызываются из основного
// цикла run_console_ansi() (ConsoleUi.cpp) либо напрямую из теста,
// синхронизация нужна на случай, если этот класс когда-нибудь снова
// будет опрашиваться из отдельного потока.
class ConsoleModel {
 public:
  struct DisplayState {
    bool ui_enabled{false};
    bool door_open{false};
    bool last_health{false};
    bool board_online{false};
    bool has_snapshot{false};
    int aeration{0};
    std::string app_version{"-"};
    std::string fw_version{"-"};
    std::string milk_system_sn{"-"};
    std::string expiry_date{"-"};
    std::string remaining{"-"};
    std::string errors{"-"};
    std::string status;
    // Совмещённое состояние системы (online lacte-платы + HMI-сигнал
    // двери, см. lacte::SystemState/SystemStateResolver в SystemState.hpp
    // и BoardSnapshot::system_state) - "door_open"/"normal"/
    // "board_disconnected"/"board_not_installed", либо "-" у снапшота,
    // построенного версией до появления этого поля.
    std::string system_state{"-"};
  };
 
  // Стандартный таймаут туда-обратно для обычных вызовов шины этой модели
  // (health/snapshot/param get-set) - достаточно короткий, чтобы консольный
  // UI никогда не казался зависшим в ожидании недоступной платы.
  static constexpr auto K_BUS_OP_TIMEOUT = std::chrono::milliseconds(300);
  // Нескольким операциям (переключение платы online/offline, явное
  // сохранение аэрации) даётся чуть больше запаса - это осознанные, редкие
  // действия пользователя, а не непрерывный ритм
  // poll_health()/refresh_snapshot().
  static constexpr auto K_BUS_SLOW_OP_TIMEOUT = std::chrono::milliseconds(500);
  static constexpr int K_MAX_AERATION_PERCENT = 100;
 
  // Управляет client/runtime, которыми владеет и которые подключила база
  // UiApp; консоль добавляет поверх только свою политику
  // двери/аэрации/статуса.
  ConsoleModel(bus::UiBusClient& bus, bus::UiRuntime& runtime)
      : m_bus_(bus), m_runtime_(runtime) {}
 
  void poll_health() {
    std::scoped_lock lock(m_mutex_);
    m_last_health_ = m_bus_.check_health(m_runtime_, K_BUS_OP_TIMEOUT);
    if (!m_last_health_) {
      m_runtime_.set_enabled(false);
    }
  }
 
  // Периодический опрос: обновляет поля снапшота, но НЕ трогает аэрацию —
  // иначе фоновый поток каждую секунду затирает локальную позицию слайдера.
  // Аэрация синхронизируется с backend только явно: открытие двери,
  // кнопка Refresh, переключение платы.
  void refresh_snapshot() {
    std::scoped_lock lock(m_mutex_);
    if (const auto snapshot = m_bus_.get_snapshot(K_BUS_OP_TIMEOUT)) {
      m_runtime_.apply_snapshot(*snapshot);
    }
  }
 
  void refresh_snapshot_with_aeration() {
    std::scoped_lock lock(m_mutex_);
    if (const auto snapshot = m_bus_.get_snapshot(K_BUS_OP_TIMEOUT)) {
      m_runtime_.apply_snapshot(*snapshot);
      m_runtime_.set_aeration(snapshot->aeration);
    }
  }
 
  void open_door() {
    std::scoped_lock lock(m_mutex_);
    m_door_open_ = true;
    poll_health();
    if (!m_last_health_) {
      m_status_ = "door open ignored: lacte board is offline";
      return;
    }
 
    if (const auto aeration =
            m_bus_.get_param(bus::K_PARAM_AERATION, K_BUS_OP_TIMEOUT)) {
      m_runtime_.set_aeration(*aeration);
    }
    m_runtime_.set_enabled(true);
    m_status_ = "door opened: ui enabled";
  }
 
  void close_door() {
    std::scoped_lock lock(m_mutex_);
    m_door_open_ = false;
    if (m_runtime_.enabled()) {
      m_bus_.set_param(bus::K_PARAM_AERATION, m_runtime_.aeration(),
                       K_BUS_OP_TIMEOUT);
    }
    m_runtime_.set_enabled(false);
    m_status_ = "door closed: ui disabled";
  }
 
  void toggle_door() { m_door_open_ ? close_door() : open_door(); }
 
  void toggle_board() {
    std::scoped_lock lock(m_mutex_);
    m_requested_board_online_ = !m_requested_board_online_;
    if (m_bus_.set_test_board_online(m_requested_board_online_,
                                     K_BUS_SLOW_OP_TIMEOUT)) {
      m_status_ = m_requested_board_online_ ? "test board connected"
                                            : "test board disconnected";
    } else {
      m_status_ = "board toggle is available only with virtual backend";
    }
    poll_health();
    refresh_snapshot_with_aeration();
  }
 
  void set_aeration(const int value) {
    std::scoped_lock lock(m_mutex_);
    m_runtime_.set_aeration(std::clamp(value, 0, K_MAX_AERATION_PERCENT));
    m_status_ = "aeration changed locally";
  }
 
  void adjust_aeration(const int delta) { set_aeration(aeration() + delta); }
 
  void save_aeration() {
    std::scoped_lock lock(m_mutex_);
    m_bus_.set_param(bus::K_PARAM_AERATION, m_runtime_.aeration(),
                     K_BUS_SLOW_OP_TIMEOUT);
    m_status_ = "aeration sent to backend";
  }
 
  void refresh() {
    std::scoped_lock lock(m_mutex_);
    poll_health();
    refresh_snapshot_with_aeration();
    m_status_ = "snapshot refreshed";
  }
 
  void shutdown() {
    std::scoped_lock lock(m_mutex_);
    m_runtime_.set_enabled(false);
  }
 
  [[nodiscard]] auto aeration() -> int {
    std::scoped_lock lock(m_mutex_);
    return m_runtime_.aeration();
  }
 
  // Быстрый снимок всего отображаемого состояния под одним замком — рендер
  // копирует его и дальше строит вид без удержания m_mutex_.
  [[nodiscard]] auto snapshot() -> DisplayState {
    std::scoped_lock lock(m_mutex_);
    DisplayState state;
    state.ui_enabled = m_runtime_.enabled();
    state.door_open = m_door_open_;
    state.last_health = m_last_health_;
    state.aeration = m_runtime_.aeration();
    state.status = m_status_;
    if (const auto snapshot = m_runtime_.last_snapshot()) {
      state.has_snapshot = true;
      state.board_online = snapshot->board_online;
      state.app_version = snapshot->app_version;
      state.fw_version = snapshot->fw_version;
      state.milk_system_sn = snapshot->milk_system_sn;
      state.expiry_date = snapshot->expiry_date;
      state.remaining = optional_text(snapshot->remaining_percent);
      state.errors = optional_text(snapshot->error_flags);
      if (!snapshot->system_state.empty()) {
        state.system_state = snapshot->system_state;
      }
    }
    return state;
  }
 
 private:
  std::recursive_mutex m_mutex_;
  bus::UiBusClient& m_bus_;
  bus::UiRuntime& m_runtime_;
  bool m_door_open_{false};
  bool m_requested_board_online_{true};
  bool m_last_health_{false};
  std::string m_status_{"connected"};
};
 
}  // namespace lacte::ui