ISSTracker.cpp

Go to the documentation of this file.

/*
    MetaImGUI
    Copyright (C) 2026  A P Nicholson
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/
 
#include "ISSTracker.h"
 
#include "HttpClient.h"
#include "Logger.h"
 
#include <nlohmann/json.hpp>
 
#include <chrono>
#include <stop_token>
#include <thread>
 
namespace MetaImGUI {
 
ISSTracker::ISSTracker() : m_tracking(false) {}
 
ISSTracker::~ISSTracker() {
    StopTracking();
}
 
void ISSTracker::StartTracking(std::function<void(const ISSPosition&)> callback) {
    const std::lock_guard<std::mutex> lock(m_threadMutex);
 
    if (m_tracking) {
        LOG_INFO("ISS Tracker: Already tracking, skipping");
        return;
    }
 
    m_tracking = true;
 
    // Store callback under lock protection
    {
        const std::lock_guard<std::mutex> callbackLock(m_callbackMutex);
        m_callback = callback;
    }
 
    // C++20: std::jthread with stop_token for clean cancellation
    // jthread creates its own stop_source internally
    m_trackingThread = std::jthread([this](const std::stop_token& stopToken) { TrackingLoop(stopToken); });
 
    LOG_INFO("ISS Tracker: Started tracking");
}
 
void ISSTracker::StopTracking() {
    const std::lock_guard<std::mutex> lock(m_threadMutex);
 
    if (!m_tracking) {
        return;
    }
 
    // Request stop using jthread's internal stop_source
    m_trackingThread.request_stop();
    m_tracking = false;
 
    LOG_INFO("ISS Tracker: Stopped tracking");
}
 
bool ISSTracker::IsTracking() const {
    return m_tracking;
}
 
ISSPosition ISSTracker::GetCurrentPosition() const {
    const std::lock_guard<std::mutex> lock(m_dataMutex);
    return m_currentPosition;
}
 
void ISSTracker::GetPositionHistory(std::vector<double>& latitudes, std::vector<double>& longitudes) const {
    const std::lock_guard<std::mutex> lock(m_dataMutex);
 
    latitudes.clear();
    longitudes.clear();
    latitudes.reserve(m_positionHistory.size());
    longitudes.reserve(m_positionHistory.size());
 
    for (const auto& pos : m_positionHistory) {
        if (pos.valid) {
            latitudes.push_back(pos.latitude);
            longitudes.push_back(pos.longitude);
        }
    }
}
 
ISSPosition ISSTracker::FetchPositionSync() {
    return FetchPositionImpl(std::stop_token{});
}
 
void ISSTracker::TrackingLoop(const std::stop_token& stopToken) {
    while (!stopToken.stop_requested()) {
        try {
            const ISSPosition position = FetchPositionImpl(stopToken);
 
            // Check if stop was requested after fetch (important for slow networks)
            if (stopToken.stop_requested()) {
                LOG_INFO("ISS Tracker: Stop requested, discarding fetched data");
                break;
            }
 
            if (position.valid) {
                // Update current position and add to history
                {
                    const std::lock_guard<std::mutex> lock(m_dataMutex);
                    m_currentPosition = position;
                    AddToHistory(position);
                }
 
                // Invoke callback if set (copy under lock to avoid data race)
                std::function<void(const ISSPosition&)> callback;
                {
                    const std::lock_guard<std::mutex> lock(m_callbackMutex);
                    callback = m_callback;
                }
 
                if (callback) {
                    try {
                        callback(position);
                    } catch (const std::exception& e) {
                        LOG_ERROR("ISS Tracker: Callback threw exception: {}", e.what());
                    } catch (...) {
                        LOG_ERROR("ISS Tracker: Callback threw unknown exception");
                    }
                }
 
                LOG_INFO("ISS Tracker: Position updated - Lat: {}, Long: {}, Alt: {} km, Vel: {} km/h",
                         position.latitude, position.longitude, position.altitude, position.velocity);
            }
        } catch (const std::exception& e) {
            LOG_ERROR("ISS Tracker: Error fetching position: {}", e.what());
        } catch (...) {
            LOG_ERROR("ISS Tracker: Unknown error fetching position");
        }
 
        // Wait 5 seconds before next update (if not stopped)
        auto start = std::chrono::steady_clock::now();
        while (!stopToken.stop_requested()) {
            auto now = std::chrono::steady_clock::now();
            auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(now - start).count();
            if (elapsed >= 5) {
                break;
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }
    }
 
    LOG_INFO("ISS Tracker: Tracking loop exited");
}
 
ISSPosition ISSTracker::FetchPositionImpl(const std::stop_token& stopToken) {
    ISSPosition position;
    position.valid = false;
 
    try {
        const HttpClient http;
        // 30s timeout, two retries to ride out flaky mobile networks. The
        // wheretheiss.at endpoint is public and unauthenticated.
        const HttpRequest request{.url = ISS_API_URL,
                                  .userAgent = "MetaImGUI-ISSTracker/1.0",
                                  .timeout = std::chrono::seconds{30},
                                  .maxRetries = 2};
        const HttpResponse response = http.Get(request, stopToken);
 
        if (response.status == HttpStatus::Cancelled) {
            return position; // Caller checks stop_token after we return.
        }
        if (response.status != HttpStatus::Ok) {
            LOG_ERROR("ISS Tracker: HTTP fetch failed (status={})", static_cast<int>(response.status));
            return position;
        }
        if (response.body.empty()) {
            LOG_ERROR("ISS Tracker: Empty response from server");
            return position;
        }
 
        position = ParseJSON(response.body);
    } catch (const std::bad_alloc& e) {
        LOG_ERROR("ISS Tracker: Memory allocation failed: {}", e.what());
    } catch (const std::exception& e) {
        LOG_ERROR("ISS Tracker: Fetch failed: {}", e.what());
    } catch (...) {
        LOG_ERROR("ISS Tracker: Unknown error during fetch");
    }
 
    return position;
}
 
ISSPosition ISSTracker::ParseJSON(const std::string& jsonResponse) {
    ISSPosition position;
    position.valid = false;
 
    try {
        auto json = nlohmann::json::parse(jsonResponse);
 
        // Parse required fields
        if (json.contains("latitude") && json.contains("longitude")) {
            position.latitude = json["latitude"].get<double>();
            position.longitude = json["longitude"].get<double>();
 
            // Parse optional fields
            if (json.contains("altitude")) {
                position.altitude = json["altitude"].get<double>();
            }
            if (json.contains("velocity")) {
                position.velocity = json["velocity"].get<double>();
            }
            if (json.contains("timestamp")) {
                position.timestamp = json["timestamp"].get<long>();
            }
 
            position.valid = true;
        } else {
            LOG_ERROR("ISS Tracker: Missing required fields in JSON response");
        }
    } catch (const nlohmann::json::parse_error& e) {
        LOG_ERROR("ISS Tracker: JSON parse error: {}", e.what());
    } catch (const nlohmann::json::type_error& e) {
        LOG_ERROR("ISS Tracker: JSON type error: {}", e.what());
    } catch (const std::exception& e) {
        LOG_ERROR("ISS Tracker: Error parsing JSON: {}", e.what());
    }
 
    return position;
}
 
void ISSTracker::AddToHistory(const ISSPosition& position) {
    // Note: Caller must hold m_dataMutex
 
    if (!position.valid) {
        return;
    }
 
    // Add to history
    m_positionHistory.push_back(position);
 
    // Keep only the last maxHistorySize positions
    while (m_positionHistory.size() > m_maxHistorySize) {
        m_positionHistory.pop_front();
    }
}
 
} // namespace MetaImGUI