CollisionAvoidance/src/mock/MockDataService.cpp

#include "mock/MockDataService.h"
#include <format>
#include <sstream>
#include <iomanip>

MockDataService::MockDataService(const AirportBounds& bounds)
    : bounds_(bounds)
{
}

std::vector<Aircraft> MockDataService::generateAircraftData() {
    std::vector<Aircraft> aircraft;
    
    // 生成跑道上的航空器
    for (int i = 0; i < 5; ++i) {
        Aircraft a;
        a.flightNo = generateAircraftId();
        a.position = generatePosition(AreaType::RUNWAY);
        a.speed = generateSpeed(AreaType::RUNWAY);
        a.heading = generateHeading(AreaType::RUNWAY);
        a.altitude = generateAltitude(AreaType::RUNWAY);
        aircraft.push_back(a);
    }
    
    // 生成滑行道上的航空器
    for (int i = 0; i < 10; ++i) {
        Aircraft a;
        a.flightNo = generateAircraftId();
        a.position = generatePosition(AreaType::TAXIWAY);
        a.speed = generateSpeed(AreaType::TAXIWAY);
        a.heading = generateHeading(AreaType::TAXIWAY);
        a.altitude = generateAltitude(AreaType::TAXIWAY);
        aircraft.push_back(a);
    }
    
    // 生成停机位的航空器
    for (int i = 0; i < 15; ++i) {
        Aircraft a;
        a.flightNo = generateAircraftId();
        a.position = generatePosition(AreaType::GATE);
        a.speed = generateSpeed(AreaType::GATE);
        a.heading = generateHeading(AreaType::GATE);
        a.altitude = generateAltitude(AreaType::GATE);
        aircraft.push_back(a);
    }
    
    return aircraft;
}

std::vector<Vehicle> MockDataService::generateVehicleData() {
    std::vector<Vehicle> vehicles;
    
    // 生成服务区的车辆
    for (int i = 0; i < 20; ++i) {
        Vehicle v;
        v.vehicleNo = generateVehicleId();
        v.position = generatePosition(AreaType::SERVICE);
        v.speed = generateSpeed(AreaType::SERVICE);
        v.heading = generateHeading(AreaType::SERVICE);
        vehicles.push_back(v);
    }
    
    // 生成停机位的车辆
    for (int i = 0; i < 15; ++i) {
        Vehicle v;
        v.vehicleNo = generateVehicleId();
        v.position = generatePosition(AreaType::GATE);
        v.speed = generateSpeed(AreaType::GATE);
        v.heading = generateHeading(AreaType::GATE);
        vehicles.push_back(v);
    }
    
    return vehicles;
}

Vector2D MockDataService::generatePosition(AreaType areaType) {
    const auto& config = bounds_.getAreaConfig(areaType);
    const auto& areaBounds = bounds_.getAreaBounds(areaType);
    
    std::uniform_real_distribution<double> x_dist(areaBounds.x, 
                                                areaBounds.x + areaBounds.width);
    std::uniform_real_distribution<double> y_dist(areaBounds.y, 
                                                areaBounds.y + areaBounds.height);
    
    return {x_dist(rng_), y_dist(rng_)};
}

double MockDataService::generateSpeed(AreaType areaType) {
    // 根据区域类型返回合适的速度范围
    switch (areaType) {
        case AreaType::RUNWAY:
            return std::uniform_real_distribution<double>{30.0, 80.0}(rng_);
        case AreaType::TAXIWAY:
            return std::uniform_real_distribution<double>{5.0, 15.0}(rng_);
        case AreaType::GATE:
            return std::uniform_real_distribution<double>{0.0, 5.0}(rng_);
        case AreaType::SERVICE:
            return std::uniform_real_distribution<double>{0.0, 10.0}(rng_);
        default:
            return 0.0;
    }
}

double MockDataService::generateHeading(AreaType areaType) {
    // 根据区域类型返回合适的航向范围
    switch (areaType) {
        case AreaType::RUNWAY:
            // 跑道通常只有两个方向
            return std::uniform_int_distribution<int>{0, 1}(rng_) * 180.0;
        default:
            // 其他区域可以是任意方向
            return std::uniform_real_distribution<double>{0.0, 360.0}(rng_);
    }
}

double MockDataService::generateAltitude(AreaType areaType) {
    // 根据区域类型返回合适的高度范围
    switch (areaType) {
        case AreaType::RUNWAY:
            return std::uniform_real_distribution<double>{0.0, 15.0}(rng_);
        case AreaType::TAXIWAY:
            return std::uniform_real_distribution<double>{0.0, 5.0}(rng_);
        default:
            return 0.0;
    }
}

std::string MockDataService::generateAircraftId() {
    std::stringstream ss;
    ss << "AC" << std::setw(4) << std::setfill('0') << ++aircraftCounter_;
    return ss.str();
}

std::string MockDataService::generateVehicleId() {
    std::stringstream ss;
    ss << "VH" << std::setw(4) << std::setfill('0') << ++vehicleCounter_;
    return ss.str();
}

std::vector<TrafficLightSignal> MockDataService::generateTrafficLightData() {
    std::vector<TrafficLightSignal> signals;
    
    // 生成 5-10 个红绿灯信号
    std::uniform_int_distribution<> numSignals(5, 10);
    int count = numSignals(rng_);
    
    for (int i = 0; i < count; ++i) {
        TrafficLightSignal signal;
        signal.trafficLightId = generateTrafficLightId();
        signal.status = generateTrafficLightState();
        signal.timestamp = std::chrono::system_clock::now().time_since_epoch().count();
        signals.push_back(signal);
    }
    
    return signals;
}

std::string MockDataService::generateTrafficLightId() {
    std::stringstream ss;
    ss << "TL" << std::setw(4) << std::setfill('0') << ++trafficLightCounter_;
    return ss.str();
}

SignalStatus MockDataService::generateTrafficLightState() {
    std::uniform_int_distribution<> dist(0, 2);
    int state = dist(rng_);
    return static_cast<SignalStatus>(state);
}