pilotclient/src/blackmisc/aviation/comsystem.h

// SPDX-FileCopyrightText: Copyright (C) 2013 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1

//! \file

#ifndef BLACKMISC_AVIATION_COMSYSTEM_H
#define BLACKMISC_AVIATION_COMSYSTEM_H

#include "blackmisc/aviation/modulator.h"
#include "blackmisc/metaclass.h"
#include "blackmisc/pq/constants.h"
#include "blackmisc/pq/frequency.h"
#include "blackmisc/pq/physicalquantity.h"
#include "blackmisc/pq/units.h"
#include "blackmisc/pq/pqstring.h"
#include "blackmisc/blackmiscexport.h"
#include "blackmisc/mixin/mixinindex.h"
#include "blackmisc/mixin/mixinhash.h"
#include "blackmisc/mixin/mixinjson.h"
#include "blackmisc/mixin/mixinmetatype.h"

#include <QHash>
#include <QJsonObject>
#include <QMetaType>
#include <QString>
#include <tuple>

namespace BlackMisc::Aviation
{
    //! COM system (aka "radio")
    class BLACKMISC_EXPORT CComSystem :
        public CModulator<CComSystem>,
        public Mixin::MetaType<CComSystem>,
        public Mixin::JsonOperators<CComSystem>,
        public Mixin::Index<CComSystem>
    {
    public:
        //! Base type
        using base_type = CModulator<CComSystem>;

        BLACKMISC_DECLARE_USING_MIXIN_METATYPE(CComSystem)
        BLACKMISC_DECLARE_USING_MIXIN_INDEX(CComSystem)

        //! Channel spacing frequency
        enum ChannelSpacing
        {
            ChannelSpacing50KHz, //!< 50kHz
            ChannelSpacing25KHz, //!< 25kHz
            ChannelSpacing8_33KHz //!< 8.33kHz
        };

        //! COM unit
        enum ComUnit
        {
            Com1,
            Com2
        };

        //! Default constructor
        CComSystem() {}

        //! Constructor
        CComSystem(const QString &name, const PhysicalQuantities::CFrequency &activeFrequency, const PhysicalQuantities::CFrequency &standbyFrequency = { 0, PhysicalQuantities::CFrequencyUnit::nullUnit() }) : CModulator(name, activeFrequency, standbyFrequency.isNull() ? activeFrequency : standbyFrequency)
        {}

        //! Set active frequency
        //! \remarks will be rounded to channel spacing
        void setFrequencyActiveMHz(double frequencyMHz);

        //! Set standby frequency
        //! \remarks will be rounded to channel spacing
        void setFrequencyStandbyMHz(double frequencyMHz);

        //! Set active frequency
        //! \remarks will be rounded to channel spacing
        void setFrequencyActive(const PhysicalQuantities::CFrequency &frequency);

        //! Set active frequency
        //! \remarks will be rounded to channel spacing
        void setFrequencyStandby(const PhysicalQuantities::CFrequency &frequency);

        //! Is active frequency the same frequency
        bool isActiveFrequencySameFrequency(const PhysicalQuantities::CFrequency &comFrequency) const;

        //! Set UNICOM frequency as active
        void setActiveUnicom();

        //! Set International Air Distress 121.5MHz
        void setActiveInternationalAirDistress();

        //! Get channel spacing
        ChannelSpacing getChannelSpacing() const { return m_channelSpacing; }

        //! Set channel spacing
        void setChannelSpacing(ChannelSpacing spacing) { m_channelSpacing = spacing; }

        //! COM1 unit
        static CComSystem getCom1System(double activeFrequencyMHz, double standbyFrequencyMHz = -1);

        //! COM1 unit
        static CComSystem getCom1System(const PhysicalQuantities::CFrequency &activeFrequency,
                                        const PhysicalQuantities::CFrequency &standbyFrequency = { 0, PhysicalQuantities::CFrequencyUnit::nullUnit() });
        //! COM2 unit
        static CComSystem getCom2System(double activeFrequencyMHz, double standbyFrequencyMHz = -1);

        //! COM2 unit
        static CComSystem getCom2System(const PhysicalQuantities::CFrequency &activeFrequency,
                                        const PhysicalQuantities::CFrequency &standbyFrequency = { 0, PhysicalQuantities::CFrequencyUnit::nullUnit() });

        //! Valid civil aviation frequency?
        static bool isValidCivilAviationFrequency(const PhysicalQuantities::CFrequency &f);

        //! Valid military aviation frequency?
        static bool isValidMilitaryFrequency(const PhysicalQuantities::CFrequency &f);

        //! Valid COM frequency (either civil or military)
        static bool isValidComFrequency(const PhysicalQuantities::CFrequency &f);

        //! Round to channel spacing, set MHz as unit
        //! \see ChannelSpacing
        static void roundToChannelSpacing(PhysicalQuantities::CFrequency &frequency,
                                          ChannelSpacing channelSpacing);

        //! Compare frequencies under consideration that on VATSIM
        //! frequencies .x20/.x25 and .x70/.x75 are the same
        static bool isSameFrequency(const PhysicalQuantities::CFrequency &freq1,
                                    const PhysicalQuantities::CFrequency &freq2);

        //! Is passed frequency in kHz a valid 8.33 channel. This does not check if
        //! the frequency is within the correct bounds.
        static bool isValid8_33kHzChannel(int fKHz);

        //! Round passed frequency in kHz to 8.33 frequency spacing
        static int round8_33kHzChannel(int fKHz);

        //! Is frequency a "new" 8.33 kHz frequency and not within 25 kHz spacing
        //! E.g. returns false for 122.825 but true for 118.305
        static bool isExclusiveWithin8_33kHzChannel(const PhysicalQuantities::CFrequency &freq);

        //! Is frequency within 25 kHz frequency spacing
        static bool isWithin25kHzChannel(const PhysicalQuantities::CFrequency &freq);

        //! Parses almost any shitty string to a valid COM frequency
        static PhysicalQuantities::CFrequency parseComFrequency(const QString &input, PhysicalQuantities::CPqString::SeparatorMode sep);

        //! \copydoc BlackMisc::CValueObject::registerMetadata
        static void registerMetadata();

    private:
        ChannelSpacing m_channelSpacing = ChannelSpacing8_33KHz; //!< channel spacing

        //! Give me channel spacing in KHz
        //! \remarks Just a helper method, that is why no CFrequency is returned
        static double channelSpacingToFrequencyKHz(ChannelSpacing channelSpacing);

        BLACK_METACLASS(
            CComSystem,
            BLACK_METAMEMBER(channelSpacing)
        );
    };
} // namespace

Q_DECLARE_METATYPE(BlackMisc::Aviation::CComSystem)
Q_DECLARE_METATYPE(BlackMisc::Aviation::CComSystem::ChannelSpacing)
Q_DECLARE_METATYPE(BlackMisc::Aviation::CComSystem::ComUnit)

#endif // guard