#pragma once
#include "saatelegrams_export.h"
#include <QChar>
#include <QDateTime>
#include <QJsonArray>
#include <QJsonObject>
#include <QString>
#include <QUuid>
#include <QVector>

#include <ProjectDataManagement/pdm_enums.hpp>

namespace AdlerJson
{

namespace JsonKeys
{

inline QString DATA() { return QStringLiteral("data"); }
inline QString UUID_() { return QStringLiteral("uuid"); }
inline QString TYPE() { return QStringLiteral("type"); }
inline QString TYPE_ID() { return QStringLiteral("typeId"); }
inline QString TIMESTAMP() { return QStringLiteral("timestamp"); }

inline QString VERSION() { return QStringLiteral("version"); }
inline QString SENDER() { return QStringLiteral("sender"); }
inline QString RECEIVER() { return QStringLiteral("receiver"); }
inline QString REFERENCE_UUID() { return QStringLiteral("referenceUuid"); }
inline QString AFE() { return QStringLiteral("Afe"); }
inline QString PARTY_ID() { return QStringLiteral("partyId"); }
inline QString ADLER_VERBUND() { return QStringLiteral("adlerVerbund"); }
inline QString SZENAR() { return QStringLiteral("szenar"); }
inline QString STATUS() { return QStringLiteral("status"); }




inline QString JAHR() { return QStringLiteral("jahr"); }
inline QString MONAT() { return QStringLiteral("monat"); }
inline QString TAG() { return QStringLiteral("tag"); }
inline QString STUNDEN() { return QStringLiteral("stunden"); }
inline QString MINUTEN() { return QStringLiteral("minuten"); }
inline QString SEKUNDEN() { return QStringLiteral("sekunden"); }
inline QString ZDS() { return QStringLiteral("zds"); }
inline QString ZDM() { return QStringLiteral("zdm"); }
inline QString ZVZ() { return QStringLiteral("zvz"); }



inline QString EX_AWES_PLANNING() { return QStringLiteral("  EX-FQ(BA-BB-FK)"); } 
inline QString EX_MANUAL_REPLY() { return QStringLiteral("EX-MQ"); }              
inline QString EX_READY_TO_FIRE() { return QStringLiteral("EX-FQ(FB)"); }         
inline QString EX_FIRE() { return QStringLiteral("EX-FQ(FN)"); }                  
inline QString EX_FIRED() { return QStringLiteral("EX-FQ(AF)"); }                 
inline QString EX_ENFORCEMENT() { return QStringLiteral("EX-FQ(VM)"); }           
inline QString EX_FIRE_HALT() { return QStringLiteral("EX-FH"); }                 
inline QString EX_DONT_FIRE() { return QStringLiteral("EX-FQ(nFN)"); }
inline QString EX_POSITION_REPORT_FIRE() { return QStringLiteral("EX-SQ(FS)"); }              
inline QString EX_POSITION_REPORT_WEAPON() { return QStringLiteral("EX-SQ(WS)"); }            
inline QString EX_POSITION_REPORT_LOADING_PLACE() { return QStringLiteral("EX-SQ(LP)"); }     
inline QString EX_EXPLORATION_RESULTS() { return QStringLiteral("EX-Erkundungsergebnisse"); } 
inline QString EX_FIRE_FIGHT() { return QStringLiteral("EX-FQ(BA-BB)"); }                     
inline QString EX_POSITION_CHANGED() { return QStringLiteral("EX-Stellungswechsel"); }        
inline QString EX_GUIDING_LINES() { return QStringLiteral("EX-HQ(K)"); }                      
inline QString EX_GUIDING_LINES_AND_BOUNDARIES() { return QStringLiteral("EX-HQ(G)"); }       
inline QString EX_AQ() { return QStringLiteral("EX-AQ"); }                                    
inline QString EX_FLUGBAHNBERECHNUNG() { return QStringLiteral("EX-Flugbahnberechnung"); }    
inline QString EX_FLUGBAHNDATEN() { return QStringLiteral("EX-Flugbahndaten"); }              




inline QString EX_REGISTRATION_REQUEST() { return QStringLiteral("EX-Anmeldung"); }
inline QString EX_REGISTRATION_CONFIRMATION() { return QStringLiteral("EX-Anmeldebestaetigung"); }
inline QString EX_DEREGISTRATION_REQUEST() { return QStringLiteral("EX-Abmeldung"); }
inline QString EX_STATUS() { return QStringLiteral("EX-Status"); }
inline QString EX_CONNECTION_TEST_REQUEST() { return QStringLiteral("EX-Verbindungsanfrage"); }
inline QString EX_CONNECTION_TEST_REPLY() { return QStringLiteral("EX-Verbindungsantwort"); }
inline QString EX_TQ() { return QStringLiteral("EX-TQ"); }




inline QString FEUERKAMPFREFERENZ() { return QStringLiteral("feuerkampfReferenz"); }
inline QString ZIELDATEN() { return QStringLiteral("zieldaten"); }
inline QString NUMMER() { return QStringLiteral("nummer"); }
inline QString GEOMETRIE() { return QStringLiteral("geometrie"); }
inline QString KOORDINATE() { return QStringLiteral("koordinate"); }
inline QString KOORDINATEN() { return QStringLiteral("koordinaten"); }
inline QString ZIELKOORDINATE() { return QStringLiteral("zielkoordinate"); }
inline QString STANDORT() { return QStringLiteral("standort"); }
inline QString LATITUDE() { return QStringLiteral("latitude"); }
inline QString LONGITUDE() { return QStringLiteral("longitude"); }
inline QString HOEHE() { return QStringLiteral("hoehe"); }
inline QString MAXGIPFEL() { return QStringLiteral("maxGipfel"); }
inline QString RELATIV_KOORDINATE() { return QStringLiteral("relativKoordinate"); }
inline QString BREITE_RADIUS() { return QStringLiteral("breiteRadius"); }
inline QString RADIUS() { return QStringLiteral("radius"); }
inline QString TIEFE() { return QStringLiteral("tiefe"); }
inline QString ZIELACHSE() { return QStringLiteral("zielachse"); }
inline QString ZOG() { return QStringLiteral("zog"); }
inline QString ELEMENTE() { return QStringLiteral("elemente"); }
inline QString TYP() { return QStringLiteral("typ"); }
inline QString SUB_TYP() { return QStringLiteral("subTyp"); }
inline QString ABFEUERUNGSART() { return QStringLiteral("abfeuerungsArt"); }
inline QString ART() { return QStringLiteral("art"); }
inline QString FORDERUNG() { return QStringLiteral("forderung"); }
inline QString DAUER() { return QStringLiteral("dauer"); }

inline QString FEUERKOMMANDO() { return QStringLiteral("feuerkommando"); }
inline QString VEREIN() { return QStringLiteral("verein"); }
inline QString WIRKMITTEL() { return QStringLiteral("wirkmittel"); }
inline QString WIRKMITTELRAKETE() { return QStringLiteral("wirkmittelRakete"); }
inline QString KENNER() { return QStringLiteral("kenner"); }
inline QString AUFTREFFPUNKT() { return QStringLiteral("auftreffpunkt"); }
inline QString TREFFPUNKTE() { return QStringLiteral("treffpunkte"); }
inline QString FLUGZEIT() { return QStringLiteral("flugzeit"); }
inline QString GIPFELHOEHE() { return QStringLiteral("gipfelhoehe"); }
inline QString SCHUSSRICHTUNG() { return QStringLiteral("schussrichtung"); }
inline QString GESCHOSS() { return QStringLiteral("geschoss"); }
inline QString GESCHOSSE() { return QStringLiteral("geschosse"); }
inline QString GESCHOSSSORTE() { return QStringLiteral("geschosssorte"); }
inline QString LADUNG() { return QStringLiteral("ladung"); }
inline QString LADUNGSNUMMER() { return QStringLiteral("ladungsNummer"); }
inline QString ZUENDER() { return QStringLiteral("zuender"); }
inline QString ZUENDERFUNKTION() { return QStringLiteral("zuenderFunktion"); }
inline QString ZUENDER_ZEIT() { return QStringLiteral("zuenderZeit"); }
inline QString ANZAHL() { return QStringLiteral("anzahl"); }
inline QString INTERVALL() { return QStringLiteral("intervall"); }
inline QString FLUGBAHNPUNKT() { return QStringLiteral("flugbahnpunkt"); }
inline QString SPRENGHOEHE() { return QStringLiteral("sprenghoehe"); }
inline QString ZEIT() { return QStringLiteral("zeit"); }
inline QString X_RELATIV() { return QStringLiteral("xRelativ"); }
inline QString Y_RELATIV() { return QStringLiteral("yRelativ"); }
inline QString Z_RELATIV() { return QStringLiteral("zRelativ"); }
inline QString STREUUNG() { return QStringLiteral("streuung"); }
inline QString LAENGS_STREUUNG() { return QStringLiteral("laengsstreuung"); }
inline QString SEITEN_STREUUNG() { return QStringLiteral("seitenstreuung"); }
inline QString LAENGS_STREUUNG_H() { return QStringLiteral("laengsstreuungH"); }
inline QString SEITEN_STREUUNG_H() { return QStringLiteral("seitenstreuungH"); }
inline QString EINHEIT() { return QStringLiteral("einheit"); }
inline QString FEUEREINHEIT() { return QStringLiteral("feuereinheit"); }
inline QString MITTELPUNKT() { return QStringLiteral("mittelpunkt"); }
inline QString GRUNDRICHTUNG() { return QStringLiteral("grundrichtung"); }
inline QString WINKELGRUPPE() { return QStringLiteral("winkelgruppe"); }
inline QString LINKS() { return QStringLiteral("links"); }
inline QString RECHTS() { return QStringLiteral("rechts"); }
inline QString WIRKUNGSBEREICH() { return QStringLiteral("wirkungsbereich"); }
inline QString NAME() { return QStringLiteral("name"); }
inline QString TRUPPENTEIL() { return QStringLiteral("truppenteil"); }

inline QString MELDUNGSNUMMER() { return QStringLiteral("meldungsnummer"); }
inline QString AB() { return QStringLiteral("ab"); }
inline QString BIS() { return QStringLiteral("bis"); }
inline QString LINKERNACHBAR() { return QStringLiteral("linkerNachbar"); }
inline QString RECHTERNACHBAR() { return QStringLiteral("rechterNachbar"); }
inline QString BESCHREIBUNG() { return QStringLiteral("beschreibung"); }
inline QString FREITEXT() { return QStringLiteral("freitext"); }
inline QString KATEGORIE() { return QStringLiteral("kategorie"); }
inline QString FEUERKAMPF() { return QStringLiteral("feuerkampf"); }
inline QString ZPNUMMER() { return QStringLiteral("zpNummer"); }
inline QString OI() { return QStringLiteral("oi"); }
inline QString R() { return QStringLiteral("r"); }
inline QString WAFFENPLAETZE() { return QStringLiteral("waffenplaetze"); }
inline QString WAFFENSYSTEM() { return QStringLiteral("waffensystem"); }
inline QString STELLUNGEN() { return QStringLiteral("stellungen"); }
inline QString TEXTVAL() { return QStringLiteral("text"); }
inline QString FEHLERCODE() { return QStringLiteral("fehlercode"); }
inline QString FALLWINKEL() { return QStringLiteral("fallwinkel"); }
inline QString ERRORTEXT() { return QStringLiteral("error"); }
inline QString ANFLUG() { return QStringLiteral("anflug"); }
inline QString GPS() { return QStringLiteral("gps"); }
inline QString WIRKZEIT() { return QStringLiteral("wirkzeit"); }
inline QString ENTLADENSCHUSS() { return QStringLiteral("entladenSchuss"); }

inline QString ABFEUERUNGSZEIT() { return QStringLiteral("abfeuerungsZeit"); }

} 

namespace TelegramIds
{
static constexpr int EX_REGISTRATION_REQUEST() { return 6007; }      
static constexpr int EX_DEREGISTRATION_REQUEST() { return 6009; }    
static constexpr int EX_REGISTRATION_CONFIRMATION() { return 6008; } 
static constexpr int EX_CONNECTION_TEST_REQUEST() { return 6011; }   
static constexpr int EX_CONNECTION_TEST_REPLY() { return 6012; }     
static constexpr int EX_STATUS() { return 6010; }                    


static constexpr int EX_AWES_PLANNING() { return 1000; }                 
static constexpr int EX_MANUAL_REPLY() { return 1001; }                  
static constexpr int EX_READY_TO_FIRE() { return 1002; }                 
static constexpr int EX_FIRE() { return 1003; }                          
static constexpr int EX_FIRED() { return 1004; }                         
static constexpr int EX_ENFORCEMENT() { return 1005; }                   
static constexpr int EX_FIRE_HALT() { return 1006; }                     
static constexpr int EX_DONT_FIRE() { return 1007; }                     
static constexpr int EX_POSITION_REPORT_FIRE() { return 2000; }          
static constexpr int EX_POSITION_REPORT_WEAPON() { return 2001; }        
static constexpr int EX_POSITION_REPORT_LOADING_PLACE() { return 2002; } 
static constexpr int EX_EXPLORATION_RESULTS() { return 5000; }           
static constexpr int EX_FIRE_FIGHT() { return 19; }                      
static constexpr int EX_POSITION_CHANGED() { return 20; }                
static constexpr int EX_GUIDING_LINES() { return 3000; }                 
static constexpr int EX_GUIDING_LINES_AND_BOUNDARIES() { return 3001; }  
static constexpr int EX_TQ() { return 6013; }                            
static constexpr int EX_AQ() { return 5001; }                            

static constexpr int EX_FLUGBAHNBERECHNUNG() { return 4000; } 
static constexpr int EX_FLUGBAHNDATEN() { return 4001; }      

} 


struct SAATELEGRAMS_EXPORT Zeitangabe_DTG
{
  int stunden;
  int minuten;
  int sekunden;
  int tag;
  int monat;
  int jahr;
  QString ZVz;
  QString ZDS;
  QString ZDM;
};



struct SAATELEGRAMS_EXPORT SAATelegram
{
  virtual QJsonObject toJson() = 0;

  explicit SAATelegram() {}
  virtual ~SAATelegram() {}

  public:
  template <typename T> QJsonObject toJsonInternal();
};
template <> QJsonObject SAATelegram::toJsonInternal<SAATelegram>();


struct SAATELEGRAMS_EXPORT EXTelegramBase : public SAATelegram
{
  QString typeName;
  int typeId;
  QString uuid;
  QString version;
  QString sender;
  QString receiver;
  QString referenceUuid;
  QString timestamp;

  EXTelegramBase(const QString &typeName, int typeId)
      : typeName(typeName)
      , typeId(typeId)
      , uuid(QUuid::createUuid().toString(QUuid::WithoutBraces))
  {
  }

  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};
template <> QJsonObject EXTelegramBase::toJsonInternal<SAATelegram>();
template <> QJsonObject EXTelegramBase::toJsonInternal<EXTelegramBase>();



struct SAATELEGRAMS_EXPORT EXRegistration : public EXTelegramBase
{
  int partyId;
  bool adlerVerbund;
  QString szenar;

  EXRegistration()
      : EXTelegramBase(JsonKeys::EX_REGISTRATION_REQUEST(), TelegramIds::EX_REGISTRATION_REQUEST())
  {
  }

  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};

template <> QJsonObject EXRegistration::toJsonInternal<EXRegistration>();


















struct SAATELEGRAMS_EXPORT EXDeregistration : EXTelegramBase
{
  int partyId;
  EXDeregistration()
      : EXTelegramBase(JsonKeys::EX_DEREGISTRATION_REQUEST(), TelegramIds::EX_DEREGISTRATION_REQUEST())
  {
  }

  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};
template <> QJsonObject EXDeregistration::toJsonInternal<EXDeregistration>();

struct SAATELEGRAMS_EXPORT EXConnectionTestRequest : public EXTelegramBase
{
  EXConnectionTestRequest()
      : EXTelegramBase(JsonKeys::EX_CONNECTION_TEST_REQUEST(), TelegramIds::EX_CONNECTION_TEST_REQUEST())
  {
  }
  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};
struct SAATELEGRAMS_EXPORT EXConnectionTestReply : public EXTelegramBase
{
  EXConnectionTestReply()
      : EXTelegramBase(JsonKeys::EX_CONNECTION_TEST_REPLY(), TelegramIds::EX_CONNECTION_TEST_REPLY())
  {
  }
  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};

enum class Szenarstatus
{
  Inaktiv,  
  Geplant,  
  Aktiv,    
  Gestoppt, 
};
QString SAATELEGRAMS_EXPORT szenarstatusToStr(Szenarstatus status);
Szenarstatus SAATELEGRAMS_EXPORT strToSzenarstatus(QString status);

struct SAATELEGRAMS_EXPORT EXStatus : public EXTelegramBase
{
  Szenarstatus status;

  EXStatus()
      : EXTelegramBase(JsonKeys::EX_STATUS(), TelegramIds::EX_STATUS())
  {
  }

  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};
void SAATELEGRAMS_EXPORT statusFromJson(const QJsonObject &data, EXStatus &eXStatus, bool &bOk);





template <> QJsonObject EXStatus::toJsonInternal<EXStatus>();





struct SAATELEGRAMS_EXPORT Koordinate
{
  double latitude;  
  double longitude; 
};


struct SAATELEGRAMS_EXPORT KoordinateMitHoehe
{
  Koordinate koordinate; 
  int hoehe;             
};


enum class SAATELEGRAMS_EXPORT Abfeuerungsart
{
  A, 
  B, 
  F, 
  T, 
  K, 
};


enum SAATELEGRAMS_EXPORT Art_L24
{
  AL,     
  ANL,    
  AO,     
  ATRZ,   
  BAA,    
  BCA,    
  BDRY,   
  BHA,    
  CAA,    
  CCA,    
  CFL,    
  CFZ,    
  CHA,    
  CP,     
  CZ,     
  EA,     
  EZ,     
  FLET,   
  FLOT,   
  FOAZI,  
  FOAZII, 
  IZ,     
  LZ,     
  MA,     
  NAI,    
  OA,     
  PL,     
  ROTACA, 
  ROTAHA, 
  ROTARA, 
  ROUTE,  
  RP,     
  SP,     
  TAI,    
  FEBA,   
  VZL,    
  MFLD,   
  ZOF,    
  TAREA,  
  PP,     
  AMA,    
  ARA     
};


const QMap<QString, ProjectDataManagement::L26_EffectingSystemType> waffensystemtypMap = {
    {QStringLiteral("Pzh2000"), ProjectDataManagement::L26_EffectingSystemType::Pzh2000},
    {QStringLiteral("RRohr"), ProjectDataManagement::L26_EffectingSystemType::RRohr},
    {QStringLiteral("Mars"), ProjectDataManagement::L26_EffectingSystemType::Mars},
};


const QMap<QString, ProjectDataManagement::L27_EffectorId> waffensystemkennerMap = {
    {QStringLiteral("A"), ProjectDataManagement::L27_EffectorId::A},        
    {QStringLiteral("B"), ProjectDataManagement::L27_EffectorId::B},        
    {QStringLiteral("C"), ProjectDataManagement::L27_EffectorId::C},        
    {QStringLiteral("D"), ProjectDataManagement::L27_EffectorId::D},        
    {QStringLiteral("E"), ProjectDataManagement::L27_EffectorId::E},        
    {QStringLiteral("F"), ProjectDataManagement::L27_EffectorId::F},        
    {QStringLiteral("G"), ProjectDataManagement::L27_EffectorId::G},        
    {QStringLiteral("H"), ProjectDataManagement::L27_EffectorId::H},        
    {QStringLiteral("I"), ProjectDataManagement::L27_EffectorId::I},        
    {QStringLiteral("J"), ProjectDataManagement::L27_EffectorId::J},        
    {QStringLiteral("K"), ProjectDataManagement::L27_EffectorId::K},        
    {QStringLiteral("L"), ProjectDataManagement::L27_EffectorId::L},        
    {QStringLiteral("M"), ProjectDataManagement::L27_EffectorId::M},        
    {QStringLiteral("N"), ProjectDataManagement::L27_EffectorId::N},        
    {QStringLiteral("O"), ProjectDataManagement::L27_EffectorId::O},        
    {QStringLiteral("P"), ProjectDataManagement::L27_EffectorId::P},        
    {QStringLiteral("Q"), ProjectDataManagement::L27_EffectorId::Q},        
    {QStringLiteral("R"), ProjectDataManagement::L27_EffectorId::R},        
    {QStringLiteral("S"), ProjectDataManagement::L27_EffectorId::S},        
    {QStringLiteral("T"), ProjectDataManagement::L27_EffectorId::T},        
    {QStringLiteral("U"), ProjectDataManagement::L27_EffectorId::U},        
    {QStringLiteral("V"), ProjectDataManagement::L27_EffectorId::V},        
    {QStringLiteral("W"), ProjectDataManagement::L27_EffectorId::W},        
    {QStringLiteral("X"), ProjectDataManagement::L27_EffectorId::X},        
    {QStringLiteral("Y"), ProjectDataManagement::L27_EffectorId::Y},        
    {QStringLiteral("Z"), ProjectDataManagement::L27_EffectorId::Z},        
    {QStringLiteral("B1"), ProjectDataManagement::L27_EffectorId::B1},      
    {QStringLiteral("B2"), ProjectDataManagement::L27_EffectorId::B2},      
    {QStringLiteral("B3"), ProjectDataManagement::L27_EffectorId::B3},      
    {QStringLiteral("B4"), ProjectDataManagement::L27_EffectorId::B4},      
    {QStringLiteral("B5"), ProjectDataManagement::L27_EffectorId::B5},      
    {QStringLiteral("B6"), ProjectDataManagement::L27_EffectorId::B6},      
    {QStringLiteral("B7"), ProjectDataManagement::L27_EffectorId::B7},      
    {QStringLiteral("B8"), ProjectDataManagement::L27_EffectorId::B8},      
    {QStringLiteral("C1"), ProjectDataManagement::L27_EffectorId::C1},      
    {QStringLiteral("C2"), ProjectDataManagement::L27_EffectorId::C2},      
    {QStringLiteral("C3"), ProjectDataManagement::L27_EffectorId::C3},      
    {QStringLiteral("C4"), ProjectDataManagement::L27_EffectorId::C4},      
    {QStringLiteral("C5"), ProjectDataManagement::L27_EffectorId::C5},      
    {QStringLiteral("C6"), ProjectDataManagement::L27_EffectorId::C6},      
    {QStringLiteral("C7"), ProjectDataManagement::L27_EffectorId::C7},      
    {QStringLiteral("C8"), ProjectDataManagement::L27_EffectorId::C8},      
    {QStringLiteral("211"), ProjectDataManagement::L27_EffectorId::NO_211}, 
    {QStringLiteral("212"), ProjectDataManagement::L27_EffectorId::NO_212}, 
    {QStringLiteral("213"), ProjectDataManagement::L27_EffectorId::NO_213}, 
    {QStringLiteral("214"), ProjectDataManagement::L27_EffectorId::NO_214}, 
    {QStringLiteral("215"), ProjectDataManagement::L27_EffectorId::NO_215}, 
    {QStringLiteral("216"), ProjectDataManagement::L27_EffectorId::NO_216}, 
    {QStringLiteral("217"), ProjectDataManagement::L27_EffectorId::NO_217}, 
    {QStringLiteral("218"), ProjectDataManagement::L27_EffectorId::NO_218}, 
    {QStringLiteral("221"), ProjectDataManagement::L27_EffectorId::NO_221}, 
    {QStringLiteral("222"), ProjectDataManagement::L27_EffectorId::NO_222}, 
    {QStringLiteral("223"), ProjectDataManagement::L27_EffectorId::NO_223}, 
    {QStringLiteral("224"), ProjectDataManagement::L27_EffectorId::NO_224}, 
    {QStringLiteral("225"), ProjectDataManagement::L27_EffectorId::NO_225}, 
    {QStringLiteral("226"), ProjectDataManagement::L27_EffectorId::NO_226}, 
    {QStringLiteral("227"), ProjectDataManagement::L27_EffectorId::NO_227}, 
    {QStringLiteral("228"), ProjectDataManagement::L27_EffectorId::NO_228}, 
    {QStringLiteral("311"), ProjectDataManagement::L27_EffectorId::NO_311}, 
    {QStringLiteral("312"), ProjectDataManagement::L27_EffectorId::NO_312}, 
    {QStringLiteral("313"), ProjectDataManagement::L27_EffectorId::NO_313}, 
    {QStringLiteral("314"), ProjectDataManagement::L27_EffectorId::NO_314}, 
    {QStringLiteral("315"), ProjectDataManagement::L27_EffectorId::NO_315}, 
    {QStringLiteral("316"), ProjectDataManagement::L27_EffectorId::NO_316}, 
    {QStringLiteral("317"), ProjectDataManagement::L27_EffectorId::NO_317}, 
    {QStringLiteral("318"), ProjectDataManagement::L27_EffectorId::NO_318}, 
    {QStringLiteral("321"), ProjectDataManagement::L27_EffectorId::NO_321}, 
    {QStringLiteral("322"), ProjectDataManagement::L27_EffectorId::NO_322}, 
    {QStringLiteral("323"), ProjectDataManagement::L27_EffectorId::NO_323}, 
    {QStringLiteral("324"), ProjectDataManagement::L27_EffectorId::NO_324}, 
    {QStringLiteral("325"), ProjectDataManagement::L27_EffectorId::NO_325}, 
    {QStringLiteral("326"), ProjectDataManagement::L27_EffectorId::NO_326}, 
    {QStringLiteral("327"), ProjectDataManagement::L27_EffectorId::NO_327}, 
    {QStringLiteral("328"), ProjectDataManagement::L27_EffectorId::NO_328}, 
    {QStringLiteral("411"), ProjectDataManagement::L27_EffectorId::NO_411}, 
    {QStringLiteral("412"), ProjectDataManagement::L27_EffectorId::NO_412}, 
    {QStringLiteral("413"), ProjectDataManagement::L27_EffectorId::NO_413}, 
    {QStringLiteral("414"), ProjectDataManagement::L27_EffectorId::NO_414}, 
    {QStringLiteral("415"), ProjectDataManagement::L27_EffectorId::NO_415}, 
    {QStringLiteral("416"), ProjectDataManagement::L27_EffectorId::NO_416}, 
    {QStringLiteral("417"), ProjectDataManagement::L27_EffectorId::NO_417}, 
    {QStringLiteral("418"), ProjectDataManagement::L27_EffectorId::NO_418}, 
    {QStringLiteral("421"), ProjectDataManagement::L27_EffectorId::NO_421}, 
    {QStringLiteral("422"), ProjectDataManagement::L27_EffectorId::NO_422}, 
    {QStringLiteral("423"), ProjectDataManagement::L27_EffectorId::NO_423}, 
    {QStringLiteral("424"), ProjectDataManagement::L27_EffectorId::NO_424}, 
    {QStringLiteral("425"), ProjectDataManagement::L27_EffectorId::NO_425}, 
    {QStringLiteral("426"), ProjectDataManagement::L27_EffectorId::NO_426}, 
    {QStringLiteral("427"), ProjectDataManagement::L27_EffectorId::NO_427}, 
    {QStringLiteral("428"), ProjectDataManagement::L27_EffectorId::NO_428}, 
    {QStringLiteral("511"), ProjectDataManagement::L27_EffectorId::NO_511}, 
    {QStringLiteral("512"), ProjectDataManagement::L27_EffectorId::NO_512}, 
    {QStringLiteral("513"), ProjectDataManagement::L27_EffectorId::NO_513}, 
    {QStringLiteral("514"), ProjectDataManagement::L27_EffectorId::NO_514}, 
    {QStringLiteral("515"), ProjectDataManagement::L27_EffectorId::NO_515}, 
    {QStringLiteral("516"), ProjectDataManagement::L27_EffectorId::NO_516}, 
    {QStringLiteral("517"), ProjectDataManagement::L27_EffectorId::NO_517}, 
    {QStringLiteral("518"), ProjectDataManagement::L27_EffectorId::NO_518}, 
    {QStringLiteral("521"), ProjectDataManagement::L27_EffectorId::NO_521}, 
    {QStringLiteral("522"), ProjectDataManagement::L27_EffectorId::NO_522}, 
    {QStringLiteral("523"), ProjectDataManagement::L27_EffectorId::NO_523}, 
    {QStringLiteral("524"), ProjectDataManagement::L27_EffectorId::NO_524}, 
    {QStringLiteral("525"), ProjectDataManagement::L27_EffectorId::NO_525}, 
    {QStringLiteral("526"), ProjectDataManagement::L27_EffectorId::NO_526}, 
    {QStringLiteral("527"), ProjectDataManagement::L27_EffectorId::NO_527}, 
    {QStringLiteral("528"), ProjectDataManagement::L27_EffectorId::NO_528}  
};


enum SAATELEGRAMS_EXPORT Status_L32
{
  INV, 
  DAT, 
};












enum class SAATELEGRAMS_EXPORT Winkelgruppe
{
  Untere = 0, 
  Obere = 1   
};


enum class SAATELEGRAMS_EXPORT FlugbahnberechnungFehlercode
{
  Ok = 0,                  
  MinimaleEntfernung = 1,  
  MaximaleEntfernung = 2,  
  GeschossKombination = 3, 
  Ungueltig = 4,           
};


enum class SAATELEGRAMS_EXPORT L45_AnmeldebestaetigungFehlercode
{
  Ok = 0,       
  Doppelt = 1,  
  Mehrfach = 2, 
  Belegt = 3    
};


struct SAATELEGRAMS_EXPORT Einheit
{
  QString verein; 
  int r;
  ProjectDataManagement::L19_Oi oi; 
};


struct SAATELEGRAMS_EXPORT Geschoss
{
  QString geschosssorte; 
  QString ladung;        
  QString zuender;       
  int anzahl{0};
};


struct SAATELEGRAMS_EXPORT Zieldaten
{
  int nummer{0};
  ProjectDataManagement::L4_TargetGeometry geometrie; 
  KoordinateMitHoehe koordinate;                      
  KoordinateMitHoehe relativKoordinate;               
  int breiteRadius{0};
  int tiefe{0};
  int zielachse{0};
  int zog{0};
  int elemente{0};
  QString typ;    
  QString subTyp; 
};





struct SAATELEGRAMS_EXPORT Wirkungsbereich
{
  int grundrichtung;
  int links;
  int rechts;
};


struct SAATELEGRAMS_EXPORT Feuereinheit
{
  QString verein;
  int r;
};


struct SAATELEGRAMS_EXPORT Erkundungseinheit
{
  QString verein;
  int r;
};


struct SAATELEGRAMS_EXPORT Erkundungsstellungen
{
  QVector<KoordinateMitHoehe> waffenplaetze; 
  Wirkungsbereich wirkungsbereich;           
};


struct SAATELEGRAMS_EXPORT FeuerkommandoGeschosse
{
  QString geschosssorte;   
  QString ladung;          
  QString zuender;         
  QString zuenderFunktion; 
  double zuenderZeit;      
  int anzahl;
  int ladungsNummer;
  double intervall; 
};


struct SAATELEGRAMS_EXPORT Flugbahnpunkt
{
  double zeit;
  double xRelativ;
  double yRelativ;
  double zRelativ;
};


struct SAATELEGRAMS_EXPORT FlugbahnberechnungGeschosse
{
  QString geschosssorte;   
  QString ladung;          
  QString zuender;         
  QString zuenderFunktion; 
};


struct SAATELEGRAMS_EXPORT FlugbahndatenGeschosse
{
  QString geschosssorte; 
  QString ladung;        
  int ladungsNummer;
  QString zuender;         
  QString zuenderFunktion; 
  double zuenderZeit;
};


struct SAATELEGRAMS_EXPORT Streuungsdaten
{
  double laengsstreuung;
  double seitenstreuung;
  double laengsstreuungH;
  double seitenstreuungH;
};


struct SAATELEGRAMS_EXPORT WirkmittelFeuerkommando
{
  ProjectDataManagement::L27_EffectorId kenner; 
  KoordinateMitHoehe auftreffpunkt;             
  double flugzeit;
  int gipfelhoehe;
  double schussrichtung;
  FeuerkommandoGeschosse geschoss;      
  QVector<Flugbahnpunkt> flugbahnpunkt; 
  Streuungsdaten streuung;              
};


struct SAATELEGRAMS_EXPORT Treffpunkt
{
  KoordinateMitHoehe koordinate; 
  int anzahl;
};


struct SAATELEGRAMS_EXPORT WirkmittelFeuerkommandoRakete
{
  ProjectDataManagement::L27_EffectorId kenner; 
  QVector<Treffpunkt> treffpunkte;
  double flugzeit;
  int gipfelhoehe;
  double schussrichtung;
  int fallwinkel;
  ProjectDataManagement::L48_TrajectoryRocket anflug;
  FeuerkommandoGeschosse geschoss;
  ProjectDataManagement::L46_GpsFrequency gps;
  int wirkzeit;
};


struct SAATELEGRAMS_EXPORT Feuerkommando
{
  QString verein;                                          
  ProjectDataManagement::L26_EffectingSystemType typ;      
  QVector<WirkmittelFeuerkommando> wirkmittel;             
  QVector<WirkmittelFeuerkommandoRakete> wirkmittelRakete; 
};





struct SAATELEGRAMS_EXPORT Wirkfelddaten
{
  QString feuerkampfReferenz;
  Zieldaten zieldaten;
  Abfeuerungsart abfeuerungsArt;
  ProjectDataManagement::L7_Request forderung;
  int dauer;
  Feuerkommando feuerkommando;
};


struct SAATELEGRAMS_EXPORT Feuerkampfdaten
{
  QString feuerkampfReferenz;                   
  QString verein;                               
  ProjectDataManagement::L27_EffectorId kenner; 
};


struct SAATELEGRAMS_EXPORT Erkundungsdaten
{
  Erkundungseinheit einheit;       
  KoordinateMitHoehe ladeplatz;    
  Erkundungsstellungen stellungen; 
};


struct SAATELEGRAMS_EXPORT Zielmeldedaten
{
  Zieldaten zieldaten;                         
  Abfeuerungsart abfeuerungsArt;               
  ProjectDataManagement::L7_Request forderung; 
  int dauer;
  QVector<Feuerkommando> feuerkommandos; 
};


struct SAATELEGRAMS_EXPORT Feuerstellungsdaten
{
  ProjectDataManagement::L26_EffectingSystemType typ; 
  ProjectDataManagement::L28_Status status;           
  Einheit feuereinheit;                               
  KoordinateMitHoehe mittelpunkt;                     
  QVector<KoordinateMitHoehe> koordinaten;            
  QVector<Geschoss> geschosse;                        
  Wirkungsbereich wirkungsbereich;                    
};


struct SAATELEGRAMS_EXPORT Waffensystemdaten
{
  ProjectDataManagement::L26_EffectingSystemType typ; 
  ProjectDataManagement::L27_EffectorId kenner;       
  ProjectDataManagement::L28_Status status;           
  Einheit einheit;                                    
  QVector<Geschoss> geschosse;                        
  KoordinateMitHoehe koordinate;                      
  Wirkungsbereich wirkungsbereich;                    
};


struct SAATELEGRAMS_EXPORT Ladeplatzdaten
{
  Einheit einheit;               
  KoordinateMitHoehe koordinate; 
  QVector<Geschoss> geschosse;   
};


struct SAATELEGRAMS_EXPORT Stellungswechseldaten
{
  QString verein; 
  int r;
  ProjectDataManagement::L19_Oi oi; 
};


struct SAATELEGRAMS_EXPORT Munitionsdaten
{
  QString verein; 
};


struct SAATELEGRAMS_EXPORT LpMunitionsdaten
{
  Einheit einheit; 
};


struct SAATELEGRAMS_EXPORT Koordinierungsdaten
{
  ProjectDataManagement::L25_KindGuidingLine art; 
  QString name;
  int meldungsnummer;
  QString truppenteil;             
  Zeitangabe_DTG ab;               
  Zeitangabe_DTG bis;              
  QVector<Koordinate> koordinaten; 
  Koordinate mittelpunkt;          
  int radius;
  int maxGipfel; 
};


struct SAATELEGRAMS_EXPORT WirkfeldplanungData
{
  QString feuerkampfReferenz;
  Zieldaten zieldaten;                         
  Abfeuerungsart abfeuerungsArt;               
  ProjectDataManagement::L7_Request forderung; 
  int dauer;
  Feuerkommando feuerkommando; 
};


struct SAATELEGRAMS_EXPORT Fuehrungsdaten
{
  Art_L24 art; 
  QString name;
  int meldungsnummer;
  Zeitangabe_DTG ab;               
  Zeitangabe_DTG bis;              
  QVector<Koordinate> koordinaten; 
  QString linkerNachbar;
  QString rechterNachbar;
};


struct SAATELEGRAMS_EXPORT Anmeldedaten
{
  int partyId;
  bool adlerVerbund;
  QString szenar;
};
void SAATELEGRAMS_EXPORT anmeldedatenFromJson(const QJsonObject &data, Anmeldedaten &anmeldedaten, bool &bOk);


struct SAATELEGRAMS_EXPORT Abmeldedaten
{
  int partyId;
};
void SAATELEGRAMS_EXPORT abmeldedatenFromJson(const QJsonObject &data, Abmeldedaten &anmeldedaten, bool &bOk);


struct SAATELEGRAMS_EXPORT TechnischeDaten
{
  Status_L32 status; 
  QString beschreibung;
};


struct SAATELEGRAMS_EXPORT FreitextDaten
{
  QString text;
};


struct SAATELEGRAMS_EXPORT ManuelleQuittungDaten
{
  QString feuerkampfreferenz;
};


struct SAATELEGRAMS_EXPORT FeuerHaltDaten
{
  QString verein;                                        
  ProjectDataManagement::L27_EffectorId kenner;          
  ProjectDataManagement::L22_FireHaltCategory kategorie; 
  QString feuerkampfReferenz;
  int zpNummer;
  Koordinate koordinate; 
  int radius;
  bool entladenSchuss;
};


struct SAATELEGRAMS_EXPORT AnBestaetigungsdaten
{
  L45_AnmeldebestaetigungFehlercode error;
};


struct SAATELEGRAMS_EXPORT FlugBerechnungsDaten
{
  KoordinateMitHoehe standort;
  KoordinateMitHoehe zielkoordinate;
  ProjectDataManagement::L26_EffectingSystemType waffensystem;
  FlugbahnberechnungGeschosse geschoss; 
  int sprenghoehe;
  Winkelgruppe winkelgruppe;
};


struct SAATELEGRAMS_EXPORT Flugbahndaten
{
  FlugbahnberechnungFehlercode fehlercode; 
  KoordinateMitHoehe zielkoordinate;
  ProjectDataManagement::L26_EffectingSystemType waffensystem;
  int flugzeit;
  int gipfelhoehe;
  int schussrichtung;
  int fallwinkel;
  QVector<Flugbahnpunkt> flugbahnpunkt; 
  Streuungsdaten streuung;
  FlugbahndatenGeschosse geschoss;
};









void SAATELEGRAMS_EXPORT wirkfeldplanungDataFromJson(const QJsonObject &data, WirkfeldplanungData &wirkfeldplanungData, bool &bOk);
struct SAATELEGRAMS_EXPORT ExAwesPlanning : public EXTelegramBase
{
  WirkfeldplanungData wirkfeldplanungData;

  ExAwesPlanning()
      : EXTelegramBase(JsonKeys::EX_AWES_PLANNING(), TelegramIds::EX_AWES_PLANNING())
  {
  }
  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};

template <> QJsonObject ExAwesPlanning::toJsonInternal<ExAwesPlanning>();


void SAATELEGRAMS_EXPORT feuerkampfdatenFromJson(const QJsonObject &data, Feuerkampfdaten &feuerkampfdaten, bool &bOk);
struct SAATELEGRAMS_EXPORT ExFeuerbereit : public EXTelegramBase
{
  Feuerkampfdaten feuerkampfdaten;

  ExFeuerbereit()
      : EXTelegramBase(JsonKeys::EX_READY_TO_FIRE(), TelegramIds::EX_READY_TO_FIRE())
  {
  }
  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};

template <> QJsonObject ExFeuerbereit::toJsonInternal<ExFeuerbereit>();


struct SAATELEGRAMS_EXPORT ExFeuern : public EXTelegramBase
{
  Feuerkampfdaten feuerkampfdaten;

  ExFeuern()
      : EXTelegramBase(JsonKeys::EX_FIRE(), TelegramIds::EX_FIRE())
  {
  }
  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};

template <> QJsonObject ExFeuern::toJsonInternal<ExFeuern>();


struct SAATELEGRAMS_EXPORT ExAbgefeuert : public EXTelegramBase
{
  Feuerkampfdaten feuerkampfdaten;

  ExAbgefeuert()
      : EXTelegramBase(JsonKeys::EX_FIRED(), TelegramIds::EX_FIRED())
  {
  }
  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};

template <> QJsonObject ExFeuern::toJsonInternal<ExAbgefeuert>();


struct SAATELEGRAMS_EXPORT ExVollzugsmeldung : public EXTelegramBase
{
  Feuerkampfdaten feuerkampfdaten;

  ExVollzugsmeldung()
      : EXTelegramBase(JsonKeys::EX_ENFORCEMENT(), TelegramIds::EX_ENFORCEMENT())
  {
  }
  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};

template <> QJsonObject ExFeuern::toJsonInternal<ExVollzugsmeldung>();



















void SAATELEGRAMS_EXPORT erkundungsdatenFromJson(const QJsonObject &data, Erkundungsdaten &erkundungsdaten, bool &bOk);

struct SAATELEGRAMS_EXPORT ExErkundungsergebnisse : public EXTelegramBase
{
  Erkundungsdaten erkundungsdaten;

  ExErkundungsergebnisse()
      : EXTelegramBase(JsonKeys::EX_EXPLORATION_RESULTS(), TelegramIds::EX_EXPLORATION_RESULTS())
  {
  }
  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};

template <> QJsonObject ExFeuern::toJsonInternal<ExErkundungsergebnisse>();




void SAATELEGRAMS_EXPORT zielmeldedatenFromJson(const QJsonObject &data, Zielmeldedaten &zielmeldedaten, bool &bOk);
struct SAATELEGRAMS_EXPORT ExFeuerkampf : public EXTelegramBase
{
  Zielmeldedaten zielmeldedaten; 

  ExFeuerkampf()
      : EXTelegramBase(JsonKeys::EX_FIRE_FIGHT(), TelegramIds::EX_FIRE_FIGHT())
  {
  }
  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};

template <> QJsonObject ExFeuern::toJsonInternal<ExFeuerkampf>();



void SAATELEGRAMS_EXPORT feuerHaltDatenFromJson(const QJsonObject &data, FeuerHaltDaten &feuerHaltDaten, bool &bOk);
struct SAATELEGRAMS_EXPORT ExFeuerhalt : public EXTelegramBase
{
  FeuerHaltDaten feuerHaltDaten; 

  ExFeuerhalt()
      : EXTelegramBase(JsonKeys::EX_FIRE_HALT(), TelegramIds::EX_FIRE_HALT())
  {
  }
  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};

template <> QJsonObject ExFeuern::toJsonInternal<ExFeuerhalt>();



void SAATELEGRAMS_EXPORT feuerstellungsdatenFromJson(const QJsonObject &data, Feuerstellungsdaten &feuerstellungsdaten, bool &bOk);
struct SAATELEGRAMS_EXPORT ExFeuerstellungFS : public EXTelegramBase
{
  Feuerstellungsdaten feuerstellungsdaten; 

  ExFeuerstellungFS()
      : EXTelegramBase(JsonKeys::EX_POSITION_REPORT_FIRE(), TelegramIds::EX_POSITION_REPORT_FIRE())
  {
  }
  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};

template <> QJsonObject ExFeuerstellungFS::toJsonInternal<ExFeuerstellungFS>();



void SAATELEGRAMS_EXPORT waffensystemdatenFromJson(const QJsonObject &data, Waffensystemdaten &waffensystemdaten, bool &bOk);
struct SAATELEGRAMS_EXPORT ExFeuerstellungWS : public EXTelegramBase
{
  Waffensystemdaten waffensystemdaten; 

  ExFeuerstellungWS()
      : EXTelegramBase(JsonKeys::EX_POSITION_REPORT_WEAPON(), TelegramIds::EX_POSITION_REPORT_WEAPON())
  {
  }
  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};

template <> QJsonObject ExFeuerstellungWS::toJsonInternal<ExFeuerstellungWS>();



void SAATELEGRAMS_EXPORT ladeplatzdatenFromJson(const QJsonObject &data, Ladeplatzdaten &ladeplatzdaten, bool &bOk);
struct SAATELEGRAMS_EXPORT ExFeuerstellungLP : public EXTelegramBase
{
  Ladeplatzdaten ladeplatzdaten; 

  ExFeuerstellungLP()
      : EXTelegramBase(JsonKeys::EX_POSITION_REPORT_LOADING_PLACE(), TelegramIds::EX_POSITION_REPORT_LOADING_PLACE())
  {
  }
  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};

template <> QJsonObject ExFeuerstellungLP::toJsonInternal<ExFeuerstellungLP>();



void SAATELEGRAMS_EXPORT stellungswechseldatenFromJson(const QJsonObject &data, Stellungswechseldaten &stellungswechseldaten, bool &bOk);
struct SAATELEGRAMS_EXPORT ExStellungswechsel : public EXTelegramBase
{
  Stellungswechseldaten stellungswechseldaten; 

  ExStellungswechsel()
      : EXTelegramBase(JsonKeys::EX_POSITION_CHANGED(), TelegramIds::EX_POSITION_CHANGED())
  {
  }
  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};

template <> QJsonObject ExStellungswechsel::toJsonInternal<ExStellungswechsel>();



void SAATELEGRAMS_EXPORT koordinierungsdatenFromJson(const QJsonObject &data, Koordinierungsdaten &koordinierungsdaten, bool &bOk);
struct SAATELEGRAMS_EXPORT ExHqKoordinierungsmassnahmen : public EXTelegramBase
{
  Koordinierungsdaten koordinierungsdaten; 

  ExHqKoordinierungsmassnahmen()
      : EXTelegramBase(JsonKeys::EX_GUIDING_LINES(), TelegramIds::EX_GUIDING_LINES())
  {
  }
  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};

template <> QJsonObject ExHqKoordinierungsmassnahmen::toJsonInternal<ExHqKoordinierungsmassnahmen>();



void SAATELEGRAMS_EXPORT fuehrungsdatenFromJson(const QJsonObject &data, Fuehrungsdaten &fuehrungsdaten, bool &bOk);
struct SAATELEGRAMS_EXPORT ExHqFuehrungslinien : public EXTelegramBase
{
  Fuehrungsdaten fuehrungsdaten; 

  ExHqFuehrungslinien()
      : EXTelegramBase(JsonKeys::EX_GUIDING_LINES_AND_BOUNDARIES(), TelegramIds::EX_GUIDING_LINES_AND_BOUNDARIES())
  {
  }
  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};

template <> QJsonObject ExHqFuehrungslinien::toJsonInternal<ExHqFuehrungslinien>();



void SAATELEGRAMS_EXPORT technischeDatenFromJson(const QJsonObject &data, TechnischeDaten &technischeDaten, bool &bOk);
struct SAATELEGRAMS_EXPORT ExTqTechnischeQuittung : public EXTelegramBase
{
  TechnischeDaten technischeDaten; 

  ExTqTechnischeQuittung()
      : EXTelegramBase(JsonKeys::EX_TQ(), TelegramIds::EX_TQ())
  {
  }
  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};

template <> QJsonObject ExTqTechnischeQuittung::toJsonInternal<ExTqTechnischeQuittung>();



void SAATELEGRAMS_EXPORT FreitextDatenFromJson(const QJsonObject &data, FreitextDaten &freitextDaten, bool &bOk);
struct SAATELEGRAMS_EXPORT ExAqFreitextmeldung : public EXTelegramBase
{
  FreitextDaten freitextDaten; 

  ExAqFreitextmeldung()
      : EXTelegramBase(JsonKeys::EX_AQ(), TelegramIds::EX_AQ())
  {
  }
  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};
template <> QJsonObject ExAqFreitextmeldung::toJsonInternal<ExAqFreitextmeldung>();



void SAATELEGRAMS_EXPORT mqManuelleQuittungDatenFromJson(const QJsonObject &data, ManuelleQuittungDaten &manuelleQuittungDaten, bool &bOk);
struct SAATELEGRAMS_EXPORT ExMqManuelleQuittung : public EXTelegramBase
{
  ManuelleQuittungDaten mqManuelleQuittungDaten;

  ExMqManuelleQuittung()
      : EXTelegramBase(JsonKeys::EX_MANUAL_REPLY(), TelegramIds::EX_MANUAL_REPLY())
  {
  }
  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};
template <> QJsonObject ExMqManuelleQuittung::toJsonInternal<ExMqManuelleQuittung>();



void SAATELEGRAMS_EXPORT exNichtFeuernFromJson(const QJsonObject &data, Feuerkampfdaten &feuerkampfdaten, bool &bOk);

struct SAATELEGRAMS_EXPORT exNichtFeuern : public EXTelegramBase
{
  Feuerkampfdaten feuerkampfdaten;

  exNichtFeuern()
      : EXTelegramBase(JsonKeys::EX_DONT_FIRE(), TelegramIds::EX_DONT_FIRE())
  {
  }

  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};
template <> QJsonObject exNichtFeuern::toJsonInternal<exNichtFeuern>();


void SAATELEGRAMS_EXPORT exAnmeldebestaetigungDatenFromJson(const QJsonObject &data, AnBestaetigungsdaten &anBestaetigungsdaten, bool &bOk);
struct SAATELEGRAMS_EXPORT ExAnmeldebestaetigung : public EXTelegramBase
{
  AnBestaetigungsdaten anBestaetigungsdaten;

  ExAnmeldebestaetigung()
      : EXTelegramBase(JsonKeys::EX_REGISTRATION_CONFIRMATION(), TelegramIds::EX_REGISTRATION_CONFIRMATION())
  {
  }
  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};
template <> QJsonObject ExAnmeldebestaetigung::toJsonInternal<ExAnmeldebestaetigung>();



void SAATELEGRAMS_EXPORT exFlugbahnberechnungDatenFromJson(const QJsonObject &data, FlugBerechnungsDaten &flugBerechnungsDaten, bool &bOk);
struct SAATELEGRAMS_EXPORT ExFlugbahnberechnung : public EXTelegramBase
{
  FlugBerechnungsDaten flugbahnberechnungDaten;

  ExFlugbahnberechnung()
      : EXTelegramBase(JsonKeys::EX_FLUGBAHNBERECHNUNG(), TelegramIds::EX_FLUGBAHNBERECHNUNG())
  {
  }
  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};
template <> QJsonObject ExFlugbahnberechnung::toJsonInternal<ExFlugbahnberechnung>();



void SAATELEGRAMS_EXPORT flugbahndatenFromJson(const QJsonObject &data, Flugbahndaten &flugbahndaten, bool &bOk);
struct SAATELEGRAMS_EXPORT ExFlugbahndaten : public EXTelegramBase
{
  Flugbahndaten flugbahndaten;

  ExFlugbahndaten()
      : EXTelegramBase(JsonKeys::EX_FLUGBAHNDATEN(), TelegramIds::EX_FLUGBAHNDATEN())
  {
  }
  QJsonObject toJson() override;

  public:
  template <typename T> QJsonObject toJsonInternal();
};
template <> QJsonObject ExFlugbahndaten::toJsonInternal<Flugbahndaten>();






const QMap<QString, ProjectDataManagement::L4_TargetGeometry> zielgeometrieMap = {
    {QStringLiteral("P"), ProjectDataManagement::L4_TargetGeometry::Point},  
    {QStringLiteral("F"), ProjectDataManagement::L4_TargetGeometry::Area},   
    {QStringLiteral("R"), ProjectDataManagement::L4_TargetGeometry::Radial}, 
    {QStringLiteral("L"), ProjectDataManagement::L4_TargetGeometry::Linear}  
};


const QMap<QString, Abfeuerungsart> AbfeuerungsartMap = {
    {QStringLiteral("A"), Abfeuerungsart::A}, 
    {QStringLiteral("B"), Abfeuerungsart::B}, 
    {QStringLiteral("F"), Abfeuerungsart::F}, 
    {QStringLiteral("T"), Abfeuerungsart::T}, 
    {QStringLiteral("K"), Abfeuerungsart::K}, 
};


const QMap<QString, ProjectDataManagement::L7_Request> ForderungMap = {
    {QStringLiteral("ABR"), ProjectDataManagement::L7_Request::ABR}, 
    {QStringLiteral("BEK"), ProjectDataManagement::L7_Request::BEK}, 
    {QStringLiteral("BEL"), ProjectDataManagement::L7_Request::BEL}, 
    {QStringLiteral("BLE"), ProjectDataManagement::L7_Request::BLE}, 
    {QStringLiteral("NIE"), ProjectDataManagement::L7_Request::NIE}, 
    {QStringLiteral("SPE"), ProjectDataManagement::L7_Request::SPE}, 
    {QStringLiteral("STO"), ProjectDataManagement::L7_Request::STO}, 
    {QStringLiteral("UBW"), ProjectDataManagement::L7_Request::UBW}, 
    {QStringLiteral("VER"), ProjectDataManagement::L7_Request::VER}, 
    {QStringLiteral("ZSL"), ProjectDataManagement::L7_Request::ZSL}, 
    {QStringLiteral("ZER"), ProjectDataManagement::L7_Request::ZER}, 
    {QStringLiteral("BWL"), ProjectDataManagement::L7_Request::BWL}, 
    {QStringLiteral("MRK"), ProjectDataManagement::L7_Request::MRK}, 
    {QStringLiteral("WRN"), ProjectDataManagement::L7_Request::WRN}, 
    {QStringLiteral("BLI"), ProjectDataManagement::L7_Request::BLI}, 
    {QStringLiteral("BEI"), ProjectDataManagement::L7_Request::BEI}, 
    {QStringLiteral("BEW"), ProjectDataManagement::L7_Request::BEW}, 
    {QStringLiteral("BEO"), ProjectDataManagement::L7_Request::BEO}, 
    {QStringLiteral("BLW"), ProjectDataManagement::L7_Request::BLW}, 
    {QStringLiteral("MBE"), ProjectDataManagement::L7_Request::MBE}, 
    {QStringLiteral("MBL"), ProjectDataManagement::L7_Request::MBL}, 
    {QStringLiteral("MIR"), ProjectDataManagement::L7_Request::MIR}, 
};


const QMap<QString, ProjectDataManagement::L19_Oi> ortsIdMap = {
    {QStringLiteral("Empty"), ProjectDataManagement::L19_Oi::Empty}, 
    {QStringLiteral("F1"), ProjectDataManagement::L19_Oi::F1},       
    {QStringLiteral("F2"), ProjectDataManagement::L19_Oi::F2},       
    {QStringLiteral("F3"), ProjectDataManagement::L19_Oi::F3},       
    {QStringLiteral("F4"), ProjectDataManagement::L19_Oi::F4},       
    {QStringLiteral("F5"), ProjectDataManagement::L19_Oi::F5},       
    {QStringLiteral("F6"), ProjectDataManagement::L19_Oi::F6},       
    {QStringLiteral("F7"), ProjectDataManagement::L19_Oi::F7},       
    {QStringLiteral("F8"), ProjectDataManagement::L19_Oi::F8},       
    {QStringLiteral("F9"), ProjectDataManagement::L19_Oi::F9},       
    {QStringLiteral("L"), ProjectDataManagement::L19_Oi::L}          
};





const QMap<QString, ProjectDataManagement::L22_FireHaltCategory> feuerHaltKategorieMap = {
    {QStringLiteral("A"), ProjectDataManagement::L22_FireHaltCategory::A}, 
    {QStringLiteral("R"), ProjectDataManagement::L22_FireHaltCategory::R}, 
    {QStringLiteral("E"), ProjectDataManagement::L22_FireHaltCategory::E}, 
    {QStringLiteral("C"), ProjectDataManagement::L22_FireHaltCategory::C}, 
    {QStringLiteral("F"), ProjectDataManagement::L22_FireHaltCategory::F}, 
};


const QMap<QString, Art_L24> art_L24Map = {
    {QStringLiteral("AL"), Art_L24::AL},         
    {QStringLiteral("ANL"), Art_L24::ANL},       
    {QStringLiteral("AO"), Art_L24::AO},         
    {QStringLiteral("ATRZ"), Art_L24::ATRZ},     
    {QStringLiteral("BAA"), Art_L24::BAA},       
    {QStringLiteral("BCA"), Art_L24::BCA},       
    {QStringLiteral("BDRY"), Art_L24::BDRY},     
    {QStringLiteral("BHA"), Art_L24::BHA},       
    {QStringLiteral("CAA"), Art_L24::CAA},       
    {QStringLiteral("CCA"), Art_L24::CCA},       
    {QStringLiteral("CFL"), Art_L24::CFL},       
    {QStringLiteral("CFZ"), Art_L24::CFZ},       
    {QStringLiteral("CHA"), Art_L24::CHA},       
    {QStringLiteral("CP"), Art_L24::CP},         
    {QStringLiteral("CZ"), Art_L24::CZ},         
    {QStringLiteral("EA"), Art_L24::EA},         
    {QStringLiteral("EZ"), Art_L24::EZ},         
    {QStringLiteral("FLET"), Art_L24::FLET},     
    {QStringLiteral("FLOT"), Art_L24::FLOT},     
    {QStringLiteral("FOAZI"), Art_L24::FOAZI},   
    {QStringLiteral("FOAZII"), Art_L24::FOAZII}, 
    {QStringLiteral("IZ"), Art_L24::IZ},         
    {QStringLiteral("LZ"), Art_L24::LZ},         
    {QStringLiteral("MA"), Art_L24::MA},         
    {QStringLiteral("NAI"), Art_L24::NAI},       
    {QStringLiteral("OA"), Art_L24::OA},         
    {QStringLiteral("PL"), Art_L24::PL},         
    {QStringLiteral("ROTACA"), Art_L24::ROTACA}, 
    {QStringLiteral("ROTAHA"), Art_L24::ROTAHA}, 
    {QStringLiteral("ROTARA"), Art_L24::ROTARA}, 
    {QStringLiteral("ROUTE"), Art_L24::ROUTE},   
    {QStringLiteral("RP"), Art_L24::RP},         
    {QStringLiteral("SP"), Art_L24::SP},         
    {QStringLiteral("TAI"), Art_L24::TAI},       
    {QStringLiteral("FEBA"), Art_L24::FEBA},     
    {QStringLiteral("VZL"), Art_L24::VZL},       
    {QStringLiteral("MFLD"), Art_L24::MFLD},     
    {QStringLiteral("ZOF"), Art_L24::ZOF},       
    {QStringLiteral("TAREA"), Art_L24::TAREA},   
    {QStringLiteral("PP"), Art_L24::PP},         
    {QStringLiteral("AMA"), Art_L24::AMA},       
    {QStringLiteral("ARA"), Art_L24::ARA},       
};


const QMap<QString, ProjectDataManagement::L25_KindGuidingLine> art_L25Map = {
    {QStringLiteral("FFA"), ProjectDataManagement::L25_KindGuidingLine::FFA},
    {QStringLiteral("NFA"), ProjectDataManagement::L25_KindGuidingLine::NFA},
    {QStringLiteral("RFA"), ProjectDataManagement::L25_KindGuidingLine::RFA},
    {QStringLiteral("FSCL"), ProjectDataManagement::L25_KindGuidingLine::FSCL},
    {QStringLiteral("RFL"), ProjectDataManagement::L25_KindGuidingLine::RFL},
    {QStringLiteral("FSSL"), ProjectDataManagement::L25_KindGuidingLine::FSSL},
    {QStringLiteral("NFL"), ProjectDataManagement::L25_KindGuidingLine::NFL},
};


const QMap<QString, ProjectDataManagement::L28_Status> StatusL28Map = {

    {QStringLiteral("Nicht einsatzbereit"), ProjectDataManagement::L28_Status::NichtEinsatzbereit},
    {QStringLiteral("Einsatzbereit"), ProjectDataManagement::L28_Status::Einsatzbereit}};


const QMap<QString, Status_L32> StatusL32Map = {
    {QStringLiteral("INV"), Status_L32::INV}, 
    {QStringLiteral("DAT"), Status_L32::DAT}, 
};


const QMap<QString, Szenarstatus> szenarstatusMap = {
    {QStringLiteral("Inaktiv"), Szenarstatus::Inaktiv},   
    {QStringLiteral("Geplant"), Szenarstatus::Geplant},   
    {QStringLiteral("Aktiv"), Szenarstatus::Aktiv},       
    {QStringLiteral("Gestoppt"), Szenarstatus::Gestoppt}, 
};


const QMap<QString, Winkelgruppe> winkelgruppeMap = {
    {QStringLiteral("Untere"), Winkelgruppe::Untere},
    {QStringLiteral("Obere"), Winkelgruppe::Obere},
};


const QMap<QString, FlugbahnberechnungFehlercode> FehlercodeMap = {
    {QStringLiteral("ok"), FlugbahnberechnungFehlercode::Ok},                                   
    {QStringLiteral("MinimaleEntfernung"), FlugbahnberechnungFehlercode::MinimaleEntfernung},   
    {QStringLiteral("MaximaleEntfernung"), FlugbahnberechnungFehlercode::MaximaleEntfernung},   
    {QStringLiteral("GeschossKombination"), FlugbahnberechnungFehlercode::GeschossKombination}, 
    {QStringLiteral("Ungueltig"), FlugbahnberechnungFehlercode::Ungueltig},                     
};


const QMap<QString, L45_AnmeldebestaetigungFehlercode> AnmeldebestaetigungFehlercodeMap = {
    {QStringLiteral("ok"), L45_AnmeldebestaetigungFehlercode::Ok},
    {QStringLiteral("doppelt"), L45_AnmeldebestaetigungFehlercode::Doppelt},
    {QStringLiteral("mehrfach"), L45_AnmeldebestaetigungFehlercode::Mehrfach},
    {QStringLiteral("belegt"), L45_AnmeldebestaetigungFehlercode::Belegt},
};


const QMap<QString, ProjectDataManagement::L46_GpsFrequency> GpsFrequencyMap
    = {{QStringLiteral("L1"), ProjectDataManagement::L46_GpsFrequency::L1}, {QStringLiteral("L1"), ProjectDataManagement::L46_GpsFrequency::L2}};


const QMap<QString, ProjectDataManagement::L48_TrajectoryRocket> TrajectoryRocketMap
    = {{QStringLiteral("Nominal"), ProjectDataManagement::L48_TrajectoryRocket::Nominal},
       {QStringLiteral("Vertical"), ProjectDataManagement::L48_TrajectoryRocket::Vertical}};


void SAATELEGRAMS_EXPORT koordinierungsdatenFromJson(const QJsonObject &data, Koordinierungsdaten &koordinierungsdaten, bool &bOk);
void SAATELEGRAMS_EXPORT koordinierungsdatenToJson(QJsonObject &data, const Koordinierungsdaten &koordinierungsdaten);


void SAATELEGRAMS_EXPORT fuehrungsdatenFromJson(const QJsonObject &data, Fuehrungsdaten &fuehrungsdaten, bool &bOk);
void SAATELEGRAMS_EXPORT fuehrungsdatenToJson(QJsonObject &data, const Fuehrungsdaten &fuehrungsdaten);


void SAATELEGRAMS_EXPORT feuerHaltDatenFromJson(const QJsonObject &data, FeuerHaltDaten &feuerHaltDaten, bool &bOk);
void SAATELEGRAMS_EXPORT feuerHaltDatenToJson(QJsonObject &data, const FeuerHaltDaten &feuerHaltDaten);


void SAATELEGRAMS_EXPORT wirkmittelFeuerkommandoRaketeToJson(QJsonObject &data, const WirkmittelFeuerkommandoRakete &wirkmittelFeuerkommandoRakete);
void SAATELEGRAMS_EXPORT wirkmittelFeuerkommandoRaketeFromJson(const QJsonObject &data, WirkmittelFeuerkommandoRakete &wirkmittelFeuerkommandoRakete, bool &bOk);
int SAATELEGRAMS_EXPORT getFeuerkommandoRaketeEffectDurationMsec(const QJsonObject &data);

}