#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include "alert_manager.hpp"
#include <sstream>
#include <iostream>

class AlertManagerTest : public ::testing::Test {
protected:
    AlertManager alert_manager;

    void SetUp() override {
        // 重置输出流缓冲区，避免测试输出干扰
        testing::internal::CaptureStdout();
        testing::internal::CaptureStderr();
    }

    void TearDown() override {
        testing::internal::GetCapturedStdout();
        testing::internal::GetCapturedStderr();
    }
};

// 测试 checkAltitudeAlert 函数
// 正常输入测试：高度在阈值范围内，不应触发预警
TEST_F(AlertManagerTest, testCheckAltitudeAlertNormalRange) {
    alert_manager.setAltitudeThresholds(100.0f, -50.0f);
    alert_manager.checkAltitudeAlert(50.0f, 1000);
    
    EXPECT_FALSE(alert_manager.hasActiveAlerts());
    EXPECT_FALSE(alert_manager.hasUnacknowledgedAlerts());
}

// 正常输入测试：高度超过上限，应触发上限预警
TEST_F(AlertManagerTest, testCheckAltitudeAlertUpperThreshold) {
    alert_manager.setAltitudeThresholds(100.0f, -50.0f);
    alert_manager.checkAltitudeAlert(150.0f, 1000);
    
    EXPECT_TRUE(alert_manager.hasActiveAlerts());
    auto active_alerts = alert_manager.getActiveAlerts();
    ASSERT_EQ(active_alerts.size(), 1);
    EXPECT_EQ(active_alerts[0].type, AlertType::ALTITUDE_UPPER);
    EXPECT_EQ(active_alerts[0].status, AlertStatus::ACTIVE);
}

// 正常输入测试：高度低于下限，应触发下限预警
TEST_F(AlertManagerTest, testCheckAltitudeAlertLowerThreshold) {
    alert_manager.setAltitudeThresholds(100.0f, -50.0f);
    alert_manager.checkAltitudeAlert(-100.0f, 1000);
    
    EXPECT_TRUE(alert_manager.hasActiveAlerts());
    auto active_alerts = alert_manager.getActiveAlerts();
    ASSERT_EQ(active_alerts.size(), 1);
    EXPECT_EQ(active_alerts[0].type, AlertType::ALTITUDE_LOWER);
    EXPECT_EQ(active_alerts[0].status, AlertStatus::ACTIVE);
}

// 边界值测试：高度等于上限阈值，不应触发预警
TEST_F(AlertManagerTest, testCheckAltitudeAlertAtUpperBoundary) {
    alert_manager.setAltitudeThresholds(100.0f, -50.0f);
    alert_manager.checkAltitudeAlert(100.0f, 1000);
    
    EXPECT_FALSE(alert_manager.hasActiveAlerts());
}

// 边界值测试：高度等于下限阈值，不应触发预警
TEST_F(AlertManagerTest, testCheckAltitudeAlertAtLowerBoundary) {
    alert_manager.setAltitudeThresholds(100.0f, -50.0f);
    alert_manager.checkAltitudeAlert(-50.0f, 1000);
    
    EXPECT_FALSE(alert_manager.hasActiveAlerts());
}

// 边界值测试：高度略高于上限阈值，应触发预警
TEST_F(AlertManagerTest, testCheckAltitudeAlertJustAboveUpper) {
    alert_manager.setAltitudeThresholds(100.0f, -50.0f);
    alert_manager.checkAltitudeAlert(100.001f, 1000);
    
    EXPECT_TRUE(alert_manager.hasActiveAlerts());
}

// 边界值测试：高度略低于下限阈值，应触发预警
TEST_F(AlertManagerTest, testCheckAltitudeAlertJustBelowLower) {
    alert_manager.setAltitudeThresholds(100.0f, -50.0f);
    alert_manager.checkAltitudeAlert(-50.001f, 1000);
    
    EXPECT_TRUE(alert_manager.hasActiveAlerts());
}

// 特殊场景测试：高度从超限恢复正常，应解除预警
TEST_F(AlertManagerTest, testCheckAltitudeAlertResolveAfterExceed) {
    alert_manager.setAltitudeThresholds(100.0f, -50.0f);
    
    // 触发上限预警
    alert_manager.checkAltitudeAlert(150.0f, 1000);
    EXPECT_TRUE(alert_manager.hasActiveAlerts());
    
    // 恢复正常
    alert_manager.checkAltitudeAlert(50.0f, 1001);
    EXPECT_FALSE(alert_manager.hasActiveAlerts());
    
    // 验证预警历史中有已解决的记录
    auto history = alert_manager.getAlertHistory(10);
    bool found_resolved = false;
    for (const auto& alert : history) {
        if (alert.type == AlertType::ALTITUDE_UPPER && 
            alert.status == AlertStatus::RESOLVED) {
            found_resolved = true;
            break;
        }
    }
    EXPECT_TRUE(found_resolved);
}

// 特殊场景测试：同时触发上下限预警（理论上不可能，但测试边界）
TEST_F(AlertManagerTest, testCheckAltitudeAlertBothThresholds) {
    alert_manager.setAltitudeThresholds(100.0f, -50.0f);
    
    // 触发上限预警
    alert_manager.checkAltitudeAlert(150.0f, 1000);
    // 触发下限预警
    alert_manager.checkAltitudeAlert(-100.0f, 1001);
    
    auto active_alerts = alert_manager.getActiveAlerts();
    EXPECT_EQ(active_alerts.size(), 2);
}

// 异常输入测试：高度为极大值
TEST_F(AlertManagerTest, testCheckAltitudeAlertMaxFloat) {
    alert_manager.setAltitudeThresholds(100.0f, -50.0f);
    alert_manager.checkAltitudeAlert(std::numeric_limits<float>::max(), 1000);
    
    EXPECT_TRUE(alert_manager.hasActiveAlerts());
    auto active_alerts = alert_manager.getActiveAlerts();
    EXPECT_EQ(active_alerts[0].type, AlertType::ALTITUDE_UPPER);
}

// 异常输入测试：高度为极小值
TEST_F(AlertManagerTest, testCheckAltitudeAlertMinFloat) {
    alert_manager.setAltitudeThresholds(100.0f, -50.0f);
    alert_manager.checkAltitudeAlert(std::numeric_limits<float>::lowest(), 1000);
    
    EXPECT_TRUE(alert_manager.hasActiveAlerts());
    auto active_alerts = alert_manager.getActiveAlerts();
    EXPECT_EQ(active_alerts[0].type, AlertType::ALTITUDE_LOWER);
}

// 测试 setAltitudeThresholds 函数
// 正常输入测试：设置有效的上下限阈值
TEST_F(AlertManagerTest, testSetAltitudeThresholdsValid) {
    alert_manager.setAltitudeThresholds(200.0f, -100.0f);
    
    // 验证新阈值生效
    alert_manager.checkAltitudeAlert(150.0f, 1000);
    EXPECT_FALSE(alert_manager.hasActiveAlerts());
    
    alert_manager.checkAltitudeAlert(250.0f, 1001);
    EXPECT_TRUE(alert_manager.hasActiveAlerts());
}

// 异常输入测试：上限等于下限，应输出错误并保持原阈值
TEST_F(AlertManagerTest, testSetAltitudeThresholdsEqual) {
    alert_manager.setAltitudeThresholds(100.0f, -50.0f);
    
    // 尝试设置相等的阈值
    alert_manager.setAltitudeThresholds(50.0f, 50.0f);
    
    // 验证原阈值保持不变
    alert_manager.checkAltitudeAlert(75.0f, 1000);
    EXPECT_FALSE(alert_manager.hasActiveAlerts());
    
    alert_manager.checkAltitudeAlert(101.0f, 1001);
    EXPECT_TRUE(alert_manager.hasActiveAlerts());
}

// 异常输入测试：上限小于下限，应输出错误并保持原阈值
TEST_F(AlertManagerTest, testSetAltitudeThresholdsInvalid) {
    alert_manager.setAltitudeThresholds(100.0f, -50.0f);
    
    // 尝试设置无效的阈值
    alert_manager.setAltitudeThresholds(-100.0f, 200.0f);
    
    // 验证原阈值保持不变
    alert_manager.checkAltitudeAlert(75.0f, 1000);
    EXPECT_FALSE(alert_manager.hasActiveAlerts());
    
    alert_manager.checkAltitudeAlert(101.0f, 1001);
    EXPECT_TRUE(alert_manager.hasActiveAlerts());
}

// 特殊场景测试：设置阈值后，原有预警应被重置
TEST_F(AlertManagerTest, testSetAltitudeThresholdsResetAlerts) {
    alert_manager.setAltitudeThresholds(100.0f, -50.0f);
    
    // 触发预警
    alert_manager.checkAltitudeAlert(150.0f, 1000);
    EXPECT_TRUE(alert_manager.hasActiveAlerts());
    
    // 设置新阈值，应重置预警
    alert_manager.setAltitudeThresholds(200.0f, -100.0f);
    EXPECT_FALSE(alert_manager.hasActiveAlerts());
}

// 边界值测试：设置极大阈值
TEST_F(AlertManagerTest, testSetAltitudeThresholdsMaxValues) {
    float upper = std::numeric_limits<float>::max();
    float lower = -std::numeric_limits<float>::max();
    
    alert_manager.setAltitudeThresholds(upper, lower);
    
    // 验证阈值设置成功
    alert_manager.checkAltitudeAlert(0.0f, 1000);
    EXPECT_FALSE(alert_manager.hasActiveAlerts());
}

// 边界值测试：设置极小阈值
TEST_F(AlertManagerTest, testSetAltitudeThresholdsMinValues) {
    float upper = 0.0f;
    float lower = -std::numeric_limits<float>::max();
    
    alert_manager.setAltitudeThresholds(upper, lower);
    
    // 验证阈值设置成功
    alert_manager.checkAltitudeAlert(-100.0f, 1000);
    EXPECT_FALSE(alert_manager.hasActiveAlerts());
    
    alert_manager.checkAltitudeAlert(1.0f, 1001);
    EXPECT_TRUE(alert_manager.hasActiveAlerts());
}

// 特殊场景测试：连续多次设置阈值
TEST_F(AlertManagerTest, testSetAltitudeThresholdsMultipleTimes) {
    alert_manager.setAltitudeThresholds(100.0f, -50.0f);
    alert_manager.setAltitudeThresholds(200.0f, -100.0f);
    alert_manager.setAltitudeThresholds(300.0f, -150.0f);
    
    // 验证最后一次设置生效
    alert_manager.checkAltitudeAlert(250.0f, 1000);
    EXPECT_FALSE(alert_manager.hasActiveAlerts());
    
    alert_manager.checkAltitudeAlert(350.0f, 1001);
    EXPECT_TRUE(alert_manager.hasActiveAlerts());
}

// 特殊场景测试：设置阈值后立即检查预警状态
TEST_F(AlertManagerTest, testSetAltitudeThresholdsImmediateCheck) {
    alert_manager.setAltitudeThresholds(100.0f, -50.0f);
    
    // 触发预警
    alert_manager.checkAltitudeAlert(150.0f, 1000);
    EXPECT_TRUE(alert_manager.hasActiveAlerts());
    
    // 设置新阈值，预警被重置
    alert_manager.setAltitudeThresholds(200.0f, -100.0f);
    EXPECT_FALSE(alert_manager.hasActiveAlerts());
    
    // 立即检查，不应有预警
    alert_manager.checkAltitudeAlert(150.0f, 1001);
    EXPECT_FALSE(alert_manager.hasActiveAl