#include <gtest/gtest.h>

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

#include "behavior/behavior_event.h"
#include "frame/frame.h"
#include "utils/simple_json.h"
#include "../plugins/alarm/rule_engine.h"

namespace rk3588 {
namespace {

SimpleJson ParseAlarmRules(const std::string& text) {
    SimpleJson config;
    std::string err;
    const bool ok = ParseSimpleJson(text, config, err);
    EXPECT_TRUE(ok) << err;
    return config;
}

TEST(AlarmBehaviorEventsTest, MatchesBehaviorEventByTypeAndDuration) {
    RuleEngine engine;
    const auto rules = ParseAlarmRules(R"([
        {
            "name": "fall_event",
            "use_behavior_events": true,
            "event_types": ["fall"],
            "min_duration_ms": 1000,
            "cooldown_ms": 0
        }
    ])");

    ASSERT_TRUE(engine.Init(rules, {}));

    auto frame = std::make_shared<Frame>();
    frame->behavior_events = std::make_shared<BehaviorEventResult>();
    BehaviorEventItem item;
    item.type = BehaviorEventType::Fall;
    item.status = BehaviorEventStatus::Active;
    item.duration_ms = 1500;
    item.track_ids = {8};
    frame->behavior_events->items.push_back(item);

    const auto result = engine.Evaluate(frame);
    EXPECT_TRUE(result.matched);
    EXPECT_EQ(result.rule_name, "fall_event");
    ASSERT_EQ(result.matched_behavior_events.size(), 1u);
    EXPECT_EQ(result.matched_behavior_events[0].type, BehaviorEventType::Fall);
}

TEST(AlarmBehaviorEventsTest, PreservesLegacyDetectionRules) {
    RuleEngine engine;
    const auto rules = ParseAlarmRules(R"([
        {
            "name": "person_detected",
            "class_ids": [0],
            "cooldown_ms": 0
        }
    ])");

    ASSERT_TRUE(engine.Init(rules, {"person"}));

    auto frame = std::make_shared<Frame>();
    frame->width = 1920;
    frame->height = 1080;
    frame->det = std::make_shared<DetectionResult>();
    frame->det->img_w = 1920;
    frame->det->img_h = 1080;
    frame->det->items.push_back(Detection{0, 0.9f, Rect{100.0f, 120.0f, 80.0f, 200.0f}, 3});

    const auto result = engine.Evaluate(frame);
    EXPECT_TRUE(result.matched);
    EXPECT_EQ(result.rule_name, "person_detected");
    ASSERT_EQ(result.matched_detections.size(), 1u);
    EXPECT_EQ(result.matched_detections[0].cls_id, 0);
}

}  // namespace
}  // namespace rk3588