FlightLog.h

/***************************************************************************
 *   Copyright (C) 2026 by Stefan Kebekus                                  *
 *   stefan.kebekus@gmail.com                                              *
 *                                                                         *
 *   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, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
#pragma once
 
#include <memory>
 
#include <QGeoPath>
#include <QObjectBindableProperty>
#include <QQmlEngine>
#include <QTimer>
#include <QUuid>
#include <QVariant>
 
#include "GlobalObject.h"
#include "flightlog/Flight.h"
#include "flightlog/FlightDetector.h"
#include "geomaps/Waypoint.h"
 
using namespace Qt::Literals::StringLiterals;
 
namespace Flightlog {
 
class FlightLogStorage;
class FlightRecorder;

 
class FlightLog : public GlobalObject
{
    Q_OBJECT
    QML_ELEMENT
    QML_SINGLETON
 
public:
 
    //
    // Constructors and Destructors
    //

    explicit FlightLog(QObject* parent = nullptr);
 
    // deferred initialization
    void deferredInitialization() override;
 
    // No default constructor, important for QML singleton
    explicit FlightLog() = delete;

    ~FlightLog() override;
 
    // factory function for QML singleton
    static FlightLog* create(QQmlEngine* /*unused*/, QJSEngine* /*unused*/)
    {
        return GlobalObject::flightLog();
    }
 
 
    //
    // PROPERTIES
    //

    Q_PROPERTY(QList<Flightlog::Flight> flights READ flights NOTIFY flightsChanged)
    [[nodiscard]] auto flights() const -> QList<Flight> { return m_flights; }

    Q_PROPERTY(Flightlog::FlightDetector::DetectionState detectionState READ detectionState NOTIFY detectionStateChanged)
    [[nodiscard]] auto detectionState() const -> FlightDetector::DetectionState;

    Q_PROPERTY(int count READ count NOTIFY flightsChanged)
    [[nodiscard]] auto count() const -> int { return static_cast<int>(m_flights.value().size()); }

    Q_PROPERTY(QGeoPath displayedTrackPath READ displayedTrackPath NOTIFY displayedTrackPathChanged)
    [[nodiscard]] auto displayedTrackPath() const -> QGeoPath;

    Q_PROPERTY(QString displayedTrackUuid READ displayedTrackUuid NOTIFY displayedTrackPathChanged)
    [[nodiscard]] auto displayedTrackUuid() const -> QString;

    Q_PROPERTY(bool trackRecording READ trackRecording WRITE setTrackRecording NOTIFY trackRecordingChanged)
    [[nodiscard]] auto trackRecording() const -> bool;
    void setTrackRecording(bool enabled);

    Q_PROPERTY(bool showCurrentFlightTrace READ showCurrentFlightTrace WRITE setShowCurrentFlightTrace NOTIFY showCurrentFlightTraceChanged)
    [[nodiscard]] auto showCurrentFlightTrace() const -> bool;
    void setShowCurrentFlightTrace(bool enabled);
 
 
    //
    // Methods
    //

    Q_INVOKABLE void addFlight(const Flightlog::Flight& flight);

    Q_INVOKABLE void removeFlight(const QString& uuid);

    Q_INVOKABLE void removeFlights(const QStringList& uuids);

    Q_INVOKABLE void clearFlights();

    Q_INVOKABLE void updateFlight(const QString& uuid, const Flightlog::Flight& flight);

    Q_INVOKABLE static Flightlog::Flight createFlight(
        const QString& departureICAO,
        const QString& arrivalICAO,
        const QString& date,
        const QString& offBlockTimeStr,
        const QString& startTimeStr,
        const QString& landingTimeStr,
        const QString& onBlockTimeStr,
        const QString& pilotName,
        const QString& aircraftCallsign,
        const QString& comments);

    Q_INVOKABLE void endFlight();

    Q_INVOKABLE QString lastArrivalICAO(const QString& aircraftCallsign) const;

    Q_INVOKABLE static GeoMaps::Waypoint nearestAirfield(const QGeoCoordinate& position = {}, double proximityM = 5000.0);

    [[nodiscard]] Q_INVOKABLE QByteArray exportToIGC(const QString& uuid) const;

    [[nodiscard]] Q_INVOKABLE QByteArray exportToForeFlight(const QStringList& uuids) const;

    [[nodiscard]] Q_INVOKABLE QByteArray exportToJSON(const QStringList& uuids) const;

    [[nodiscard]] Q_INVOKABLE QString importFromJSON(const QString& fileName);

    Q_INVOKABLE void removeTrack(const QString& uuid);

    Q_INVOKABLE void showTrack(const QString& uuid);

    Q_INVOKABLE void hideTrack();
 
signals:
    void flightsChanged();

    void detectionStateChanged();

    void displayedTrackPathChanged();

    void trackRecordingChanged();

    void showCurrentFlightTraceChanged();

    void takeoffDetected(const QString& time);

    void landingDetected(const QString& time);

    void saveError(const QString& message);

    void backgroundLocationUnavailable(const QString& message);
 
private slots:
    // Process position updates — delegates to the active FlightDetector
    void onPositionUpdated();
 
    // Handle detection state change — forwards signal
    void onDetectionStateChanged();
 
    // Handle auto-detection setting change — manages Android foreground service.
    // userInitiated is true when the user changed the setting, and false for
    // the persisted setting at startup. Only a user-initiated change may show
    // a permission dialog.
    void onAutoFlightDetectionChanged(bool userInitiated);
 
#ifdef Q_OS_ANDROID
    // Posted after a grace period when auto-detection is on but no position
    // data is arriving. Cancelled when GPS resumes or detection is disabled.
    void onReceivingPositionInfoChanged(bool receiving);
 
    // Start or stop the Android foreground service to match the setting.
    // Starting fails without location permission (Android 14+). Then, if
    // userInitiated, request the permission and explain if it is declined;
    // otherwise stay silent and retry when the window regains focus.
    void updateForegroundService(bool userInitiated);
#endif
 
    // Handle takeoff detected by the FlightDetector
    void onTakeoffDetected(const QString& departureICAO,
                           const QGeoCoordinate& departureCoordinate,
                           const QDateTime& startTime,
                           const QString& aircraftCallsign);
 
    // Handle landing detected by the FlightDetector
    void onLandingDetected(const QString& arrivalICAO,
                           const QGeoCoordinate& arrivalCoordinate,
                           const QDateTime& landingTime,
                           int landingCount);
 
private:
    Q_DISABLE_COPY_MOVE(FlightLog)
 
    // Install signal connections for the given detector
    void connectDetector(FlightDetector* detector);
 
    // Load flights via m_storage
    void load();
 
    // Fill in a coordinate from its ICAO code via the GeoMapProvider, but
    // only if the coordinate isn't already set (e.g. from a real GPS fix)
    void resolveCoordinates(Flight& flight);
 
    // Sort flights by startTime descending
    void sortFlights(QList<Flight>& flights);
 
    // Collect the flights matching the given UUID strings; returns all flights if the list is empty
    [[nodiscard]] auto flightsForUuids(const QStringList& uuids) const -> QList<Flight>;
 
    // Helper to parse a date+time string to QDateTime
    static auto parseDateTime(const QString& date, const QString& timeStr) -> QDateTime;
 
    Q_OBJECT_BINDABLE_PROPERTY(FlightLog, QList<Flightlog::Flight>, m_flights, &FlightLog::flightsChanged)
 
    // UUID of the flight currently being recorded, or null if none
    QUuid m_currentFlightUuid;
 
    // Filename of the flight whose saved track is displayed, or empty
    QString m_displayedTrackFile;
 
    // Cached geo path for the displayed saved track
    QGeoPath m_displayedTrackPath;
 
    // The active flight detector (owned by this object)
    FlightDetector* m_detector {nullptr};
 
    // The flight recorder (owned by this object)
    std::unique_ptr<FlightRecorder> m_recorder;
 
    // The persistent storage backend (owned by this object)
    std::unique_ptr<FlightLogStorage> m_storage;
 
#ifdef Q_OS_ANDROID
    // True if the last start of the Android foreground service was accepted
    // and stop() has not been called since. Java (FlightLogService.start())
    // owns the actual running state; this flag only decides whether to stop.
    bool m_foregroundServiceRunning {false};
 
    // Fires after a grace period to post the "no GPS" notification. Started
    // when auto-detection is enabled with no position data; cancelled when
    // position arrives or auto-detection is disabled.
    QTimer m_noGPSTimer;
#endif
};
 
} // namespace Flightlog