// #include <iostream>
// #include <vector>
// #include <memory>
// #include <mutex>
// #include <algorithm>
// #include <unordered_map>
// #include <functional>

// // ==================== 观察者接口 ====================
// class IObserver {
// public:
//     virtual ~IObserver() = default;
//     virtual void update(const std::string& eventType, void* data) = 0;  //
//     支持事件类型区分
// };

// // ==================== 主题基类 (线程安全) ====================
// class Observable {
// public:
//     virtual ~Observable() = default;

//     // 注册观察者（支持事件类型过滤）
//     void addObserver(const std::string& eventType, std::weak_ptr<IObserver>
//     observer) {
//         std::lock_guard<std::mutex> lock(mtx_);
//         observers_[eventType].push_back(observer);
//     }

//     // 移除观察者
//     void removeObserver(std::weak_ptr<IObserver> target) {
//         std::lock_guard<std::mutex> lock(mtx_);
//         for (auto& [type, list] : observers_) {
//             list.erase(
//                 std::remove_if(list.begin(), list.end(),
//                     [&](const auto& weakObserver) {
//                         if (auto observer = weakObserver.lock()) {
//                             return observer == target.lock();
//                         }
//                         return false;  // 自动清理失效指针
//                     }),
//                 list.end()
//             );
//         }
//     }

// protected:
//     // 通知特定事件类型的所有观察者（推模型）
//     void notify(const std::string& eventType, void* data = nullptr) {
//         std::vector<std::weak_ptr<IObserver>> toNotify;
//         {
//             std::lock_guard<std::mutex> lock(mtx_);
//             if (observers_.find(eventType) != observers_.end()) {
//                 toNotify = observers_[eventType];
//             }
//         }

//         // 遍历通知（自动清理失效观察者）
//         auto it = toNotify.begin();
//         while (it != toNotify.end()) {
//             if (auto observer = it->lock()) {
//                 observer->update(eventType, data);
//                 ++it;
//             } else {
//                 it = toNotify.erase(it);
//             }
//         }
//     }

// private:
//     std::unordered_map<std::string, std::vector<std::weak_ptr<IObserver>>>
//     observers_; mutable std::mutex mtx_;
// };

// // ==================== 具体主题：温度传感器 ====================
// class TemperatureSensor : public Observable {
// public:
//     void setTemperature(float temp) {
//         temperature_ = temp;
//         notify("TEMP_UPDATE", &temperature_);  // 推模型传递数据
//     }

//     // 拉模型支持
//     float getTemperature() const { return temperature_; }

// private:
//     float temperature_ = 0.0f;
// };

// // ==================== 具体观察者：显示设备 ====================
// class DisplayDevice : public IObserver, public
// std::enable_shared_from_this<DisplayDevice> { public:
//     explicit DisplayDevice(const std::string& name) : name_(name) {}

//     void subscribeTo(Observable& subject, const std::string& eventType) {
//         subject.addObserver(eventType, weak_from_this());
//     }

//     void update(const std::string& eventType, void* data) override {
//         if (eventType == "TEMP_UPDATE") {
//             float* temp = static_cast<float*>(data);
//             std::cout << "[" << name_ << "] 温度更新: " << *temp << "°C\n";
//         }
//     }

// private:
//     std::string name_;
// };

// // ==================== 具体观察者：报警器（拉模型示例）====================
// class TemperatureAlarm : public IObserver, public
// std::enable_shared_from_this<TemperatureAlarm> { public:
//     explicit TemperatureAlarm(float threshold) : threshold_(threshold) {}

//     void subscribeTo(TemperatureSensor& sensor) {
//         sensor.addObserver("TEMP_UPDATE", weak_from_this());
//     }

//     void update(const std::string& eventType, void* data) override {
//         if (eventType == "TEMP_UPDATE") {
//             // 拉模型示例：主动从主题获取数据
//             TemperatureSensor* sensor =
//             static_cast<TemperatureSensor*>(data); if
//             (sensor->getTemperature() > threshold_) {
//                 std::cout << "! 警报 ! 温度超过阈值: " << threshold_ <<
//                 "°C\n";
//             }
//         }
//     }

// private:
//     float threshold_;
// };

// // ==================== 主函数 ====================
// int main() {
//     // 创建主题
//     TemperatureSensor sensor;

//     // 创建观察者（使用智能指针）
//     auto display1 = std::make_shared<DisplayDevice>("主控屏");
//     auto display2 = std::make_shared<DisplayDevice>("备用屏");
//     auto alarm = std::make_shared<TemperatureAlarm>(35.0f);

//     // 注册观察者
//     display1->subscribeTo(sensor, "TEMP_UPDATE");
//     display2->subscribeTo(sensor, "TEMP_UPDATE");
//     alarm->subscribeTo(sensor);

//     // 模拟温度变化
//     std::cout << "---- 第一次更新 ----\n";
//     sensor.setTemperature(25.5f);

//     std::cout << "\n---- 第二次更新 ----\n";
//     sensor.setTemperature(37.2f);  // 触发警报

//     // 动态移除观察者
//     sensor.removeObserver(std::weak_ptr<IObserver>(display2));
//     std::cout << "\n---- 第三次更新（移除备用屏后）----\n";
//     sensor.setTemperature(38.0f);

//     return 0;
// }

// #include <model/Model2SliceI.h>
// #include <Ice/Ice.h>
// #include <Ice/OutputStream.h>
// #include <Ice/Proxy.h>
// #include <arpa/inet.h>
// #include <dirent.h>
// #include <log4cplus/LOG.h>
// #include <map>
// #include <pace/P99Component.h>
// #include <pace/pace.h>
// #include <string>
// #include <sys/stat.h>
// #include <vector>
// //#include "UDT1.h"
// //#include <boost/type_index.hpp>
// #include "incFileName.h"
// #include <cstdlib>
// #include <ctime>
// //#include "STD/UDT_1.h"

// using namespace iPlature;

// namespace iPlature {
// class EventCallBck : public virtual EventReceiverI {
// public:
//   EventCallBck() {}
//   ~EventCallBck() {}

//   virtual void recvCallBack(const ::Ice::StringSeq &tagNames,
//                             const ::AP::ByteSeqSeq &tagValues,
//                             const Ice::Current &current) {
//     LOG log("recvCallBack");

//     //	STD::DSC_MTR::MTR ab;
//     short ab = 0;
//     for (int i = 0; i < tagNames.size(); i++) {
//       log.Info() << "tagName = " << tagNames.at(i) << endl;
//     }
//     for (int i = 0; i < tagValues.size(); i++) {

//       log.DebugHex((void *)&tagValues.at(i).front(),
//                    (int)tagValues.at(i).size());

//       memset(&ab, 0, tagValues.at(i).size());
//       memcpy(&ab, &tagValues.at(i).front(), sizeof(2));
//     }
//   }
// };
// } // namespace iPlature

// using namespace iPlature;
// using namespace std;

// class EventReceiverComponent : public Component {
// public:
//   virtual int start() {
//     // 创建日志对象
//     LOG log("EventReceiverMain");

//     // 创建指针
//     ptr = new iPlature::EventCallBck();
//     std::cout << "ptr" << ptr << endl;

//     // 添加指针
//     this->add("iPlature/EventCallBck", ptr);
//     log.Info() << "add ok " << endl;
//     DRSdkConnectParam con;

//     // con.szServerIp = "10.25.101.165";
//     // con.nServerPort =10087 ;
//     con.szServerIp = "192.168.0.12";
//     con.nServerPort = 1234;
//     con.szServerIpBak = "192.168.0.13";
//     con.nServerPortBak = 1234;
//     con.flag = 1;
//     con.nConnectTimeoutMs = 1000;
//     con.nHeartbeatTimeoutMs = 3000;
//     DRSdkOption op;
//     op.nThreadPoolNum = 10;
//     op.nRequestWaitTimeoutMs = 1000;

//     const ::Ice::Current &current = ::Ice::emptyCurrent;
//     //初始化连接
//     ptr->Init(con, op, current);
//     log.Info() << "Init ok " << endl;
//     ::AP::ByteSeqSeq seq;

//     //		STD::MTR ab;

//     //		STD::DSC_MTR::MTR er;
//     //		log.Debug() << "er size" << sizeof(er) << endl;

//     // DSF Name ： STD.DSC_MTR::MTR
//     // C++ Name ： STD::DSC_MTR::MTR
//     std::string objName = "STD::DSC_MTR::MTR";

//     Ice::StringSeq ss;
//     ss.push_back("STD::TEST1");
//     ss.push_back("STD::TEST2");
//     ss.push_back("STD::TEST3");
//     ss.push_back("STD::TEST4");
//     ss.push_back("STD::TEST5");
//     //		ss.push_back(objName);
//     //ͬ同步读
//     seq = ptr->readData(ss, current);
//     log.Debug() << "readData" << endl;
//     short a = 0;
//     for (int i = 0; i < seq.size(); i++) {
//       ::Ice::ByteSeq sq(sizeof(seq.at(i).size()));
//       sq = seq.at(i);
//       log.DebugHex((void *)&sq.front(), (int)sq.size());
//       memcpy(&a, (void *)&sq.front(), 2);
//       std::cout << "a = " << a << endl;
//     }

//     std::cout << "seq size = " << seq.size() << endl;
//     log.Debug() << "seq size = " << seq.size() << endl;

//     //		::Ice::ByteSeq sq(sizeof(STD::DSC_MTR::MTR));
//     // memcpy((void*)&sq.front(),&er,sizeof(STD::DSC_MTR::MTR));
//     //		std::cout << "sizeof(STD::DSC_MTR::MTR) =
//     "<<sizeof(STD::DSC_MTR::MTR)
//     //<< endl;

//     //异步读
//     ss.clear();
//     //		ss.push_back("STD::DSC_MTR::MTR");
//     ss.push_back("STD::TEST1");
//     ss.push_back("STD::TEST2");
//     ss.push_back("STD::TEST3");
//     ss.push_back("STD::TEST4");
//     ss.push_back("STD::TEST5");

//     int batchid = ptr->regist(ss, 100, current);

//     //		short
//     a = 5;

//     ::AP::ByteSeqSeq tagValues;
//     ::Ice::ByteSeq sq1; //(sizeof(aa.O_HMI_STAT_RDY));

//     //		STD::DSC_MTR::MTR ee;
//     int count = 0;
//     std::srand(static_cast<unsigned int>(std::time(0))); // Seed for
//     randomness while (1) {
//       a += count + 1;
//       ss.clear();
//       tagValues.clear();
//       sq1.clear();
//       a = static_cast<short>(rand()) / 1000;
//       sq1.resize(2);
//       memcpy((void *)&sq1.front(), &a, 2);
//       tagValues.push_back(sq1);
//       sq1.clear();
//       sq1.resize(2);
//       memcpy((void *)&sq1.front(), &a, 2);
//       tagValues.push_back(sq1);
//       sq1.clear();
//       sq1.resize(2);
//       memcpy((void *)&sq1.front(), &a, 2);
//       tagValues.push_back(sq1);
//       sq1.clear();
//       sq1.resize(2);
//       memcpy((void *)&sq1.front(), &a, 2);
//       tagValues.push_back(sq1);
//       sq1.clear();
//       sq1.resize(2);
//       memcpy((void *)&sq1.front(), &a, 2);
//       tagValues.push_back(sq1);
//       sq1.clear();
//       ss.clear();
//       ss.push_back("STD::TEST1");
//       ss.push_back("STD::TEST2");
//       ss.push_back("STD::TEST3");
//       ss.push_back("STD::TEST4");
//       ss.push_back("STD::TEST5");

//       log.Debug() << "tagValues size = " << tagValues.size() << endl;
//       //下发
//       int b = ptr->setControlData(ss, tagValues, 5, current);
//       log.Info() << "setControlData ok  b = " << b << endl;
//       log.Info() << "1111" << endl;
//       sleep(1);
//       count++;
//     }

//     std::cout << "setControlData ok  " << endl;
//   }

// private:
//   iPlature::EventCallBck *ptr;
// };

// PACE_SERVER_INSTALL(EventReceiverComponent)

// #include "exp_extract.hpp"
// #include "mix_cc/ihyper_db.h"
// #include "mix_cc/json.h"
// #include "mix_cc/matheval/matheval.hpp"
// #include <iomanip>
// #include <iostream>
// #include <map>
// #include <memory>
// #include <string>

// int main() {

//   std::map<std::string, double> mm_vars;
//   mm_vars["tag1"] = 0;
//   std::string exp_str = "ln(3)";
//   // std::string exp_str = "XOR(0,0)";
//   std::unique_ptr<mix_cc::matheval::Expression> exp_ptr =
//       std::make_unique<mix_cc::matheval::Expression>(exp_str, &mm_vars);
//   std::cout << "tag1:" << mm_vars["tag1"] << ",exp str:" << exp_str
//             << ",exp value:" << exp_ptr->evaluate() << std::endl;

// }

// #include <regex>
// #include <string>
// #include <iostream>

// int extractCTaskNumberRegex(const std::string& input) {
//     std::regex pattern(R"(_(\d+)_task$)");
//     std::smatch matches;

//     if (std::regex_search(input, matches, pattern)) {
//         if (matches.size() > 1) {  // 索引0是完整匹配，索引1是第一个捕获组
//             try {
//                 return std::stoi(matches[1].str());
//             } catch (...) {
//                 return 0;
//             }
//         }
//     }

//     return 0;
// }

// // 增强版，可以匹配更多情况
// int extractCTaskNumberRegexEnhanced(const std::string& input) {
//     // 匹配任意字符串中的最后一个数字（该数字后面跟下划线和"task"）
//     std::regex pattern(R"((\d+)(?=_task$))");
//     std::smatch matches;

//     if (std::regex_search(input, matches, pattern)) {
//         try {
//             return std::stoi(matches[1].str());
//         } catch (...) {
//             return 0;
//         }
//     }

//     return 0;
// }

// // 或者更通用的版本，提取最后一个数字部分
// int extractCTaskNumberRegexGeneric(const std::string& input) {
//     // 匹配任意位置的数字部分，但通过贪婪匹配获取最后一个
//     std::regex pattern(R"((\d+))");
//     std::sregex_iterator begin(input.begin(), input.end(), pattern);
//     std::sregex_iterator end;

//     std::string lastMatch;
//     for (auto it = begin; it != end; ++it) {
//         lastMatch = (*it)[1].str();
//     }

//     if (!lastMatch.empty()) {
//         try {
//             return std::stoi(lastMatch);
//         } catch (...) {
//             return 0;
//         }
//     }

//     return 0;
// }

// int main() {
//     std::string test1 = "12_4_5_task";
//     std::string test2 = "a_b_123_task";
//     std::string test3 = "test_45_678_task";

//     std::cout << extractCTaskNumberRegex(test1) << std::endl;       // 输出:
//     5 std::cout << extractCTaskNumberRegexEnhanced(test1) << std::endl; //
//     输出: 5 std::cout << extractCTaskNumberRegexGeneric(test1) << std::endl;
//     // 输出: 5

//     std::cout << extractCTaskNumberRegex(test2) << std::endl;       // 输出:
//     123 std::cout << extractCTaskNumberRegexGeneric(test3) << std::endl; //
//     输出: 678

//     return 0;
// }

// #include "VarsCache.hpp"
// #include <iostream>
// #include <string>
// #include <vector>
// using std::cout;
// using std::endl;
// using std::string;
// using std::vector;
// int main() {
//   vector<string> m_tag = {"tag1", "tag2", "tag3", "tag5"};

//   VarsCache var_cache;
//   var_cache.init(5, 30);
//   cout << var_cache.dumps() << std::endl;
//   return 0;
// }

// #include <chrono>
// #include <ctime>
// #include <iomanip> // 对于 std::setfill 和 std::setw
// #include <iostream>
// #include <sstream> // 对于 std::stringstream
// #include <thread>

// // 方案1：使用CLOCK_MONOTONIC_RAW（不受NTP和VMware调整）
// class MonotonicRawClock {
// public:
//   using duration = std::chrono::nanoseconds;
//   using rep = duration::rep;
//   using period = duration::period;
//   using time_point = std::chrono::time_point<MonotonicRawClock>;

//   static constexpr bool is_steady = true;

//   static time_point now() noexcept {
//     timespec ts;
//     // CLOCK_MONOTONIC_RAW基于硬件TSC，不受时间同步影响
//     clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
//     return time_point(std::chrono::seconds(ts.tv_sec) +
//                       std::chrono::nanoseconds(ts.tv_nsec));
//   }
// };

// // 方案2：混合时钟，检测并补偿跳跃
// class RobustTimer {
// private:
//   using SteadyClock = std::chrono::steady_clock;
//   using SystemClock = std::chrono::system_clock;

//   SteadyClock::time_point last_steady_;
//   SystemClock::time_point last_system_;
//   double estimated_drift_;

// public:
//   RobustTimer() : estimated_drift_(0.0) {
//     last_steady_ = SteadyClock::now();
//     last_system_ = SystemClock::now();
//   }

//   // 获取经过的时间，自动补偿跳跃
//   double elapsed_seconds() {
//     auto now_steady = SteadyClock::now();
//     auto now_system = SystemClock::now();

//     auto steady_diff =
//         std::chrono::duration<double>(now_steady - last_steady_).count();
//     auto system_diff =
//         std::chrono::duration<double>(now_system - last_system_).count();

//     // 检测跳跃（差异超过10ms）
//     if (std::abs(steady_diff - system_diff) > 0.01) {
//       std::cerr << "检测到时间跳跃: " << (steady_diff - system_diff) * 1000
//                 << "ms" << std::endl;

//       // 使用steady_clock，但记录跳跃
//       estimated_drift_ += system_diff - steady_diff;
//     }

//     last_steady_ = now_steady;
//     last_system_ = now_system;

//     return steady_diff + estimated_drift_;
//   }
// };

// // 辅助函数：格式化当前系统时间
// std::string current_time_string(bool with_ms = true) {
//   auto now = std::chrono::system_clock::now();
//   auto time_t_now = std::chrono::system_clock::to_time_t(now);
//   std::tm tm_buf;
//   localtime_r(&time_t_now, &tm_buf);

//   char buffer[80];
//   strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &tm_buf);

//   std::stringstream ss;
//   ss << buffer;

//   if (with_ms) {
//     auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
//                   now.time_since_epoch()) %
//               1000;
//     ss << "." << std::setfill('0') << std::setw(3) << ms.count();
//   }

//   return ss.str();
// }

// int main() {
//   // 使用MonotonicRawClock
//   auto start = MonotonicRawClock::now();

//   RobustTimer timer;
//   double total_elapsed = 0.0;

//   while (total_elapsed < 3600.0) { // 运行1小时
//     // 你的业务逻辑

//     // 获取经过的时间
//     double elapsed = timer.elapsed_seconds();
//     total_elapsed += elapsed;
//     std::cout << current_time_string(true) << "|总运行时间: " <<
//     total_elapsed
//               << "s, 本次间隔: " << elapsed << "s" << std::endl;

//     // 精确等待50ms
//     auto target =
//         start + std::chrono::duration_cast<MonotonicRawClock::duration>(
//                     std::chrono::duration<double>(total_elapsed + 0.05));

//     while (MonotonicRawClock::now() < target) {
//       // 忙等待，更高精度
//     }
//   }

//   return 0;
// }

// #include <chrono>
// #include <ctime>
// #include <iomanip> // 对于 std::setfill 和 std::setw
// #include <iostream>
// #include <sstream> // 对于 std::stringstream
// #include <thread>
// // 辅助函数：格式化当前系统时间
// std::string current_time_string(bool with_ms = true) {
//   auto now = std::chrono::system_clock::now();
//   auto time_t_now = std::chrono::system_clock::to_time_t(now);
//   std::tm tm_buf;
//   localtime_r(&time_t_now, &tm_buf);

//   char buffer[80];
//   strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &tm_buf);

//   std::stringstream ss;
//   ss << buffer;

//   if (with_ms) {
//     auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
//                   now.time_since_epoch()) %
//               1000;
//     ss << "." << std::setfill('0') << std::setw(3) << ms.count();
//   }

//   return ss.str();
// }

// int main() {
//   // 1. 检查标准库是否把 steady_clock 声明为单调的
//   std::cout << "is_steady: " << std::chrono::steady_clock::is_steady
//             << std::endl;
//   // 2. 测试差值是否跳变
//   auto start = std::chrono::steady_clock::now();
//   std::this_thread::sleep_for(std::chrono::seconds(2)); //
//   等待系统时间跳变发生 auto end = std::chrono::steady_clock::now(); auto
//   duration =
//       std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
//   std::cout << current_time_string(true) << "|耗时: " << duration.count()
//             << " ms" << std::endl;
//   return 0;
// }

// // 检查你的系统如何实现 steady_clock
// #include <iostream>
// #include <chrono>

// int main() {
//     auto start = std::chrono::steady_clock::now();

//     // 检查 steady_clock 的底层实现
//     std::cout << "steady_clock is_steady: " <<
//     std::chrono::steady_clock::is_steady << std::endl;

//     // 对比实现
//     struct timespec ts;
//     clock_gettime(CLOCK_MONOTONIC, &ts);

//     auto t1 = std::chrono::steady_clock::now();
//     auto t2 = std::chrono::time_point<std::chrono::steady_clock>(
//         std::chrono::nanoseconds(ts.tv_sec * 1000000000LL + ts.tv_nsec)
//     );

//     std::cout << "Diff: " <<
//     std::chrono::duration_cast<std::chrono::nanoseconds>(t1 - t2).count() <<
//     " ns" << stdendl;

//     return 0;
// }

#include <chrono>
#include <iostream>
#include <optional>

// 报警信息结构
struct AlarmInfo {
  enum Type { None, Alarm, Timeout } type;
  std::string message;
};

// 状态机类
class ExprMonitorSM {
public:
  // 构造函数
  // hold_mode: 动作表达式是否需要保持为真
  // timeout: 超时时间（0 表示无超时）
  ExprMonitorSM(bool hold_mode, std::chrono::milliseconds timeout =
                                    std::chrono::milliseconds::zero())
      : hold_mode_(hold_mode), timeout_(timeout), state_(State::Idle) {}

  // 重置状态机（清除所有内部状态）
  void reset() {
    state_ = State::Idle;
    act_trigger_time_ = std::chrono::steady_clock::time_point();
  }

  // 每个周期调用一次，更新表达式值并获取报警信息
  // act: 动作表达式结果
  // fb:  反馈表达式结果
  // mon: 监控表达式结果
  // now: 当前时间（可选，便于测试）
  std::optional<AlarmInfo> update(bool act, bool fb, bool mon,
                                  std::chrono::steady_clock::time_point now =
                                      std::chrono::steady_clock::now()) {
    // 超时检测（仅当不在空闲状态时）
    if (state_ != State::Idle && timeout_.count() > 0) {
      if (now - act_trigger_time_ >= timeout_) {
        reset();
        return AlarmInfo{AlarmInfo::Timeout, "动作触发后超时未收到反馈"};
      }
    }

    switch (state_) {
    case State::Idle:
      if (act) {
        // 动作触发，记录触发时间
        act_trigger_time_ = now;
        // 根据是否保持进入不同状态
        state_ = hold_mode_ ? State::HoldActive : State::WaitForFeedback;

        // 注意：同一周期内如果立即满足反馈和监控，继续处理（不会递归，只是走下面的分支）
        // 由于状态已改变，下面会根据新状态再次判断 fb / mon
      }
      break;

    case State::WaitForFeedback:
      // 非保持模式：不再关心 act，只等待反馈或超时
      if (fb) {
        // 反馈到达，重置触发状态
        reset();
        // 反馈后检查监控表达式
        if (mon) {
          return AlarmInfo{AlarmInfo::Alarm, "监控条件满足（反馈后）"};
        }
      }
      break;

    case State::HoldActive:
      // 保持模式：必须检查 act 是否仍为真
      if (!act) {
        // 动作条件不再满足，清除触发状态
        reset();
      } else {
        // act 保持为真，检查反馈
        if (fb) {
          // 反馈到达，重置触发状态
          reset();
          if (mon) {
            return AlarmInfo{AlarmInfo::Alarm,
                             "监控条件满足（保持模式下反馈后）"};
          }
        }
      }
      break;
    }

    return std::nullopt; // 无报警
  }

private:
  enum class State { Idle, WaitForFeedback, HoldActive };

  bool hold_mode_;                                         // 是否保持模式
  std::chrono::milliseconds timeout_;                      // 超时时间
  State state_;                                            // 当前状态
  std::chrono::steady_clock::time_point act_trigger_time_; // 动作触发的时间点
};

// ------------------------- 简单测试 -------------------------
#include <cassert>
#include <thread>

void test_non_hold_normal() {
  std::cout
      << "\n=== 测试：非保持模式，正常流程（动作触发 → 反馈 → 监控真）===\n";
  ExprMonitorSM sm(false, std::chrono::milliseconds(5000));

  // 第1周期：动作触发
  auto alarm = sm.update(true, false, false);
  assert(!alarm.has_value());

  // 第2周期：反馈到达，监控为真
  alarm = sm.update(false, true, true);
  assert(alarm.has_value() && alarm->type == AlarmInfo::Alarm);
  std::cout << "报警信息: " << alarm->message << std::endl;

  // 状态应已重置，再次触发
  alarm = sm.update(true, false, false);
  assert(!alarm.has_value());
}

void test_non_hold_timeout() {
  std::cout << "\n=== 测试：非保持模式，超时未反馈 ===\n";
  ExprMonitorSM sm(false, std::chrono::milliseconds(200));

  auto now = std::chrono::steady_clock::now();
  // 动作触发
  auto alarm = sm.update(true, false, false, now);
  assert(!alarm.has_value());

  // 模拟超时（过去 300ms）
  auto later = now + std::chrono::milliseconds(300);
  alarm = sm.update(false, false, false, later);
  assert(alarm.has_value() && alarm->type == AlarmInfo::Timeout);
  std::cout << "报警信息: " << alarm->message << std::endl;
}

void test_hold_normal() {
  std::cout << "\n=== 测试：保持模式，动作持续为真 → 反馈 → 监控真 ===\n";
  ExprMonitorSM sm(true, std::chrono::milliseconds(5000));

  // 第1周期：动作触发
  auto alarm = sm.update(true, false, false);
  assert(!alarm.has_value());

  // 第2周期：动作仍为真，反馈为真，监控为真
  alarm = sm.update(true, true, true);
  assert(alarm.has_value() && alarm->type == AlarmInfo::Alarm);
  std::cout << "报警信息: " << alarm->message << std::endl;
}

void test_hold_act_false() {
  std::cout << "\n=== 测试：保持模式，动作中途变假，无反馈 ===\n";
  ExprMonitorSM sm(true, std::chrono::milliseconds(5000));

  // 动作触发
  auto alarm = sm.update(true, false, false);
  assert(!alarm.has_value());

  // 动作变假，状态应退回空闲，不会报警
  alarm = sm.update(false, false, false);
  assert(!alarm.has_value());

  // 重新触发
  alarm = sm.update(true, false, false);
  assert(!alarm.has_value());
}

void test_hold_timeout() {
  std::cout << "\n=== 测试：保持模式，动作持续为真但超时未反馈 ===\n";
  ExprMonitorSM sm(true, std::chrono::milliseconds(200));

  auto now = std::chrono::steady_clock::now();
  // 动作触发
  auto alarm = sm.update(true, false, false, now);
  assert(!alarm.has_value());

  // 动作保持为真，但超过超时时间
  auto later = now + std::chrono::milliseconds(300);
  alarm = sm.update(true, false, false, later);
  assert(alarm.has_value() && alarm->type == AlarmInfo::Timeout);
  std::cout << "报警信息: " << alarm->message << std::endl;
}

void test_feedback_without_mon() {
  std::cout << "\n=== 测试：反馈为真但监控为假，不报警 ===\n";
  ExprMonitorSM sm(false, std::chrono::milliseconds(5000));

  // 动作触发
  auto alarm = sm.update(true, false, false);
  assert(!alarm.has_value());

  // 反馈为真，监控为假 → 不报警，但状态重置
  alarm = sm.update(false, true, false);
  assert(!alarm.has_value());

  // 可以再次触发动作
  alarm = sm.update(true, false, false);
  assert(!alarm.has_value());
}

int main() {
  test_non_hold_normal();
  test_non_hold_timeout();
  test_hold_normal();
  test_hold_act_false();
  test_hold_timeout();
  test_feedback_without_mon();
  std::cout << "\n所有测试通过！\n";
  return 0;
}