// Stub enums for AudioVideoManagement when BUILD_RTI is OFF
// These enums are normally generated from avm_enums.idl by RTI DDS tools
// This file provides minimal definitions for building without RTI

#ifndef AVM_ENUMS_STUB_HPP
#define AVM_ENUMS_STUB_HPP

#include <QString>

namespace AudioVideoManagement {

// RcOperatingMode enum wrapper with inner_enum typedef and underlying() method
struct RcOperatingMode {
    enum Type {
        FixedFreqEncNone = 0,
        FixedFreqEncHwKr = 1,
        FixedFreqEncHwKrKl = 2,
        AkwEncNone = 3,
        AkwEncEccm = 4,
        SIMPLEX = 5,
        HALFDUPLEX = 6,
        DUPLEX = 7
    };
    using inner_enum = Type;
    
    Type value;
    constexpr RcOperatingMode(Type v = FixedFreqEncNone) : value(v) {}
    constexpr operator Type() const { return value; }
    int underlying() const { return static_cast<int>(value); }
    
    static constexpr Type FixedFreqEncNone_v = FixedFreqEncNone;
    static constexpr Type FixedFreqEncHwKr_v = FixedFreqEncHwKr;
    static constexpr Type FixedFreqEncHwKrKl_v = FixedFreqEncHwKrKl;
    static constexpr Type AkwEncNone_v = AkwEncNone;
    static constexpr Type AkwEncEccm_v = AkwEncEccm;
    static constexpr Type SIMPLEX_v = SIMPLEX;
    static constexpr Type HALFDUPLEX_v = HALFDUPLEX;
    static constexpr Type DUPLEX_v = DUPLEX;
};

// FrequencyBand enum wrapper with inner_enum typedef and underlying() method
struct FrequencyBand {
    enum Type {
        Undefined = 0,
        HF = 1,
        VHF = 2,
        UHF = 3,
        REL = 4
    };
    using inner_enum = Type;
    
    Type value;
    constexpr FrequencyBand(Type v = Undefined) : value(v) {}
    constexpr operator Type() const { return value; }
    int underlying() const { return static_cast<int>(value); }
    
    static constexpr Type Undefined_v = Undefined;
    static constexpr Type HF_v = HF;
    static constexpr Type VHF_v = VHF;
    static constexpr Type UHF_v = UHF;
    static constexpr Type REL_v = REL;
};

// FrequencyBand_def namespace for legacy code compatibility
namespace FrequencyBand_def {
    constexpr int HF = 1;
    constexpr int UHF = 3;
    constexpr int VHF = 2;
    constexpr int REL = 4;
}

// RcOperatingMode_def namespace for legacy code compatibility
namespace RcOperatingMode_def {
    constexpr int FixedFreqEncNone = 0;
    constexpr int FixedFreqEncHwKr = 1;
    constexpr int FixedFreqEncHwKrKl = 2;
    constexpr int AkwEncNone = 3;
    constexpr int AkwEncEccm = 4;
    constexpr int SIMPLEX = 5;
    constexpr int HALFDUPLEX = 6;
    constexpr int DUPLEX = 7;
}

// ModulationType enum wrapper with inner_enum typedef and underlying() method
struct ModulationType {
    enum Type {
        AM = 0,
        FM = 1
    };
    using inner_enum = Type;
    
    Type value;
    constexpr ModulationType(Type v = AM) : value(v) {}
    constexpr operator Type() const { return value; }
    int underlying() const { return static_cast<int>(value); }
};

// ChannelSpacingHF enum wrapper with inner_enum typedef and underlying() method
struct ChannelSpacingHF {
    enum Type {
        CS_100_Hz = 0
    };
    using inner_enum = Type;
    
    Type value;
    constexpr ChannelSpacingHF(Type v = CS_100_Hz) : value(v) {}
    constexpr operator Type() const { return value; }
    int underlying() const { return static_cast<int>(value); }
};

// ChannelSpacing enum wrapper with inner_enum typedef and underlying() method
struct ChannelSpacing {
    enum Type {
        CS_25_00_kHz = 0,
        CS_12_50_kHz = 1,
        CS_8_33_kHz = 2
    };
    using inner_enum = Type;
    
    Type value;
    constexpr ChannelSpacing(Type v = CS_25_00_kHz) : value(v) {}
    constexpr operator Type() const { return value; }
    int underlying() const { return static_cast<int>(value); }
};

} // namespace AudioVideoManagement

#endif // AVM_ENUMS_STUB_HPP