TrafficFactor_Abstract.h

/***************************************************************************
 *   Copyright (C) 2021-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 <QObjectBindableProperty>
#include <QTimer>
 
#include "units/Distance.h"
 
using namespace std::chrono_literals;
 
 
namespace Traffic {
 
// Plain-data record fed into updateFrom()/replaceBy(); defined in TrafficFactorData.h
struct TrafficFactorData;

 
class TrafficFactor_Abstract : public QObject {
    Q_OBJECT
    QML_ELEMENT
 
public:
    enum Type : quint8
    {
        unknown, 
        Aircraft, 
        Airship, 
        Balloon, 
        Copter, 
        Drone, 
        Glider, 
        HangGlider, 
        Jet, 
        Paraglider, 
        Skydiver, 
        StaticObstacle, 
        TowPlane 
    };
    Q_ENUM(Type) // Register the enum with Qt's meta-object system
 
    
    explicit TrafficFactor_Abstract(QObject* parent = nullptr);
 
    // Standard destructor
    ~TrafficFactor_Abstract() override;
 
 
    //
    // Methods
    //

    [[nodiscard]] bool hasHigherPriorityThan(const TrafficFactor_Abstract& rhs) const;

    [[nodiscard]] static bool isRelevant(Units::Distance hDist, Units::Distance vDist);

    void startLifetime();
 
 
    //
    // PROPERTIES
    //

    Q_PROPERTY(int alarmLevel READ alarmLevel WRITE setAlarmLevel BINDABLE bindableAlarmLevel)

    Q_PROPERTY(bool animate READ animate BINDABLE bindableAnimate)

    Q_PROPERTY(QString callSign READ callSign WRITE setCallSign BINDABLE bindableCallSign)

    Q_PROPERTY(QString color READ color BINDABLE bindableColor)

    Q_PROPERTY(QString description READ description BINDABLE bindableDescription)

    Q_PROPERTY(Units::Distance hDist READ hDist WRITE setHDist BINDABLE bindableHDist)

    Q_PROPERTY(QString ID READ ID WRITE setID BINDABLE bindableID)

    Q_PROPERTY(bool relevant READ relevant BINDABLE bindableRelevant)

    Q_PROPERTY(QString relevantString READ relevantString BINDABLE bindableRelevantString)

    Q_PROPERTY(Type type READ type WRITE setType BINDABLE bindableType)

    Q_PROPERTY(QString typeString READ typeString BINDABLE bindableTypeString)

    Q_PROPERTY(bool valid READ valid BINDABLE bindableValid)

    Q_PROPERTY(Units::Distance vDist READ vDist WRITE setVDist BINDABLE bindableVDist)
 
 
    //
    // Getter/Setter Methods
    //

    [[nodiscard]] int alarmLevel() const {return m_alarmLevel.value();}

    [[nodiscard]] QBindable<int> bindableAlarmLevel() {return &m_alarmLevel;}

    [[nodiscard]] bool animate() const {return m_animate.value();}

    [[nodiscard]] QBindable<bool> bindableAnimate() {return &m_animate;}

    [[nodiscard]] QString callSign() const {return m_callSign.value();}

    [[nodiscard]] QBindable<QString> bindableCallSign() const {return &m_callSign;}

    [[nodiscard]] QString color() const {return m_color.value();}

    [[nodiscard]] QBindable<QString> bindableColor() const {return &m_color;}

    [[nodiscard]] QString description() const {return m_description.value();}

    [[nodiscard]] QBindable<QString> bindableDescription() const {return &m_description;}

    [[nodiscard]] Units::Distance hDist() const {return m_hDist.value();}

    [[nodiscard]] QBindable<Units::Distance> bindableHDist() {return &m_hDist;}

    [[nodiscard]] QString ID() const {return m_ID.value();}

    [[nodiscard]] QBindable<QString> bindableID() const {return &m_ID;}

    [[nodiscard]] bool relevant() const {return m_relevant.value();}

    [[nodiscard]] QBindable<bool> bindableRelevant() {return &m_relevant;}

    [[nodiscard]] QString relevantString() const {return m_relevantString.value();}

    [[nodiscard]] QBindable<QString> bindableRelevantString() {return &m_relevantString;}

    [[nodiscard]] TrafficFactor_Abstract::Type type() const {return m_type.value();}

    [[nodiscard]] QBindable<TrafficFactor_Abstract::Type> bindableType() {return &m_type;}

    [[nodiscard]] QString typeString() const {return m_typeString.value();}

    [[nodiscard]] QBindable<QString> bindableTypeString() {return &m_typeString;}

    [[nodiscard]] bool valid() const {return m_valid.value();}

    [[nodiscard]] QBindable<bool> bindableValid() {return &m_valid;}

    [[nodiscard]] Units::Distance vDist() const {return m_vDist.value();}

    [[nodiscard]] QBindable<Units::Distance> bindableVDist() {return &m_vDist;}
 
 
    //
    // Setter Methods
    //

    void setAlarmLevel(int newAlarmLevel)
    {
        // Safety checks
        if ((newAlarmLevel < 0) || (newAlarmLevel > 3)) {
            return;
        }
        startLifetime();
        m_alarmLevel = newAlarmLevel;
    }

    void setCallSign(const QString& newCallSign) {m_callSign = newCallSign;}

    void setHDist(Units::Distance newHDist) {m_hDist = newHDist;}

    void setID(const QString& newID) {m_ID = newID;}

    void setType(TrafficFactor_Abstract::Type newType) {m_type = newType;}

    void setVDist(Units::Distance newVDist) {m_vDist = newVDist;}
 
 
    //
    // Constants
    //

    static constexpr auto lifetime = 45s;

    static constexpr Units::Distance maxVerticalDistance = Units::Distance::fromM(1500.0);

    static constexpr Units::Distance maxHorizontalDistance = Units::Distance::fromNM(20.0);
 
protected:
    QProperty<bool> m_valid {false};
 
    QProperty<QString> m_description;
 
    // Indicates that the instance is valid as an abstract traffic factor
    QProperty<bool> m_validAbstractTrafficFactor;

    void updateFrom(const TrafficFactorData& data);

    void replaceBy(const TrafficFactorData& data);

    static constexpr qsizetype idMatchLength = 6;

    [[nodiscard]] bool isSameFactorAs(const TrafficFactorData& data) const;
 
private:
    Q_DISABLE_COPY_MOVE(TrafficFactor_Abstract)
 
    //
    // Property values
    //
    QProperty<int> m_alarmLevel {0};
    QProperty<bool> m_animate {false};
    QProperty<QString> m_callSign;
    QProperty<QString> m_color {QStringLiteral("red")};
    QProperty<Units::Distance> m_hDist;
    QProperty<QString> m_ID;
    QProperty<Type> m_type {unknown};
    QProperty<bool> m_relevant {false};
    QProperty<QString> m_relevantString;
    QProperty<QString> m_typeString;
    QProperty<Units::Distance> m_vDist;
 
    // Timer for timeout. Traffic objects become invalid if their data has not
    // been refreshed for longer than "lifetime". The "valid" binding reads
    // lifetimeCounter.isActive(); QTimer notifies that (bindable) property when
    // the single-shot timer expires, so the binding reacts to expiry
    // automatically.
    QTimer lifetimeCounter;
};
 
} // namespace Traffic