#include <iostream>
#include <cassert>
#include <cmath>
#include <string>

#include "app.hpp"
#include "altitude_calculator.hpp"
#include "data_logger.hpp"
#include "sensor_simulator.hpp"
#include "alert_manager.hpp"

/**
 * @brief 测试高度计算器基本功能
 */
void testAltitudeCalculator() {
    std::cout << "测试高度计算器..." << std::endl;
    
    // 1. 测试构造函数和默认值
    AltitudeCalculator calc1;
    assert(calc1.getSeaLevelPressure() == 1013.25f);
    
    // 2. 测试自定义海平面气压
    AltitudeCalculator calc2(1020.0f);
    assert(std::fabs(calc2.getSeaLevelPressure() - 1020.0f) < 0.001f);
    
    // 3. 测试高度计算（已知值测试）
    // 在标准大气压下，1013.25 hPa 应该对应0米高度
    float altitude1 = calc1.calculateAltitude(1013.25f);
    assert(std::fabs(altitude1) < 1.0f);  // 允许1米误差
    
    // 4. 测试相对高度计算
    float relative1 = AltitudeCalculator::calculateRelativeHeight(100.0f, 50.0f);
    assert(std::fabs(relative1 - 50.0f) < 0.001f);
    
    float relative2 = AltitudeCalculator::calculateRelativeHeight(50.0f, 100.0f);
    assert(std::fabs(relative2 + 50.0f) < 0.001f);  // 负值
    
    // 5. 测试单位转换
    float meters = 100.0f;
    float feet = AltitudeCalculator::metersToFeet(meters);
    float meters_back = AltitudeCalculator::feetToMeters(feet);
    assert(std::fabs(meters - meters_back) < 0.001f);
    
    // 6. 测试气压有效性检查
    assert(AltitudeCalculator::isValidPressure(1013.25f) == true);
    assert(AltitudeCalculator::isValidPressure(500.0f) == true);
    assert(AltitudeCalculator::isValidPressure(200.0f) == false);  // 太低
    assert(AltitudeCalculator::isValidPressure(1200.0f) == false); // 太高
    
    // 7. 测试高度有效性检查
    assert(AltitudeCalculator::isValidAltitude(0.0f) == true);
    assert(AltitudeCalculator::isValidAltitude(1000.0f) == true);
    assert(AltitudeCalculator::isValidAltitude(10000.0f) == false); // 太高
    assert(AltitudeCalculator::isValidAltitude(-600.0f) == false);  // 太低
    
    std::cout << "高度计算器测试通过！" << std::endl;
}

/**
 * @brief 测试数据记录器基本功能
 */
void testDataLogger() {
    std::cout << "\n测试数据记录器..." << std::endl;
    
    // 1. 测试构造函数
    DataLogger logger(10);  // 小容量便于测试
    assert(logger.getCapacity() == 10);
    assert(logger.getRecordCount() == 0);
    assert(logger.isFull() == false);
    assert(logger.getAvailableSpace() == 10);
    
    // 2. 测试添加记录
    uint32_t timestamp1 = 1234567890;
    float altitude1 = 100.5f;
    
    bool added1 = logger.addRecord(timestamp1, altitude1, 'm', 0);
    assert(added1 == true);
    assert(logger.getRecordCount() == 1);
    assert(logger.getAvailableSpace() == 9);
    
    // 3. 测试获取记录
    const HSM_Record_t* record1 = logger.getRecord(0);
    assert(record1 != nullptr);
    assert(record1->timestamp == timestamp1);
    assert(std::fabs(record1->altitude - altitude1) < 0.001f);
    assert(record1->unit == 'm');
    assert(record1->status == 0);
    
    // 4. 测试添加更多记录
    for (int i = 0; i < 9; ++i) {
        bool added = logger.addRecord(timestamp1 + i + 1, altitude1 + i + 1, 'm', 0);
        assert(added == true);
    }
    
    assert(logger.getRecordCount() == 10);
    assert(logger.isFull() == true);
    assert(logger.getAvailableSpace() == 0);
    
    // 5. 测试环形缓冲区特性（添加第11条记录应该覆盖第一条）
    bool added11 = logger.addRecord(timestamp1 + 10, altitude1 + 10, 'm', 0);
    assert(added11 == true);
    assert(logger.getRecordCount() == 10);  // 仍然是10条
    assert(logger.isFull() == true);
    
    // 6. 测试获取最近记录
    auto recent = logger.getRecentRecords(3);
    assert(recent.size() == 3);
    
    // 最近的三条记录应该是最后添加的
    if (recent.size() >= 3) {
        assert(recent[0].timestamp == timestamp1 + 10);
        assert(recent[1].timestamp == timestamp1 + 9);
        assert(recent[2].timestamp == timestamp1 + 8);
    }
    
    // 7. 测试按时间范围获取记录
    auto range_records = logger.getRecordsByTimeRange(timestamp1 + 5, timestamp1 + 8);
    assert(range_records.size() == 4);  // 时间戳5,6,7,8
    
    // 8. 测试清空
    logger.clear();
    assert(logger.getRecordCount() == 0);
    assert(logger.getAvailableSpace() == 10);
    
    std::cout << "数据记录器测试通过！" << std::endl;
}

/**
 * @brief 测试传感器模拟器基本功能
 */
void testSensorSimulator() {
    std::cout << "\n测试传感器模拟器..." << std::endl;
    
    // 1. 测试构造函数和初始化
    SensorSimulator sensor(1013.25f, 0.1f);
    assert(sensor.initialize() == true);
    assert(sensor.isSensorNormal() == true);
    assert(sensor.getBufferSize() == 100);
    assert(sensor.getDataCount() == 0);
    
    // 2. 测试读取传感器数据
    auto data1 = sensor.readSensor();
    assert(sensor.getDataCount() == 1);
    assert(data1.pressure > 0.0f);
    assert(data1.timestamp_ms > 0);
    
    // 3. 测试获取当前气压
    float pressure1 = sensor.getCurrentPressure();
    assert(pressure1 > 0.0f);
    
    // 4. 测试获取缓冲区数据
    // 先读取几次数据
    for (int i = 0; i < 5; ++i) {
        sensor.readSensor();
    }
    assert(sensor.getDataCount() == 6);  // 包括第一次
    
    auto buffer_data = sensor.getBufferData(3);
    assert(buffer_data.size() == 3);
    
    // 5. 测试设置传感器状态
    sensor.setSensorStatus(false);
    assert(sensor.isSensorNormal() == false);
    
    sensor.setSensorStatus(true);
    assert(sensor.isSensorNormal() == true);
    
    // 6. 测试设置基础气压
    float new_base = 1000.0f;
    sensor.setBasePressure(new_base);
    
    // 7. 测试设置噪声水平
    float new_noise = 1.0f;
    sensor.setNoiseLevel(new_noise);
    
    // 8. 测试清空缓冲区
    sensor.clearBuffer();
    assert(sensor.getDataCount() == 0);
    
    std::cout << "传感器模拟器测试通过！" << std::endl;
}

/**
 * @brief 测试预警管理器基本功能
 */
void testAlertManager() {
    std::cout << "\n测试预警管理器..." << std::endl;
    
    // 1. 测试构造函数和初始化
    AlertManager alertManager;
    alertManager.initialize();
    
    assert(alertManager.getUpperThreshold() == 100.0f);
    assert(alertManager.getLowerThreshold() == -50.0f);
    assert(alertManager.hasActiveAlerts() == false);
    assert(alertManager.hasUnacknowledgedAlerts() == false);
    assert(alertManager.isSensorNormal() == true);
    
    // 2. 测试设置预警阈值
    alertManager.setAltitudeThresholds(200.0f, -100.0f);
    assert(std::fabs(alertManager.getUpperThreshold() - 200.0f) < 0.001f);
    assert(std::fabs(alertManager.getLowerThreshold() + 100.0f) < 0.001f);
    
    // 3. 测试高度预警
    uint32_t timestamp = 1234567890;
    
    // 测试上限预警
    alertManager.checkAltitudeAlert(250.0f, timestamp);  // 超过上限
    assert(alertManager.hasActiveAlerts() == true);
    
    auto active_alerts1 = alertManager.getActiveAlerts();
    assert(active_alerts1.size() >= 1);
    
    // 测试恢复正常
    alertManager.checkAltitudeAlert(150.0f, timestamp + 1);  // 恢复正常
    // 预警应该被标记为已解决
    
    // 测试下限预警
    alertManager.checkAltitudeAlert(-150.0f, timestamp + 2);  // 低于下限
    assert(alertManager.hasActiveAlerts() == true);
    
    // 4. 测试传感器故障预警
    alertManager.triggerSensorFailure(timestamp + 3);
    assert(alertManager.isSensorNormal() == false);
    
    // 5. 测试预警确认
    assert(alertManager.hasUnacknowledgedAlerts() == true);
    alertManager.acknowledgeAllAlerts(timestamp + 4);
    
    auto active_alerts2 = alertManager.getActiveAlerts();
    for (const auto& alert : active_alerts2) {
        assert(alert.status == AlertStatus::ACKNOWLEDGED || 
               alert.status == AlertStatus::RESOLVED);
    }
    
    // 6. 测试获取预警历史
    auto history = alertManager.getAlertHistory(5);
    assert(history.size() > 0);
    
    // 7. 测试重置预警
    alertManager.resetAllAlerts();
    assert(alertManager.hasActiveAlerts() == false);
    
    // 8. 测试低电量预警
    alertManager.triggerLowBattery(timestamp + 5, 15.0f);
    assert(alertManager.hasActiveAlerts() == true);
    
    // 9. 测试通信错误预警
    alertManager.triggerCommunicationError(timestamp + 6);
    
    // 10. 测试清空历史
    alertManager.clearHistory();
    
    std::cout << "预警管理器测试通过！" << std::endl;
}

/**
 * @brief 测试应用主类基本功能
 */
void testApp() {
    std::cout << "\n测试应用主类..." << std::endl;
    
    // 1. 测试构造函数和初始化
    HeightMeasurementApp app;
    assert(app.isRunning() == false);
    
    bool init_result = app.initialize();
    assert(init_result == true);
    
    // 2. 测试启动和停止
    app.start();
    assert(app.isRunning() == true);
    
    // 3. 测试获取高度（应该是0，因为还没执行零点归位）
    float altitude1 = app.getCurrentAltitude();
    // 注意：由于传感器模拟，实际值可能不是0，但应该在合理范围内
    assert(std::fabs(altitude1) < 1000.0f);
    
    // 4. 测试零点归位
    bool zero_result = app.performZeroReset();
    assert(zero_result == true);
    
    // 5. 测试设置预警阈值
    app.setAlertThresholds(150.0f, -80.0f);
    
    // 6. 测试测量循环
    bool measure_result = app.measureCycle();
    assert(measure_result == true);
    
    // 7. 测试获取相对高度
    float relative = app.getRelativeHeight();
    // 相对高度应该在合理范围内
    
    // 8. 测试获取状态信息
    std::string status = app.getStatus();
    assert(status.length() > 0);
    assert(status.find("高度测量系统状态") != std::string::npos);
    
    // 9. 测试停止
    app.stop();
    assert(app.isRunning() == false);
    
    std::cout << "应用主类测试通过！" << std::endl;
}

/**
 * @brief 主测试函数
 */
int main() {
    std::cout << "=== 高度测量系统基本功能测试 ===\n" << std::endl;
    
    try {
        testAltitudeCalculator();
        testDataLogger();
        testSensorSimulator();
        testAlertManager();
        testApp();
        
        std::cout << "\n=== 所有测试通过！ ===" << std::endl;
        return 0;
        
    } catch (const std::exception& e) {
        std::cerr << "\n测试失败，异常信息: " << e.what() << std::endl;
        return 1;
    } catch (...) {
        std::cerr << "\n测试失败，未知异常" << std::endl;
        return 1;
    }
}