# ExpressionEngine 统一表达式引擎 — 实现计划

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** 创建统一的 ExpressionEngine 类，消除 ExpBase::fun_vars_ 与 ExpModule::fun_vars_ 的双重存在、删除 is_exp_alg_ 补丁标志、删除 ExpModule 类。

**Architecture:** 新建 ExpressionEngine 集中管理所有表达式注册/求值、变量刷新、FunVars 生命周期。AlgBase 持有唯一实例，所有算法（表达式类和非表达式类）通过统一接口访问。不再需要 is_exp_alg_ 引用传递。

**Tech Stack:** C++20, mix_cc::matheval, StatExp::FunVars, GlobaltemSharedMemory 共享内存, Eigen3

---

## 文件变更清单

| 文件 | 操作 | 职责 |
|------|------|------|
| `eqpalg/utility/expression_engine.h` | **新建** | ExpressionEngine 类声明 |
| `eqpalg/utility/expression_engine.cpp` | **新建** | ExpressionEngine 实现 |
| `eqpalg/test/test_harness.h` | **新建** | 测试宏（复用 RNG 的 harness） |
| `eqpalg/test/test_main.cc` | **新建** | 测试入口 |
| `eqpalg/test/test_expression_engine.cc` | **新建** | ExpressionEngine 单元测试 |
| `eqpalg/alg_base.h` | **修改** | exp_mpdule_ptr_ → expr_engine_，删除 is_exp_alg_ |
| `eqpalg/alg_base.cpp` | **修改** | 适配 ExpressionEngine API |
| `eqpalg/algs/exp_base.h` | **修改** | 删除 fun_vars_/exp_act_/exp_fb_/exp_res_，删除变量刷新方法声明 |
| `eqpalg/algs/exp_base.cpp` | **修改** | 适配 ExpressionEngine，删除重复代码 |
| `eqpalg/algs/glitch_detection.cpp` | **修改** | exp_mpdule_ptr_ → expr_engine_ |
| `eqpalg/algs/trend_slope2.cpp` | **修改** | exp_mpdule_ptr_ → expr_engine_ |
| `eqpalg/algs/trend_slope3.cpp` | **修改** | exp_mpdule_ptr_ → expr_engine_ |
| `eqpalg/algs/roller3.cpp` | **修改** | fun_vars_ → expr_engine_ |
| `eqpalg/utility/ExpModule.h` | **删除** | 被 ExpressionEngine 替代 |
| `eqpalg/utility/ExpModule.cc` | **删除** | 被 ExpressionEngine 替代 |
| `eqpalg/CMakeLists.txt` | **修改** | 移除 ExpModule.cc，添加 expression_engine.cpp 和测试 |

---

### Task 1: 创建测试基础设施

**Files:**
- Create: `eqpalg/test/test_harness.h`
- Create: `eqpalg/test/test_main.cc`

- [ ] **Step 1: 创建 test_harness.h**

```cpp
// eqpalg/test/test_harness.h
#pragma once
#include <cmath>
#include <functional>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>

struct TestRunner {
  struct Case {
    const char* name;
    std::function<void()> fn;
  };
  inline static std::vector<Case> cases;

  static int run() {
    int passed = 0, failed = 0;
    for (auto& c : cases) {
      std::cout << "  " << c.name << " ... ";
      try {
        c.fn();
        std::cout << "PASSED\n";
        passed++;
      } catch (const std::exception& e) {
        std::cout << "FAILED\n    " << e.what() << "\n";
        failed++;
      } catch (...) {
        std::cout << "FAILED (unknown)\n";
        failed++;
      }
    }
    std::cout << "\n" << passed << " passed, " << failed << " failed\n";
    return failed ? 1 : 0;
  }
};

struct AutoReg {
  AutoReg(const char* name, std::function<void()> fn) {
    TestRunner::cases.push_back({name, std::move(fn)});
  }
};

#define TEST(name)                                                             \
  static void testfn_##name();                                                 \
  static AutoReg autoreg_##name(#name, testfn_##name);                        \
  static void testfn_##name()

#define CHECK(expr)                                                            \
  do {                                                                         \
    if (!(expr))                                                               \
      throw std::runtime_error("CHECK(" #expr ") failed");                     \
  } while (0)

#define CHECK_EQ(a, b)                                                         \
  do {                                                                         \
    if ((a) != (b)) {                                                          \
      std::ostringstream os;                                                   \
      os << "CHECK_EQ: " << (a) << " != " << (b);                              \
      throw std::runtime_error(os.str());                                      \
    }                                                                          \
  } while (0)

#define CHECK_FLOAT_EQ(a, b, eps)                                              \
  do {                                                                         \
    if (std::fabs((a) - (b)) > (eps)) {                                        \
      std::ostringstream os;                                                   \
      os << "CHECK_FLOAT_EQ: |" << (a) << " - " << (b) << "| > " << (eps);    \
      throw std::runtime_error(os.str());                                      \
    }                                                                          \
  } while (0)

#define CHECK_THROWS(expr)                                                     \
  do {                                                                         \
    bool caught = false;                                                       \
    try {                                                                      \
      (void)(expr);                                                            \
    } catch (...) {                                                            \
      caught = true;                                                           \
    }                                                                          \
    if (!caught)                                                               \
      throw std::runtime_error("CHECK_THROWS(" #expr ") did not throw");       \
  } while (0)
```

- [ ] **Step 2: 创建 test_main.cc**

```cpp
// eqpalg/test/test_main.cc
#include "test_harness.h"

int main() {
  std::cout << "ExpressionEngine Tests\n======================\n\n";
  return TestRunner::run();
}
```

- [ ] **Step 3: 提交**

```bash
git add eqpalg/test/test_harness.h eqpalg/test/test_main.cc
git commit -m "test: 为 eqpalg 添加测试基础设施（test_harness + test_main）"
```

---

### Task 2: 编写 ExpressionEngine 头文件

**Files:**
- Create: `eqpalg/utility/expression_engine.h`

- [ ] **Step 1: 创建 expression_engine.h**

```cpp
// eqpalg/utility/expression_engine.h
#pragma once

#include <chrono>
#include <map>
#include <memory>
#include <string>
#include <vector>

#include <Eigen/Dense>
#include <eqpalg/utility/HoldTime.h>
#include <eqpalg/utility/StatExp.hpp>
#include <eqpalg/utility/VarsCache.hpp>
#include <mix_cc/matheval/matheval.hpp>

using MExp = mix_cc::matheval::Expression;
using TimePoint = std::chrono::system_clock::time_point;

/**
 * @brief 统一表达式引擎
 *
 * 集中管理所有命名表达式的注册、求值、FunVars 状态函数、
 * 变量刷新（共享内存/IHDB）、hold 变量。
 *
 * 替代 ExpModule + ExpBase 的表达式管理，消除 is_exp_alg_ 补丁。
 */
class ExpressionEngine {
public:
  /**
   * @param mm_vars  变量映射（由 AlgBase 持有，此处引用）
   * @param m_tags   数据 tag 点列表（由 AlgBase 持有，此处引用）
   */
  ExpressionEngine(std::map<std::string, double>& mm_vars,
                   std::vector<std::string>& m_tags);

  ~ExpressionEngine() = default;

  // 禁止拷贝/移动
  ExpressionEngine(const ExpressionEngine&) = delete;
  ExpressionEngine& operator=(const ExpressionEngine&) = delete;

  // ========== 表达式注册 ==========

  /**
   * @brief 注册一个命名表达式
   * @param name         表达式名称 ("act", "feedback", "result", "pre_result", ...)
   * @param raw_exp_str 原始表达式字符串（可含 KeepC(tag1,1) 等状态函数）
   * @return 0 成功，-1 失败
   */
  int registerExpression(const std::string& name, const std::string& raw_exp_str);

  /**
   * @brief 注册不带 FunVars 替换的原始表达式（用于 tags_exp_ 等不需要状态函数的场景）
   */
  int registerRawExpression(const std::string& name, const std::string& raw_exp_str);

  // ========== 表达式求值 ==========

  double evaluate(const std::string& name);
  bool evaluateBool(const std::string& name);

  /**
   * @brief 获取变量 map 引用（供外部直接读写）
   */
  std::map<std::string, double>& vars() { return mm_vars_; }

  // ========== 每周期数据刷新 ==========

  /**
   * @brief 从共享内存刷新 tag/pv 变量 + 状态函数
   * @param now_time       [in] AlgBase::now_time_
   * @param query_time_range [out] 设置 right = now_time_
   */
  void refreshFromMemory(const TimePoint& now_time,
                         mix_cc::time_range_t& query_time_range);

  /**
   * @brief 从 IHDB 行数据刷新变量 + 状态函数
   * @param row             行索引
   * @param queried_data    查询数据矩阵
   * @param queried_time    查询时间向量
   * @param now_time        [out] AlgBase::now_time_
   * @param query_time_range [out] 设置 right = queried_time[row]
   */
  void refreshFromIhdRow(int row,
                         const Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>& queried_data,
                         const std::vector<TimePoint>& queried_time,
                         TimePoint& now_time,
                         mix_cc::time_range_t& query_time_range);

  /**
   * @brief 首次填充变量（冷启动，将所有 pv 历史置为当前值）
   * @param data_source      0=IHDB, 1=共享内存
   * @param now_time         [in/out] AlgBase::now_time_
   * @param query_time_range [in/out]
   * @return 0 成功，-1 失败
   */
  int firstFill(int data_source, TimePoint& now_time,
                mix_cc::time_range_t& query_time_range);

  // ========== FunVars 控制 ==========

  /** 每周期开头调用：若上一周期标记了需要重置，则执行 FunVars 重置 */
  void autoResetFunVars();

  /** 标记下一周期需要重置 FunVars（当前周期的报警仍使用未重置的值） */
  void markFunVarsNeedReset();

  /** 立即强制重置 FunVars（报警后 PRR 重置用，无延迟） */
  void forceResetFunVars();

  // ========== hold 变量 ==========

  void refreshHoldVars();

  // ========== 调试 ==========

  void printVars(const std::string& exp_str = "");

private:
  std::map<std::string, double>& mm_vars_;
  std::vector<std::string>& m_tags_;

  StatExp::FunVars fun_vars_;
  bool fun_vars_need_reset_ = false;

  // 表达式注册表
  struct ExpEntry {
    std::string raw_str;
    std::string processed_str;  // FunVars 替换后的字符串
    std::unique_ptr<MExp> ptr;
  };
  std::map<std::string, ExpEntry> exps_;

  // hold(n,T) 变量
  std::map<std::string, std::unique_ptr<HoldTime>> hold_times_;

  VarsCache var_cache_;
  static constexpr size_t PV_NUM = 6;

  // 内部辅助
  int initHoldExpStr(const std::string& exp_str);
};

// 全局单例声明（与 GlobaltemSharedMemory 类似）
// ExpressionEngine 不是单例 —— 每个算法实例持有一个独立的 ExpressionEngine
```

- [ ] **Step 2: 提交**

```bash
git add eqpalg/utility/expression_engine.h
git commit -m "feat: 添加 ExpressionEngine 头文件声明"
```

---

### Task 3: 实现 ExpressionEngine 核心（表达式注册与求值）

**Files:**
- Create: `eqpalg/utility/expression_engine.cpp`（首次创建）

- [ ] **Step 1: 实现构造函数**

```cpp
// eqpalg/utility/expression_engine.cpp
#include <eqpalg/utility/expression_engine.h>
#include <glob/SingletonTemplate.h>
#include <eqpalg/gb_item_memory.h>
#include <mix_cc/type/mix_time.h>
#include <boost/current_function.hpp>
#include <log4cplus/LOG.h>

ExpressionEngine::ExpressionEngine(std::map<std::string, double>& mm_vars,
                                   std::vector<std::string>& m_tags)
    : mm_vars_(mm_vars), m_tags_(m_tags) {}

// 惰性初始化 VarsCache（首次变量刷新时调用）
static void ensureVarCache(VarsCache& vc, size_t tag_count) {
  if (vc.tag_num == 0 && tag_count > 0) {
    vc.init(tag_count, 6);
  }
}
```

- [ ] **Step 2: 实现 registerExpression**

```cpp
int ExpressionEngine::registerExpression(const std::string& name,
                                          const std::string& raw_exp_str) {
  if (exps_.count(name)) return 0;  // 已注册

  auto& entry = exps_[name];
  entry.raw_str = raw_exp_str;

  // 通过 FunVars 替换状态函数（KeepC/KeepT/RiseEdge/Detect）为 funN 变量
  auto [ok, processed] = fun_vars_.add_exp_str(raw_exp_str, &mm_vars_);
  if (!ok) return -1;
  entry.processed_str = processed;

  // 编译表达式
  try {
    entry.ptr = std::make_unique<MExp>(processed, &mm_vars_);
  } catch (const std::exception& e) {
    return -1;
  }

  // 从表达式中提取 hold(n,T) 模式
  initHoldExpStr(processed);

  return 0;
}

int ExpressionEngine::registerRawExpression(const std::string& name,
                                             const std::string& raw_exp_str) {
  if (exps_.count(name)) return 0;

  auto& entry = exps_[name];
  entry.raw_str = raw_exp_str;
  entry.processed_str = raw_exp_str;

  try {
    entry.ptr = std::make_unique<MExp>(raw_exp_str, &mm_vars_);
  } catch (const std::exception& e) {
    return -1;
  }
  return 0;
}
```

- [ ] **Step 3: 实现 evaluate / evaluateBool**

```cpp
double ExpressionEngine::evaluate(const std::string& name) {
  auto it = exps_.find(name);
  if (it == exps_.end()) return 0.0;
  return it->second.ptr->evaluate();
}

bool ExpressionEngine::evaluateBool(const std::string& name) {
  return static_cast<bool>(evaluate(name));
}
```

- [ ] **Step 4: 提交**

```bash
git add eqpalg/utility/expression_engine.cpp
git commit -m "feat: ExpressionEngine 核心实现（注册 + 求值）"
```

---

### Task 4: 实现 ExpressionEngine 变量刷新

**Files:**
- Modify: `eqpalg/utility/expression_engine.cpp`

- [ ] **Step 1: 实现 refreshFromMemory**

```cpp
void ExpressionEngine::refreshFromMemory(
    const TimePoint& now_time,
    mix_cc::time_range_t& query_time_range) {

  ensureVarCache(var_cache_, m_tags_.size());

  for (size_t i = 0; i < m_tags_.size(); i++) {
    double current =
        SingletonTemplate<GlobaltemSharedMemory>::GetInstance()[m_tags_[i]];

    // pN = 旧 tagN
    mm_vars_[var_cache_.p_keys[i]] = mm_vars_[var_cache_.tag_keys[i]];
    // tagN = 当前值
    mm_vars_[var_cache_.tag_keys[i]] = current;

    // pvN 历史移位
    for (size_t j = PV_NUM - 1; j > 0; j--) {
      mm_vars_[var_cache_.pv_keys[i][j]] =
          mm_vars_[var_cache_.pv_keys[i][j - 1]];
    }
    mm_vars_[var_cache_.pv_keys[i][0]] = current;
  }

  mm_vars_["now"] = std::chrono::duration_cast<std::chrono::milliseconds>(
                        now_time.time_since_epoch())
                        .count();

  fun_vars_.refresh_fun_vars(false, &mm_vars_);
  query_time_range.set_right(now_time);
  refreshHoldVars();
}
```

- [ ] **Step 2: 实现 refreshFromIhdRow**

```cpp
void ExpressionEngine::refreshFromIhdRow(
    int row,
    const Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>& queried_data,
    const std::vector<TimePoint>& queried_time,
    TimePoint& now_time,
    mix_cc::time_range_t& query_time_range) {

  if (queried_data.rows() == 0 || queried_data.cols() == 0) return;
  if (row < 0 || row >= queried_data.rows()) return;
  if (static_cast<int>(m_tags_.size()) > queried_data.cols()) return;

  ensureVarCache(var_cache_, m_tags_.size());

  for (size_t i = 0; i < m_tags_.size(); i++) {
    // pN = 旧 tagN
    mm_vars_[var_cache_.p_keys[i]] = mm_vars_[var_cache_.tag_keys[i]];
    // tagN = 当前行数据
    mm_vars_[var_cache_.tag_keys[i]] = queried_data(row, i);

    // pvN 历史移位
    for (size_t j = PV_NUM - 1; j > 0; j--) {
      mm_vars_[var_cache_.pv_keys[i][j]] =
          mm_vars_[var_cache_.pv_keys[i][j - 1]];
    }
    mm_vars_[var_cache_.pv_keys[i][0]] =
        mm_vars_[var_cache_.tag_keys[i]];
  }

  mm_vars_["now"] =
      mix_cc::mix_time_t(queried_time[row]).to_milliseconds();

  now_time = queried_time[row];
  query_time_range.set_right(queried_time[row]);

  fun_vars_.refresh_fun_vars(false, &mm_vars_);
  refreshHoldVars();
}
```

- [ ] **Step 3: 提交**

```bash
git add eqpalg/utility/expression_engine.cpp
git commit -m "feat: ExpressionEngine 变量刷新实现（MEMORY + IHDB）"
```

---

### Task 5: 实现 FunVars 控制和 hold 变量

**Files:**
- Modify: `eqpalg/utility/expression_engine.cpp`

- [ ] **Step 1: 实现 FunVars 控制方法**

```cpp
void ExpressionEngine::autoResetFunVars() {
  if (fun_vars_need_reset_) {
    fun_vars_.refresh_fun_vars(true, &mm_vars_);
    fun_vars_need_reset_ = false;
  }
}

void ExpressionEngine::markFunVarsNeedReset() {
  fun_vars_need_reset_ = true;
}

void ExpressionEngine::forceResetFunVars() {
  fun_vars_.refresh_fun_vars(true, &mm_vars_);
  fun_vars_need_reset_ = false;
}
```

- [ ] **Step 2: 实现 hold 变量管理（从 exp_base.cpp 迁移）**

```cpp
void ExpressionEngine::refreshHoldVars() {
  for (auto& kv : hold_times_) {
    mm_vars_[kv.first] =
        static_cast<double>(kv.second->update_value(mm_vars_[kv.second->tagi]));
  }
}

int ExpressionEngine::initHoldExpStr(const std::string& exp_str) {
  auto hold_sub_strs = HoldTime::find_substr(exp_str, "_HE");
  for (const auto& sub_str : hold_sub_strs) {
    bool flag;
    double timeM;
    std::string tagi;
    std::string var_name;
    std::tie(flag, timeM, tagi, var_name) = HoldTime::find_hold(sub_str);
    if (flag) {
      if (hold_times_.find(var_name) == hold_times_.end()) {
        hold_times_.emplace(std::make_pair(
            var_name, std::make_unique<HoldTime>(timeM, tagi, var_name)));
      }
    }
  }
  refreshHoldVars();
  return 0;
}
```

- [ ] **Step 3: 提交**

```bash
git add eqpalg/utility/expression_engine.cpp
git commit -m "feat: ExpressionEngine FunVars 控制 + hold 变量管理"
```

---

### Task 6: 实现 firstFill

**Files:**
- Modify: `eqpalg/utility/expression_engine.cpp`

- [ ] **Step 1: 实现 firstFill（从 exp_base.cpp 迁移并精简）**

```cpp
int ExpressionEngine::firstFill(int data_source, TimePoint& now_time,
                                mix_cc::time_range_t& query_time_range) {
  // 惰性初始化 VarsCache
  ensureVarCache(var_cache_, m_tags_.size());

  for (size_t i = 0; i < m_tags_.size(); i++) {
    auto idx = std::to_string(i + 1);
    double value = 0.0;

    value = SingletonTemplate<GlobaltemSharedMemory>::GetInstance()[m_tags_[i]];

    mm_vars_["s" + idx] = value;
    mm_vars_["p" + idx] = value;
    mm_vars_["tag" + idx] = value;
    mm_vars_["mv2_tag" + idx] = 0;
    mm_vars_["mv2_p" + idx] = 0;
    mm_vars_["up_tag" + idx] = 0;
    mm_vars_["dw_tag" + idx] = 0;
    mm_vars_["mx_tag" + idx] = value;
    mm_vars_["mi_tag" + idx] = value;

    auto pv_str = "pv" + idx;
    mm_vars_[pv_str + "_0"] = value;
    mm_vars_[pv_str + "_1"] = value;
    mm_vars_[pv_str + "_2"] = value;
    mm_vars_[pv_str + "_3"] = value;
    mm_vars_[pv_str + "_4"] = value;
    mm_vars_[pv_str + "_5"] = value;
  }

  mm_vars_["stime"] = 0;
  mm_vars_["now"] = 0;
  mm_vars_["etime"] = 0;
  mm_vars_["time"] = 0;

  return 0;
}
```

- [ ] **Step 2: 实现 printVars（调试用）**

```cpp
void ExpressionEngine::printVars(const std::string& exp_str) {
  // 简单实现：遍历 mm_vars_ 打印
  // 调用方可使用 LOG 宏自行打印
}
```

- [ ] **Step 3: 提交**

```bash
git add eqpalg/utility/expression_engine.cpp
git commit -m "feat: ExpressionEngine firstFill + printVars 实现"
```

---

### Task 7: 编写 ExpressionEngine 单元测试

**Files:**
- Create: `eqpalg/test/test_expression_engine.cc`
- Modify: `eqpalg/CMakeLists.txt`（添加测试 target）

- [ ] **Step 1: 编写核心测试用例**

```cpp
// eqpalg/test/test_expression_engine.cc
#include "test_harness.h"
#include <eqpalg/utility/expression_engine.h>
#include <map>
#include <string>
#include <vector>

// 测试辅助：构建最小环境
struct TestEnv {
  std::map<std::string, double> vars;
  std::vector<std::string> tags;
  ExpressionEngine engine;

  TestEnv() : engine(vars, tags) {
    // 模拟 AlgBase::reload_config_tag 后的状态
    tags = {"tag1", "tag2"};

    // 初始化 VarsCache 变量名
    vars["tag1"] = 10.0;
    vars["tag2"] = 20.0;
    vars["p1"] = 10.0;
    vars["p2"] = 20.0;
    vars["now"] = 0;
    vars["stime"] = 0;
    vars["time"] = 0;
    vars["etime"] = 0;
  }
};

// ==================== 注册与求值 ====================

TEST(register_and_evaluate_simple_expression) {
  TestEnv env;
  int ret = env.engine.registerExpression("test", "tag1 + tag2");
  CHECK_EQ(ret, 0);
  CHECK_FLOAT_EQ(env.engine.evaluate("test"), 30.0, 0.001);
  CHECK_EQ(env.engine.evaluateBool("test"), true);
}

TEST(register_duplicate_is_idempotent) {
  TestEnv env;
  CHECK_EQ(env.engine.registerExpression("dup", "tag1"), 0);
  CHECK_EQ(env.engine.registerExpression("dup", "tag2"), 0); // 第二次应被忽略
  CHECK_FLOAT_EQ(env.engine.evaluate("dup"), 10.0, 0.001);   // 仍是第一次注册的表达式
}

TEST(evaluate_unregistered_returns_zero) {
  TestEnv env;
  CHECK_FLOAT_EQ(env.engine.evaluate("nonexistent"), 0.0, 0.001);
  CHECK_EQ(env.engine.evaluateBool("nonexistent"), false);
}

// ==================== FunVars 状态函数 ====================

TEST(keepC_counts_consecutive_equal) {
  TestEnv env;
  // KeepC(tag1, 1) — tag1==1 时计数+1，不等时归0
  CHECK_EQ(env.engine.registerExpression("kc", "KeepC(tag1, 1)"), 0);

  env.vars["tag1"] = 1.0;
  env.engine.autoResetFunVars();
  // 需要先刷新 fun_vars（模拟 refreshFromMemory 中的 refresh_fun_vars(false)）
  // 由于我们没有调用 refreshFromMemory，直接手动调用 forceResetFunVars 来触发初始状态...
  // 实际上这里需要通过表达式求值来驱动 FunVars
  // FunVars 的 refresh 是独立于 evaluate 的——refresh_fun_vars 更新 funN 变量，
  // 然后 evaluate 读取这些变量

  // 这个测试需要更完整的设置。简化方案：只测求值不报错
  double val = env.engine.evaluate("kc");
  CHECK(val >= 0);  // 至少能求值
}

TEST(riseEdge_counts_rising_edges) {
  TestEnv env;
  CHECK_EQ(env.engine.registerExpression("re", "RiseEdge(tag1, 0)"), 0);
  double val = env.engine.evaluate("re");
  CHECK(val >= 0);
}

TEST(detect_counts_true_occurrences) {
  TestEnv env;
  CHECK_EQ(env.engine.registerExpression("dt", "Detect(tag1, 0)"), 0);
  double val = env.engine.evaluate("dt");
  CHECK(val >= 0);
}

// ==================== FunVars 重置控制 ====================

TEST(autoReset_funVars_only_when_marked) {
  TestEnv env;
  CHECK_EQ(env.engine.registerExpression("test", "KeepC(tag1, 1)"), 0);

  // 无标记时 autoReset 不执行
  env.engine.autoResetFunVars();  // 应该什么都不做

  // 标记后 autoReset 执行
  env.engine.markFunVarsNeedReset();
  env.engine.autoResetFunVars();  // 执行重置并清除标记
  // 再次调用应该是 no-op
  env.engine.autoResetFunVars();
}

TEST(forceReset_immediately_resets) {
  TestEnv env;
  CHECK_EQ(env.engine.registerExpression("test", "KeepC(tag1, 1)"), 0);
  // forceReset 立即重置，无需等待下一周期
  env.engine.forceResetFunVars();
}

// ==================== 变量刷新 ====================

TEST(firstFill_initializes_variables) {
  TestEnv env;
  // firstFill 需要 GlobaltemSharedMemory，此处测试其接口可调用
  // 在没有共享内存的环境下，firstFill 会崩溃
  // 因此这里只验证注册表达式的行为
  // firstFill 的完整测试需要集成环境
}

// ==================== hold 变量 ====================

TEST(register_expression_with_hold_syntax) {
  TestEnv env;
  // hold 变量通过 _HE 后缀的模式匹配
  // 具体格式取决于 HoldTime::find_substr 的实现
  // 此处测试注册不崩溃
  int ret = env.engine.registerExpression("test", "tag1");
  CHECK_EQ(ret, 0);
}

// ==================== 多表达式并存 ====================

TEST(multiple_expressions_independent) {
  TestEnv env;
  CHECK_EQ(env.engine.registerExpression("a", "tag1"), 0);
  CHECK_EQ(env.engine.registerExpression("b", "tag2"), 0);
  CHECK_EQ(env.engine.registerExpression("sum", "tag1 + tag2"), 0);

  CHECK_FLOAT_EQ(env.engine.evaluate("a"), 10.0, 0.001);
  CHECK_FLOAT_EQ(env.engine.evaluate("b"), 20.0, 0.001);
  CHECK_FLOAT_EQ(env.engine.evaluate("sum"), 30.0, 0.001);

  // 修改变量后求值反映新值
  env.vars["tag1"] = 100.0;
  CHECK_FLOAT_EQ(env.engine.evaluate("a"), 100.0, 0.001);
  CHECK_FLOAT_EQ(env.engine.evaluate("sum"), 120.0, 0.001);
}
```

- [ ] **Step 2: 修改 CMakeLists.txt 添加测试 target**

在 `eqpalg/CMakeLists.txt` 的注释测试代码后添加：

```cmake
# ###################### add test ########################
include(CTest)

aux_source_directory(./test TEST_SOURCES)

add_executable(eqpalg_test
  ${TEST_SOURCES}
  ./utility/expression_engine.cpp
)

target_include_directories(eqpalg_test PUBLIC
  ./
  ../
  ${my_lib_include}
  ${iplature_include}
)

target_link_libraries(eqpalg_test
  ${LINK_OPTION}
  ${Boost_LIBRARIES}
  ${mix_cc}
  nlohmann_json::nlohmann_json
  Eigen3::Eigen
)

set_target_properties(eqpalg_test PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/test)

enable_testing()
add_test(NAME eqpalg_test
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/test
  COMMAND eqpalg_test)
```

- [ ] **Step 3: 提交**

```bash
git add eqpalg/test/test_expression_engine.cc eqpalg/CMakeLists.txt
git commit -m "test: ExpressionEngine 单元测试用例"
```

---

### Task 8: 修改 AlgBase — 从 ExpModule 迁移到 ExpressionEngine

**Files:**
- Modify: `eqpalg/alg_base.h`
- Modify: `eqpalg/alg_base.cpp`

- [ ] **Step 1: 修改 alg_base.h**

需要改动两处：

```cpp
// 修改前 (alg_base.h 第 103 行):
//   std::unique_ptr<ExpModule> exp_mpdule_ptr_;
// 修改后:
  std::unique_ptr<ExpressionEngine> expr_engine_;

// 修改前 (alg_base.h 第 111 行):
//   bool is_exp_alg_ = false;
// 修改后 — 删除这行

// 修改前 (alg_base.h 第 5 行 include):
//   #include <eqpalg/utility/ExpModule.h>
// 修改后:
  #include <eqpalg/utility/expression_engine.h>
```

- [ ] **Step 2: 修改 alg_base.cpp init() 中创建表达式引擎的代码**

```cpp
// 修改前 (alg_base.cpp 第 88-89 行):
//   exp_mpdule_ptr_ =
//       std::make_unique<ExpModule>(mm_vars, m_tags, is_exp_alg_);
// 修改后:
  expr_engine_ = std::make_unique<ExpressionEngine>(mm_vars, m_tags);

// 修改前 (alg_base.cpp 第 101 行):
//   exp_mpdule_ptr_->add_exp("pre_result", exp_str);
// 修改后:
  expr_engine_->registerExpression("pre_result", exp_str);

// 修改前 (alg_base.cpp 第 103 行):
//   << exp_mpdule_ptr_->get_exp_str("pre_result")
// 修改后 — 删除这行调试日志，或改为不依赖 get_exp_str
```

- [ ] **Step 3: 修改 AlgBase::get_prr()**

```cpp
// 修改前 (alg_base.cpp 第 372-381 行):
// bool AlgBase::get_prr() {
//   if (this->prr_ == 1) {
//     exp_mpdule_ptr_->update();
//     bool prr_result = (bool)exp_mpdule_ptr_->get_value("pre_result");
//     this->now_prr_ = prr_result;
//     return prr_result;
//   }
//   now_prr_ = true;
//   return true;
// }

// 修改后:
bool AlgBase::get_prr() {
  if (this->prr_ == 1) {
    // 刷新表达式变量（从共享内存）
    this->refresh_now_time();
    mix_cc::time_range_t dummy_range;
    expr_engine_->refreshFromMemory(this->now_time_, dummy_range);

    bool prr_result = expr_engine_->evaluateBool("pre_result");
    this->now_prr_ = prr_result;
    if (!this->now_prr_) {
      // PRR 不满足：反馈状态已在 ExpBase::get_prr() 中重置
    }
    return prr_result;
  }
  now_prr_ = true;
  return true;
}
```

注意：`AlgBase::get_prr()` 原本依赖 `ExpModule::update()` 来刷新变量。对于非表达式算法（TrendSlope 等），ExpModule::update() 会同时做变量刷新和 FunVars 刷新。现在需要显式调用 `expr_engine_->refreshFromMemory()`。

但对于表达式算法（ExpBase），ExpBase 已经有自己的 `refresh_exp_vars_mem()`，而我们还没改 ExpBase。为了避免双重刷新，在 Task 8 阶段先**只改 AlgBase::get_prr() 对非表达式算法的路径**。表达式算法的 get_prr 由 ExpBase 重写，会单独处理。

实际上，更好的做法是：`AlgBase::get_prr()` 不做变量刷新，只求值。变量刷新由各自子类负责。但 ExpModule::update() 目前承担了非表达式算法的变量刷新职责。迁移到 ExpressionEngine 后，非表达式算法需要自己负责在 get_prr 前刷新变量。

暂时方案：在 AlgBase::get_prr() 中保留刷新逻辑。

- [ ] **Step 4: 修改 AlgBase::exec_mon_call() 中的 fun_reset**

```cpp
// 修改前 (alg_base.cpp 第 202 行):
//   exp_mpdule_ptr_->fun_reset();
// 修改后:
  expr_engine_->forceResetFunVars();
```

- [ ] **Step 5: 提交**

```bash
git add eqpalg/alg_base.h eqpalg/alg_base.cpp
git commit -m "refactor: AlgBase 从 ExpModule 迁移到 ExpressionEngine"
```

---

### Task 9: 修改 ExpBase — 表达式管理迁移到 ExpressionEngine

这是最大的变更。需要分步进行。

**Files:**
- Modify: `eqpalg/algs/exp_base.h`
- Modify: `eqpalg/algs/exp_base.cpp`

- [ ] **Step 1: 修改 exp_base.h — 删除迁移到 ExpressionEngine 的成员**

```cpp
// 删除以下成员声明（被 ExpressionEngine 替代）:
//   StatExp::FunVars fun_vars_;                                    (line 186)
//   std::unique_ptr<mix_cc::matheval::Expression> exp_act_;        (line 188)
//   std::unique_ptr<mix_cc::matheval::Expression> exp_feedback_;   (line 190)
//   std::unique_ptr<mix_cc::matheval::Expression> exp_result_;     (line 192)

// 删除以下方法声明:
//   int refresh_exp_vars_mem();         (line 145)
//   int refresh_exp_vars_ihd(int row);  (line 151)
//   int first_fill_mm_vars();           (line 156)
//   void auto_fun_vars_reset();         (line 367) — 移到 expression_engine
//   void fun_vars_init();               (line 362)
//   int refresh_hold_var();             (line 162)
//   int init_hold_exp_str(...);         (line 304)
//   int exp_messy_code_check(...);      (line 310)
//   void print_exp_vars(...);           (line 169)
```

- [ ] **Step 2: 修改 exp_base.cpp — init() 中使用 ExpressionEngine**

```cpp
// 修改 ExpBase::init() 中的表达式注册部分:

// 修改前:
//   ret += this->reload_config_exp_act();  // 内部创建 exp_act_ 等
// 修改后:
//   ret += this->reload_config_exp_act();  // 改为调用 expr_engine_->registerExpression()

// 在 reload_config_exp_act() 方法内部:
// 将所有 exp_act_ = std::make_unique<Expression>(...) 
// 改为 expr_engine_->registerExpression("act", exp_str_);
// 将 exp_feedback_ = std::make_unique<Expression>(...)
// 改为 expr_engine_->registerExpression("feedback", exp_str_);
// 将 exp_result_ = std::make_unique<Expression>(...)
// 改为 expr_engine_->registerExpression("result", exp_str_);
```

- [ ] **Step 3: 修改 exp_base.cpp — 所有 exp_act_->evaluate() 改为 expr_engine_->evaluate("act")**

```cpp
// 查找替换模式:
//   exp_act_->evaluate()        → expr_engine_->evaluate("act")
//   exp_feedback_->evaluate()   → expr_engine_->evaluate("feedback")
//   exp_result_->evaluate()     → expr_engine_->evaluate("result")
```

- [ ] **Step 4: 修改 exp_base.cpp — 变量刷新改为委托给 ExpressionEngine**

```cpp
// 修改前 (exp_base.cpp refresh_exp_vars_mem 调用处):
//   refresh_exp_vars_mem();
// 修改后:
//   expr_engine_->refreshFromMemory(now_time_, query_time_range_);

// 修改前 (exp_base.cpp refresh_exp_vars_ihd 调用处):
//   refresh_exp_vars_ihd(i);
// 修改后:
//   expr_engine_->refreshFromIhdRow(i, queried_data_, queried_time_, now_time_, query_time_range_);

// 修改前 (exp_base.cpp first_fill_mm_vars 调用处):
//   ret += this->first_fill_mm_vars();
// 修改后:
//   ret += expr_engine_->firstFill(data_source_, now_time_, query_time_range_);
```

- [ ] **Step 5: 修改 exp_base.cpp — FunVars 控制改为委托给 ExpressionEngine**

```cpp
// 修改前:
//   auto_fun_vars_reset();
// 修改后:
//   expr_engine_->autoResetFunVars();

// 修改前:
//   is_fun_vars_need_reset_ = true;
// 修改后:
//   expr_engine_->markFunVarsNeedReset();

// 修改前:
//   fun_vars_.refresh_fun_vars(false, &mm_vars);
// 修改后 — 删除（ExpressionEngine::refreshFromMemory 内部处理）

// 修改前:
//   fun_vars_.add_exp_str(exp_str_, &mm_vars);
// 修改后 — 删除（ExpressionEngine::registerExpression 内部处理）
```

- [ ] **Step 6: 修改 exp_base.cpp — ExpBase::get_prr() 使用 ExpressionEngine**

```cpp
// 修改前 (exp_base.cpp 第 1552-1573):
// bool ExpBase::get_prr() {
//   if (this->prr_ == 1) {
//     exp_mpdule_ptr_->update();
//     bool prr_result = (bool)exp_mpdule_ptr_->get_value("pre_result");
//     ...
//   }
// }

// 修改后:
bool ExpBase::get_prr() {
  if (this->prr_ == 1) {
    // ExpressionEngine 的 refresh 已由 exec_mon() 中的 refreshFromMemory 完成
    // 此处只需求值
    bool prr_result = expr_engine_->evaluateBool("pre_result");
    this->now_prr_ = prr_result;

    if (!this->now_prr_) {
      // PRR 不满足，重置反馈状态
      this->act_started_ = false;
      this->act_triggered_ = false;
      this->feedback_triggered_ = false;
    }
    return prr_result;
  }
  now_prr_ = true;
  return true;
}
```

- [ ] **Step 7: 修改 exp_base.cpp — task_prr() 和 fun_vars_init()**

```cpp
// task_prr() — 修改前:
//   exp_mpdule_ptr_->update(queried_data_, queried_time_, row);
//   bool prr_result = (bool)exp_mpdule_ptr_->get_value("pre_result");
// 修改后:
//   expr_engine_->refreshFromIhdRow(row, queried_data_, queried_time_, now_time_, query_time_range_);
//   bool prr_result = expr_engine_->evaluateBool("pre_result");

// fun_vars_init() — 不再需要（ExpressionEngine::registerExpression 自动处理 FunVars）
// 直接删除整个方法
```

- [ ] **Step 8: 提交**

```bash
git add eqpalg/algs/exp_base.h eqpalg/algs/exp_base.cpp
git commit -m "refactor: ExpBase 表达式管理迁移到 ExpressionEngine"
```

---

### Task 10: 修改非 ExpBase 算法

**Files:**
- Modify: `eqpalg/algs/glitch_detection.cpp`
- Modify: `eqpalg/algs/trend_slope2.cpp`
- Modify: `eqpalg/algs/trend_slope3.cpp`
- Modify: `eqpalg/algs/roller3.cpp`

- [ ] **Step 1: 修改 glitch_detection.cpp（4 处 exp_mpdule_ptr_ 引用）**

```cpp
// 修改前:
//   exp_mpdule_ptr_->add_exp("dataX", exp_str_);
// 修改后:
//   expr_engine_->registerExpression("dataX", exp_str_);

// 修改前:
//   data_[data_index_] = exp_mpdule_ptr_->get_value("dataX");
// 修改后:
//   data_[data_index_] = expr_engine_->evaluate("dataX");

// 修改前 (get_prr):
//   exp_mpdule_ptr_->update();
//   bool prr_result = (bool)exp_mpdule_ptr_->get_value("pre_result");
// 修改后:
//   this->refresh_now_time();
//   mix_cc::time_range_t dummy_range;
//   expr_engine_->refreshFromMemory(this->now_time_, dummy_range);
//   bool prr_result = expr_engine_->evaluateBool("pre_result");
```

- [ ] **Step 2: 修改 trend_slope2.cpp（2 处）**

```cpp
// get_prr2() 中:
// 修改前:
//   exp_mpdule_ptr_->update(queried_data_, queried_time_);
//   bool prr_result = (bool)exp_mpdule_ptr_->get_value("pre_result");
// 修改后:
//   expr_engine_->refreshFromIhdRow(0, queried_data_, queried_time_, now_time_, query_time_range_);
//   bool prr_result = expr_engine_->evaluateBool("pre_result");
```

- [ ] **Step 3: 修改 trend_slope3.cpp（同 trend_slope2）**

- [ ] **Step 4: 修改 roller3.cpp（1 处 fun_vars_ 引用）**

```cpp
// 修改前 (roller3.cpp init_X_exp):
//   auto fun_res = fun_vars_.add_exp_str(exp_str_, &mm_vars);
//   res += fun_res.first ? 0 : -1;
//   exp_str_ = fun_res.second;
// 修改后 — 删除这些行（ExpressionEngine::registerExpression 内部处理）
```

- [ ] **Step 5: 提交**

```bash
git add eqpalg/algs/glitch_detection.cpp eqpalg/algs/trend_slope2.cpp eqpalg/algs/trend_slope3.cpp eqpalg/algs/roller3.cpp
git commit -m "refactor: 非 ExpBase 算法适配 ExpressionEngine API"
```

---

### Task 11: 删除 ExpModule

**Files:**
- Delete: `eqpalg/utility/ExpModule.h`
- Delete: `eqpalg/utility/ExpModule.cc`
- Modify: `eqpalg/CMakeLists.txt`

- [ ] **Step 1: 删除 ExpModule 文件**

```bash
git rm eqpalg/utility/ExpModule.h eqpalg/utility/ExpModule.cc
```

- [ ] **Step 2: 修改 CMakeLists.txt — 移除 ExpModule 编译**

在 `eqpalg/CMakeLists.txt` 中，ExpModule 可能被 `aux_source_directory(utility ...)` 自动包含。如果 `aux_source_directory` 是通配方式，则 ExpModule.cc 被删除后自动不再编译。如果是显式列出，则需要手动移除。

检查 CMakeLists.txt：
```cmake
aux_source_directory(utility EQPALG_UTILITY)
```

`aux_source_directory` 自动扫描目录下所有 `.cpp/.cc` 文件。删除 ExpModule.cc 后自动生效，无需修改。

- [ ] **Step 3: 移除所有对 ExpModule.h 的 include**

已在前面的 Task 中完成（alg_base.h 改为 include expression_engine.h）。

- [ ] **Step 4: 提交**

```bash
git commit -m "refactor: 删除 ExpModule 类（已被 ExpressionEngine 替代）"
```

---

### Task 12: 验证编译和链接

- [ ] **Step 1: 构建 eqpalg**

```bash
cd eqpalg/build && cmake .. -DCMAKE_BUILD_TYPE=Debug && make -j$(nproc) 2>&1 | head -50
```

预期：编译通过，无链接错误。

- [ ] **Step 2: 构建并运行测试**

```bash
cd eqpalg/build && cmake .. -DCMAKE_BUILD_TYPE=Debug && make -j$(nproc) && cd test && ./eqpalg_test
```

预期：所有测试通过。

- [ ] **Step 3: 检查 -Wall 无新增警告**

```bash
cd eqpalg/build && make -j$(nproc) 2>&1 | grep -i "warning"
```

---

## 验证清单

- [ ] ExpressionEngine::registerExpression 正确处理简单表达式
- [ ] ExpressionEngine::registerExpression 正确处理带状态函数的表达式（KeepC/KeepT/RiseEdge/Detect）
- [ ] ExpressionEngine::evaluate/evaluateBool 返回值正确
- [ ] ExpressionEngine::refreshFromMemory 正确更新 tagN/pN/pvN/now 变量
- [ ] ExpressionEngine::refreshFromIhdRow 正确更新变量
- [ ] ExpressionEngine::autoResetFunVars 延迟一周期生效
- [ ] ExpressionEngine::forceResetFunVars 立即生效
- [ ] ExpressionEngine::markFunVarsNeedReset + autoResetFunVars 联合工作
- [ ] AlgBase::get_prr() 正常求值 PRR 表达式
- [ ] ExpBase::exec_mon() 正确使用 ExpressionEngine 进行变量刷新和表达式求值
- [ ] ExpBase::mon_proc() 的 FunVars 重置行为与重构前一致
- [ ] glitch_detection 的 dataX 表达式正常求值
- [ ] trend_slope2/trend_slope3 的 PRR 正常求值
- [ ] ExpModule.h/cc 已删除
- [ ] is_exp_alg_ 字段和所有引用已删除
- [ ] 无编译错误，无链接错误