qt-migration-legatus/qt5-before/dlbo/Lts/Services/AreaEffectSimulation/object_mine_area.h

/**
 * Exercise object
 * $Id$
 * $HeadURL$
 * $Author$
 */
#pragma once

#include "aes_db.h"
#include "object_base.h"
#include <QPolygonF>
#include <LtsCoordTrans/lts_coord_trans.h>

namespace AreaEffectSimulation
{
class ObjectMineArea final : public ObjectBaseTmpl<Database::AesMineArea>
{
  Q_OBJECT
  public:
  explicit ObjectMineArea(MainHandler *mainHandler, QObject *parent = nullptr);
  ~ObjectMineArea();
  Core::FunctionReplyObject createObject(const Database::AesMineArea &data, const std::vector<Core::GeoPosition2D> &segments = std::vector<Core::GeoPosition2D>());
  Core::FunctionReplyObject createObject(const Database::AesMineArea &data, const std::vector<MineSegment> &segments);
  Core::FunctionReplyObject updateObject(const Database::AesMineArea &data, const std::vector<Core::GeoPosition2D> &segments);
  Core::FunctionReplyObject updateObject(const Database::AesMineArea &data, const std::vector<MineSegment> &segments);
  Core::FunctionReplyObject createObjectFromMineData(const Database::AesMineArea &data,
                                                     const std::vector<Core::GeoPosition2D> &segment,
                                                     const std::vector<MineData> &mineData);
  Core::FunctionReplyObject updateObjectFromMineData(const Database::AesMineArea &data,
                                                     const std::vector<Core::GeoPosition2D> &segments,
                                                     const std::vector<MineData> &mineData);
  /*!
   * \brief removeObjectFromDb
   * \details Removes the object from db, Used if the object is created but there are too much objects (amount border)
   * \author Niklas Schmidt
   * \return bool if the deletion was working
   */
  bool removeObjectFromDb();

  Database::AesMineArea get() const { return m_data; }

  QVector<Database::AesMineAreaSegment> segments() const { return m_segments; }
  QRectF boundingRect() const { return m_mineAreaPolygon.boundingRect(); }
  bool hasMine(int mineId) const { return m_triggeredMines.contains(mineId); }
  int getMineIdByIndex(int index) const;
  int lastMineNo() const;
  bool canHandleMine(int mineId, int chargeTypeId, const QPointF &position) const;
  bool triggerMine(int mineId, bool trigger = true, const QPointF &position = QPointF());
  bool updateMine(Database::AesMineAreaTriggeredMines &mine);
  void updateMineByOldMineId(Database::AesMineAreaTriggeredMines &mine, qint32 oldMineId);
  bool resetMine(int mineId);
  bool resetMines();
  Database::AesMineAreaTriggeredMines takeMine(int mineId);
  bool isDusMineArea() const;
  bool isConcreteMine() const;
  bool isSingleVirtual() const;
  bool isVirtualMine() const;
  bool isReactivatableDusMineArea() const;
  void clearCorridor(const AesItemView &aiv);
  void clearBuildings();
  QVector<Database::AesMineAreaTriggeredMines> unpairedMines() const;

  std::vector<Core::GeoPosition> form() const override { return m_aiv.form(); }
  QPolygonF generateForm() override;
  AesType aesType() const override { return AesType::AtMineArea; }
  bool isCentral() const override { return m_data.isCentral; }

  int mineCount();

  void removeTopics();
  Core::FunctionReplyObject createGeoSegmentsFromMineData(double &newWidth, const std::vector<MineData> &mineData, std::vector<Core::GeoPosition2D> &outSegments);
  Core::FunctionReplyObject createSegments(
      const std::vector<AreaEffectSimulation::MineSegment> &inSegments,
      int mineAreaId,
      QVector<Database::AesMineAreaSegment> &outSegments,
      const double &totalLengthOut); // const double &totalLengthOut since totalLengthOut is unused and exits just for signature purpose
  Core::FunctionReplyObject createSegments(const std::vector<Core::GeoPosition2D> &inSegments,
                                           int mineAreaId,
                                           QVector<Database::AesMineAreaSegment> &outSegments,
                                           double &totalLengthOut);

  // for concrete mines only
  Core::FunctionReplyObject changeSegmentsToLine(bool sortMines);
  Core::FunctionReplyObject checkDensity(double &densityOut, const double totalLength, int maxMineCount);

  signals:
  void releaseMines(int aesId, const QList<Database::AesMineAreaTriggeredMines> &mines);
  void shapeChanged(int aesId);

  public slots:
  void onEffectStateChanged();

  protected Q_SLOTS:
  void onPublishData() override final;

  private:
  template <typename T> Core::FunctionReplyObject createObjectTmpl(const Database::AesMineArea &data, const std::vector<T> &segments);
  template <typename T> Core::FunctionReplyObject updateObjectTmpl(const Database::AesMineArea &data, const std::vector<T> &segments);

  bool containsPointInExpandedMinefield(const QPointF &positionGeo) const;
  double distancePointLine(const QPointF &pUtm, const QPointF &l1Utm, const QPointF &l2Utm) const;
  double squareLen(const QPointF &p1, const QPointF &p2) const;

  double singleMineRadius() const;
  void publishAiv();
  bool publishTriggeredImpacts();
  bool publishDusMineStatus();
  bool triggerMines(const QVector<int> &mineIds, bool trigger, const QPointF &position);
  bool removeTriggeredMines(const QVector<int> &mineIds);
  void generateVirtualMines();
  bool addMineData(const std::vector<MineData> &mineData);
  bool selectMineFromDb(QMap<int, Database::AesMineAreaTriggeredMines> &outTriggerMines);
  void removeDusMineStateTopic();
  int msGetIndexMine(const QVector<LtsCoordTrans::UtmCoordinate> &box, const QVector<LtsCoordTrans::UtmCoordinate> &minen);
  double msGetDistanceFromLine(double px, double py, double px0, double py0, double px1, double py1);
  QVector<Database::AesMineAreaSegment> m_segments;
  QMap<int, Database::AesMineAreaTriggeredMines> m_triggeredMines;
  bool m_triggeredMinesChanged;
  QPolygonF m_mineAreaPolygon;
  AesItemView m_aiv;
  AesItemView m_aiv2;
  TriggeredImpacts m_tis;
  DusMineState m_dms;
};
} // namespace AreaEffectSimulation