secs-gem/include/secsgem/gem/store/equipment_constants.hpp

#pragma once

#include <cstdint>
#include <functional>
#include <map>
#include <optional>
#include <stdexcept>
#include <string>
#include <utility>
#include <variant>
#include <vector>

#include "secsgem/gem/handler_slot.hpp"
#include "secsgem/secs2/item.hpp"

namespace secsgem::gem {

namespace s2 = secsgem::secs2;

struct EquipmentConstant {
  uint32_t id;
  std::string name;
  std::string units;
  s2::Item value;
  s2::Item def_value;
  std::string min_str;  // bounds for S2F30 + EAC validation; "" disables check
  std::string max_str;
};

// S2F16 EAC per SEMI E5: 0=OK, 1=one or more constants does not exist,
// 2=busy, 3=one or more values out of range. Values 4-127 are reserved.
enum class EquipmentAck : uint8_t {
  Accept = 0,
  Denied_UnknownEcid = 1,
  Denied_Busy = 2,
  Denied_OutOfRange = 3,
};

class EquipmentConstantStore {
 public:
  void add(EquipmentConstant ec) { by_id_.insert_or_assign(ec.id, std::move(ec)); }
  std::optional<EquipmentConstant> get(uint32_t id) const {
    auto it = by_id_.find(id);
    if (it == by_id_.end()) return std::nullopt;
    return it->second;
  }
  std::vector<EquipmentConstant> all() const {
    std::vector<EquipmentConstant> out;
    out.reserve(by_id_.size());
    for (const auto& [_, ec] : by_id_) out.push_back(ec);
    return out;
  }
  bool has(uint32_t id) const { return by_id_.count(id) > 0; }

  // Validates against min/max for numeric formats (only when min_str and
  // max_str parse cleanly).  Returns Denied_UnknownEcid / Denied_OutOfRange
  // per S2F16 EAC.  This is the rule that closes the docs/COMPLIANCE.md gap
  // about "EC range validation against min/max".
  EquipmentAck set_value(uint32_t id, s2::Item value) {
    auto it = by_id_.find(id);
    if (it == by_id_.end()) return EquipmentAck::Denied_UnknownEcid;
    if (!in_range(it->second, value)) return EquipmentAck::Denied_OutOfRange;
    it->second.value = std::move(value);
    if (on_changed_) on_changed_(id, it->second.value);
    return EquipmentAck::Accept;
  }

  // Observe ACCEPTED host writes (S2F15): fires after the value is stored.
  // The tool reacts to process-parameter tuning; rejected writes don't fire.
  using ChangedHandler = std::function<void(uint32_t, const s2::Item&)>;
  void add_changed_handler(ChangedHandler h) { on_changed_.add(std::move(h)); }

 private:
  HandlerSlot<uint32_t, const s2::Item&> on_changed_;

  // For numeric formats, parse min_str / max_str as integers / doubles and
  // compare against the first value of the array (we don't support setting
  // multi-element ECs in this implementation).
  static bool in_range(const EquipmentConstant& ec, const s2::Item& value) {
    if (ec.min_str.empty() && ec.max_str.empty()) return true;

    auto parse_d = [](const std::string& s, double& out) {
      if (s.empty()) return false;
      try { out = std::stod(s); return true; } catch (...) { return false; }
    };

    double v;
    if (!extract_number(value, v)) return true;  // unknown format: skip

    double lo = -1e300, hi = 1e300;
    parse_d(ec.min_str, lo);
    parse_d(ec.max_str, hi);
    return v >= lo && v <= hi;
  }

  static bool extract_number(const s2::Item& item, double& out) {
    auto first = [&](const auto& v) -> bool {
      if (v.empty()) return false;
      out = static_cast<double>(v.front());
      return true;
    };
    switch (item.format()) {
      case s2::Format::U1: return first(std::get<std::vector<uint8_t>>(item.storage()));
      case s2::Format::U2: return first(std::get<std::vector<uint16_t>>(item.storage()));
      case s2::Format::U4: return first(std::get<std::vector<uint32_t>>(item.storage()));
      case s2::Format::U8: return first(std::get<std::vector<uint64_t>>(item.storage()));
      case s2::Format::I1: return first(std::get<std::vector<int8_t>>(item.storage()));
      case s2::Format::I2: return first(std::get<std::vector<int16_t>>(item.storage()));
      case s2::Format::I4: return first(std::get<std::vector<int32_t>>(item.storage()));
      case s2::Format::I8: return first(std::get<std::vector<int64_t>>(item.storage()));
      case s2::Format::F4: return first(std::get<std::vector<float>>(item.storage()));
      case s2::Format::F8: return first(std::get<std::vector<double>>(item.storage()));
      default: return false;
    }
  }

  std::map<uint32_t, EquipmentConstant> by_id_;
};

}  // namespace secsgem::gem