/**
  * Controller ShootbackAreas (L400)
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by N. Thoden, NLE, 06.04.2020
  */
#pragma once

#include "dds_handler.h"
#include "logger.h"

#include "handler_shootback_area.h"
#include "handler_shootback_target.h"
#include "handler_target_area_assignment.h"

#include <QMap>

namespace NGL
{
class INGLLogger;
}

namespace SituationMap
{
class LineOfSightCalculation;
class ElevationMap;
}


namespace TargetManagement
{

/*!
 * \brief The ShootbackController class is created for ShootbackTarget of L400.
 */
class ShootbackController : public QObject
{
  Q_OBJECT

public:

  using BaseClass = QObject;

  explicit ShootbackController(MainHandler *mainHandler);
  virtual ~ShootbackController();

  bool initLOS(SituationMap::ElevationMap *elevationMap);
  bool initDds(std::shared_ptr<HandlerShootbackArea> handlerArea,
               std::shared_ptr<HandlerShootbackTarget> handlerTarget,
               std::shared_ptr<HandlerTargetAreaAssignment> handlerTargetAreaAssignment);

protected Q_SLOTS:
  void onShootbackAreaChanged1(qint32 areaId, bool removed);
  void onShootbackAreaChanged2(const TargetManagement::ObjectShootbackArea &area);

  void onShootbackTargetChanged(qint32 targetId, bool removed);

  void onTargetAreaAssignmentChanged(qint32 assignmentId, bool removed);

  void onParticipantPositionChanged(const ParticipantManagement::ParticipantPosition &posData, DataModification modType);

protected:
  bool participantPositionTopicIsValid(const ParticipantManagement::ParticipantPosition &posData);
  bool isTarget(qint32 participantId, bool &bIsTarget) const;

  void removeParticipantFromCont(QMap<int, QSet<int>> &contRef, int participantId);
  void updateInternal_participantPerArea(const TargetManagement::ObjectShootbackArea &area,
                                         const ParticipantManagement::ParticipantPosition &posData);
  bool areaContainsPosition(const TargetManagement::ObjectShootbackArea &area,
                            const ParticipantManagement::ParticipantPosition &posData);
  QSet<int> areasWithParticipant(qint32 participantId) const;
  QSet<int> assignmentsWithTargetParticipantId(qint32 targetParticipantId) const;

  void updateInternalLos(const QSet<int> &changingAssignmentIds,         // ~static
                         const QSet<int> &changingAreaIds,               // ~static
                         const QSet<int> &changingTartgetIds,            // ~dynamic
                         int changedParticipantId = 0);           // ~dynamic

  bool updateInternalLosSingleAssignment(ObjectTargetAreaAssignment *assignment);

  QSet<int> visibleParticipantsPerTargetParticipantId(int targetParticipantId);

  bool lineOfSight(const Core::GeoPosition &observerPos, const Core::GeoPosition &targetPos) const;

  void syncExternal();

private:
  MainHandler                                  *m_mainHandler;

  QMap<int, QSet<int>>                          m_participantsPerArea;
  QMap<int, QSet<int>>                          m_visibleParticipantsPerAssignment;

  std::shared_ptr<HandlerShootbackArea>         m_handlerShootbackArea;
  std::shared_ptr<HandlerShootbackTarget>       m_handlerShootbackTarget;
  std::shared_ptr<HandlerTargetAreaAssignment>  m_handlerTargetAreaAssignment;

  SituationMap::ElevationMap                   *m_elevationMap; // do not delete at dtor
  SituationMap::LineOfSightCalculation         *m_losCalculation;


  NGL::INGLLogger &m_logger;
};

} // namespace TargetManagement