qt-migration-legatus/qt5-before/dlbo/Lts/Services/ParticipantManagement/ParticipantHandling/participant_handler.h

/**
 * The ParticipantHandler class manages all participant related function topics and holds classes for
 * further participant data.
 * $Id$
 * $HeadURL$
 * $Author$
 * Created by Hannes Baeuerle, SLSE, 2016-05-12
 */
#pragma once

#include <QtCore/QHash>
#include <QtCore/QObject>
#include <QtCore/QString>

#include <Proxies/TrainingAreaBase/tab_dtc.h>

#include <ParticipantManagement/ppm_db_structs.h>
#include <ParticipantManagement/ppm_dts.h>
#include <ParticipantManagement/web_socket_handler.h>

#include "logger.h"
#include "participant_donator.h"

namespace Buildings
{
class BuildingHitLineInfo;
}

namespace ProjectDataManagement
{
namespace Interface
{
class Dtc;
}
} // namespace ProjectDataManagement

namespace ParticipantManagement
{
class MainHandler;
namespace ParticipantHandling
{
class Participant;
class ExerciseParticipant;
class SupportParticipant;
class UnitPositionCalculator;

class BaseDataProvider
{
  public:
  BaseDataProvider() = default;
  virtual ~BaseDataProvider() = default;
  virtual std::shared_ptr<Interface::Dts> dts() const = 0;
  virtual std::shared_ptr<ProjectDataManagement::Interface::Dtc> pdmDtc() const = 0;
  virtual qint64 currentTimeMSec() const = 0;
};

struct ParticipantOrganisationEx : public ParticipantOrganisation
{
  int dbId = 0;
  void copy(const ParticipantOrganisation &o)
  {
    ParticipantOrganisation *that = this;
    *that = o;
  }
};

class ParticipantHandler
    : public QObject
    , public ParticipantDonator
{
  Q_OBJECT
  public:
  explicit ParticipantHandler(BaseDataProvider *bdp, const char *loggerName);
  ~ParticipantHandler();

  void clearParticipants();
  virtual bool init();

  virtual void setEquipmentNumberForParticipant(int oldEqNo, int newEqNo, int participantId);

  Participant *participantById(int32_t participantId) const override;
  Participant *participantByEquipmentNumber(int32_t equipmentNumber);
  // only needed in Exercise, correctly reimplemented in ParticipantHandlerForExercise
  bool isUnitType(int typeId) const override
  {
    Q_UNUSED(typeId);
    return false;
  }

  Q_SIGNALS:
  void gearChargeChanged(int participantId, int partyId);

  public Q_SLOTS:
  void onNewGearEvent(const TrainingAreaBase::EquipmentGearEvent &gearEvent);
  void onNewGearChargeStateFromProxy(const TrainingAreaBase::EquipmentGearChargeState &chargeState);
  void onNewGearAssignmentFromProxy(const TrainingAreaBase::EquipmentGearAssignment &gearAssignment);
  void onNewStateFromProxy(const TrainingAreaBase::EquipmentState &data);
  void onNewPositionFromProxy(const TrainingAreaBase::EquipmentPosition &position);
  void onNewEquipmentOperationalStateFromProxy(const TrainingAreaBase::EquipmentOperationalState &operationalState);
  void onNewBiteFromProxy(const TrainingAreaBase::EquipmentBite &bite);
  void onNewCtaDataErrorFromProxy(const TrainingAreaBase::CtaDataError &error);
  void onNewParticipantModeReport(const TrainingAreaBase::ParticipantModeReport &report);
  void onNewSpecialSensorData(const TrainingAreaBase::SpecialSensorData &data);
  void onNewFunctionalAreaEntryChanged(const TrainingAreaBase::FunctionalAreaEntry &data);
  void onNewLaserDesignation(const TrainingAreaBase::LaserDesignation &data);
  void onLaserDesignationRemoved(int equipmentNumber, int gearId);
  void onSanitaryMaterialStockReport(const TrainingAreaBase::ParticipantSanitaryMaterialStockReport &data);
  void onParticipantSanitation(const TrainingAreaBase::ParticipantSanitation &data);
  void onOperatorAction(const TrainingAreaBase::OperatorAction &data);
  void onEquipmentEvent(const TrainingAreaBase::EquipmentEvent &data);
  void onBuildingHitLineInfo(const Buildings::BuildingHitLineInfo &data);
  void onHitLineInfoTimeout();

  public:
  void newData(const TrainingAreaBase::EquipmentGearEvent &data) { onNewGearEvent(data); }
  void newData(const TrainingAreaBase::EquipmentGearChargeState &data) { onNewGearChargeStateFromProxy(data); }
  void newData(const TrainingAreaBase::EquipmentGearAssignment &data) { onNewGearAssignmentFromProxy(data); }
  void newData(const TrainingAreaBase::EquipmentState &data) { onNewStateFromProxy(data); }
  void newData(const TrainingAreaBase::EquipmentPosition &data) { onNewPositionFromProxy(data); }
  void newData(const TrainingAreaBase::EquipmentOperationalState &data) { onNewEquipmentOperationalStateFromProxy(data); }
  void newData(const TrainingAreaBase::EquipmentBite &data) { onNewBiteFromProxy(data); }
  void newData(const TrainingAreaBase::CtaDataError &data) { onNewCtaDataErrorFromProxy(data); }
  void newData(const TrainingAreaBase::ParticipantModeReport &data) { onNewParticipantModeReport(data); }
  void newData(const TrainingAreaBase::SpecialSensorData &data) { onNewSpecialSensorData(data); }
  void newData(const TrainingAreaBase::ParticipantSanitation &data) { onParticipantSanitation(data); }
  void newData(const TrainingAreaBase::ParticipantSanitaryMaterialStockReport &data) { onSanitaryMaterialStockReport(data); }
  void newData(const TrainingAreaBase::EquipmentEvent &data) { onEquipmentEvent(data); }
  void newData(const ParticipantPosition &data) { setPosition(data); }
  void newData(const HitLineInfo &data) { setHitlineInfoFromReplay(data); }
  void newData(const UAS &data) { setUASFromReplay(data); }

  std::shared_ptr<Interface::Dts> dts() const;
  qint64 currentTimeMSec() const;

  quint16 getWebSocketPort() const;

  protected:
  static void updateLaserDesignation(DynamicParticipantData &data, const TrainingAreaBase::LaserDesignation &newLaserDesignation);
  void updateLaserDesignation(DynamicParticipantData &dataInOut, const Buildings::BuildingHitLineInfo &newLaserDesignation);
  static void removeLaserDesignation(DynamicParticipantData &data, qint32 gearId);
  void setPosition(const ParticipantPosition &data);
  void setHitlineInfoFromReplay(const HitLineInfo &data);
  void setUASFromReplay(const UAS &data);

  virtual void createHitlineInfo(int originatorId,
                                 Participant *originParticipant,
                                 Participant *participantToBeChanged,
                                 const TrainingAreaBase::EquipmentPosition &pos,
                                 int originatorChargeTypeId,
                                 qint64 sampleTime);

  static bool isSupportTypeClass(const TypeClass &typeClass);
  // t - 11min <= sampleTime
  template <typename T> inline bool isTelegramOutdated(const T &tele) const { return isSampleTimeOutdated(tele.sampleTime()); }
  virtual bool isSampleTimeOutdated(qint64 sampleTime) const;
  // sampleTime > t + 1min
  template <typename T> inline bool isTelegramInFuture(const T &tele) const { return isSampleTimeInFuture(tele.sampleTime()); }
  virtual bool isSampleTimeInFuture(qint64 sampleTime) const;

  protected:
  std::unique_ptr<UnitPositionCalculator> m_unitPositionCalculator;
  QHash<int, int> m_equipNumber2ParticipantId;
  QHash<int, Participant *> m_participants;
  QHash<int, ParticipantOrganisationEx> m_participantOrganisations;
  int m_hitLineId;
  QMap<int, HitLineInfo> m_hitLineInfoMap;

  BaseDataProvider *m_bdp;
  LOGGER_T m_logger;

  std::shared_ptr<WebSocketHandler> m_webSocketHandler;

  friend class Participant;
};
} // namespace ParticipantHandling
} // namespace ParticipantManagement