/**
 * 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 "participant_handler.h"

#include <QtCore/QElapsedTimer>
#include <QtCore/QHash>
#include <QtCore/QMutex>
#include <QtCore/QString>

#include <QJsonDocument>
#include <ExerciseManagement/exm_dtc.h>
#include <ParticipantManagement/ppm_dtc.h>
#include <ParticipantManagement/ppm_fts.h>
#include <ProjectDataManagement/pdm_dtc.h>
#include <TrainingAreaBase/tab_dts.h>

class QTimer;
class QTransform;

namespace ParticipantManagement
{
class MainHandler;

namespace ParticipantHandling
{
class FiringUnitValidator;
class ProxyListener;

class ParticipantHandlerForExercise final
    : public ParticipantHandler
    , protected Interface::Fts::ModifyStateRequestHandler
    , protected Interface::Fts::ModifyParticipantDataRequestHandler
    , protected Interface::Fts::InitParticipantRequestHandler
    , protected Interface::Fts::SetParticipantModeRequestHandler
    , protected Interface::Fts::SendMessageRequestHandler
    , protected Interface::Fts::RegisterParticipantRequestHandler
    , protected Interface::Fts::SetSimulatedPositionRequestHandler
    , protected Interface::Fts::SetSimulatedPositionRelativeRequestHandler
    , protected Interface::Fts::SetSimulatedParticipantFormationRequestHandler
    , protected Interface::Fts::SetSanitationRequestHandler
    , protected Interface::Fts::SelectiveReammunitionRequestHandler
    , protected Interface::Fts::SetAsSimulatedRequestHandler
    , protected Interface::Fts::OcCommandRequestHandler
    , protected Interface::Fts::ModifyUasStateRequestHandler
{
  Q_OBJECT
  public:
  explicit ParticipantHandlerForExercise(MainHandler *mainHandler);
  ~ParticipantHandlerForExercise();
  bool init() override;

  void setEquipmentNumberForParticipant(int oldEqNo, int newEqNo, int participantId) override;
  bool isUnitType(int typeId) const override;

  public Q_SLOTS:
  void onGearChargeChanged(int participantId, int partyId);

  protected:
  struct ParticipantFormationStruct
  {
    QString geometry = QStringLiteral("line");
    double distance = -1;
    double angle = -1;
    QString jsonData;
    QJsonObject distanceSetsObj;
    QVariantMap distanceSets;
    ParticipantFormationStruct() {}
    explicit ParticipantFormationStruct(const QString &formationProperty) : jsonData(formationProperty)
    {
      const QJsonObject formationObj = QJsonDocument::fromJson(QByteArray::fromStdString(jsonData.toStdString())).object();
      if (formationObj.isEmpty())
        return;
      geometry = formationObj[QStringLiteral("geometry")].toString(QStringLiteral("line"));
      angle = formationObj[QStringLiteral("angle")].toDouble(-1);
      distance = formationObj[QStringLiteral("distance")].toDouble(-1);
      distanceSetsObj = formationObj[QStringLiteral("distanceSets")].toObject();
      distanceSets = distanceSetsObj.toVariantMap();
    }

public:
    bool hasFormationData() const { return ((angle != -1) && (distance != -1)); }
  };

  void getFormationParameters(const QString &jsdata, QString &geometry, double &distance, double &angle);
  void setFormationAsLine(Participant *participant, const SetSimulatedParticipantFormation &request, const double distance, const double angleDeg);

  void createHitlineInfo(int originatorId,
                         Participant *originParticipant,
                         Participant *participantToBeChanged,
                         const TrainingAreaBase::EquipmentPosition &pos,
                         int originatorChargeTypeId,
                         qint64 sampleTime) override;
  void onModifyParticipantDataRequest(const rti::core::SampleIdentity &cookie, const ModifyParticipantDataRequest &request) override;
  Core::FunctionReplyObject modifyParticipantDataRequest(const ModifyParticipantDataRequest &request);
  // ModifyState
  void onModifyStateRequest(const rti::core::SampleIdentity &cookie, const ModifyStateRequest &request) override;
  Core::FunctionReplyObject modifyStateRequest(const rti::core::SampleIdentity &cookie, const ModifyStateRequest &request);
  // Init
  void onInitParticipantRequest(const rti::core::SampleIdentity &cookie, const InitParticipantRequest &request) override;
  Core::FunctionReplyObject initParticipantRequest(const rti::core::SampleIdentity &cookie, const InitParticipantRequest &request);
  // Mode
  void onSetParticipantModeRequest(const rti::core::SampleIdentity &cookie, const SetParticipantModeRequest &request) override;
  Core::FunctionReplyObject setParticipantModeRequest(const rti::core::SampleIdentity &cookie, const SetParticipantModeRequest &request);

  void onSendMessageRequest(const rti::core::SampleIdentity &cookie, const SendMessageRequest &request) override;
  Core::FunctionReplyObject sendMessageRequest(const rti::core::SampleIdentity &cookie, const SendMessageRequest &request);
  void onRegisterParticipantRequest(const rti::core::SampleIdentity &cookie, const RegisterParticipantRequest &request) override;
  Core::FunctionReplyObject registerParticipantRequest(const RegisterParticipantRequest &request_, RegisterReturnValue &retVal);

  void onSetSimulatedPositionRequest(const rti::core::SampleIdentity &cookie, const SetSimulatedPosition &request) override;
  Core::FunctionReplyObject setSimulatedPositionRequest(const SetSimulatedPosition &request);
  void setSimulatedPosition(Participant *participant, const SetSimulatedPosition &request);

  void onSetSimulatedPositionRelativeRequest(const rti::core::SampleIdentity &cookie, const SetSimulatedPositionRelative &request) override;
  Core::FunctionReplyObject setSimulatedPositionRelativeRequest(const SetSimulatedPositionRelative &request);
  void setSimulatedPositionRelative(Participant *participant, const SetSimulatedPositionRelative &request);

  void onSetSimulatedParticipantFormationRequest(const rti::core::SampleIdentity &cookie, const SetSimulatedParticipantFormation &request) override;
  Core::FunctionReplyObject setSimulatedParticipantFormationRequest(const SetSimulatedParticipantFormation &request);

  void onSetSanitationRequest(const rti::core::SampleIdentity &cookie, const SetSanitationRequest &request) override;
  Core::FunctionReplyObject setSanitationRequest(const rti::core::SampleIdentity &cookie, const SetSanitationRequest &request);

  void onSelectiveReammunitionRequest(const rti::core::SampleIdentity &cookie, const SelectiveReammunitionRequest &request) override;
  Core::FunctionReplyObject selectiveReammunitionRequest(const rti::core::SampleIdentity &cookie, const SelectiveReammunitionRequest &request);

  void onSetAsSimulatedRequest(const rti::core::SampleIdentity &cookie, const SetAsSimulated &request) override;
  Core::FunctionReplyObject setAsSimulatedRequest(const SetAsSimulated &request);

  // OcCommand
  void onOcCommandRequest(const rti::core::SampleIdentity &cookie, const OcCommandRequest &request) override;
  Core::FunctionReplyObject ocCommandRequest(const rti::core::SampleIdentity &cookie, const OcCommandRequest &request);

  void updateParticipantFormation(Participant *participant, const Core::GeoPosition &position, const QPointF &offset);
  void setAsSimulated(const SetAsSimulated &request);
  void onModifyUasStateRequest(const rti::core::SampleIdentity &cookie, const ModifyUasStateRequest &request) override final;

  private:                       // methods
  struct ValidateParticipantData // is needed as QtConcurrent can only handle functions with up to 5 parameter ...
  {
    QVector<ParticipantData> participantsToBeCreatedOrModified;
    QHash<int, int> modIdToParticipantId;            // <modId, participantId>
    QVector<int> participantsToResetEquipmentNumber; // when move from template to pool, we have to reset the equipment number if it already exists
    bool forceAddWithId;
  };

  Core::FunctionReplyObject createNewParticipants(std::vector<Database::PpmParticipant> &dbParticipantsToBeCreated,
                                                  const std::vector<int> &dbParticipantsToBeCreatedIndexes,
                                                  const QVector<ParticipantData> &participantsToBeCreatedOrModified,
                                                  QHash<int, int> &modIdToParticipantId,
                                                  QSet<Participant *> &participantsWithChanges);
  Core::FunctionReplyObject validateParticipantData(ValidateParticipantData &data, const ParticipantManagement::ParticipantData &participantToValidate);

  std::vector<int32_t> inferiorIdsForParticipant(int32_t superiorParticipantId) const;
  Core::FunctionReplyObject checkDeleteParticipant(int id);
  Core::FunctionReplyObject deleteParticipant(int32_t id, bool permanentRemove, bool isTriggeredFromFtRequest = false);

  const Type *typeById(int typeId) const;
  bool isSupportType(int typeId) const;
  bool isParticipantType(int typeId) const;

  void startLongAction();
  void checkLongActionBreak();

  bool participantIds2EquipmentNumbers(const std::vector<int32_t> &participantIds, std::vector<int32_t> &equipmentNumbers, int *failedParticipantId) const;
  void onEquipmentExerciseMappingChanged(const EquipmentExerciseMapping &data, DataModification mod);
  void onExerciseChanged(const ExerciseManagement::Exercise &data, DataModification mod);
  void publishEquipmentExerciseMapping();
  bool isCurrentExerciseActive() const;

  QString lookUpHierachy(int participantId) const;
  QString participantInfosFromId(int participantId) const;
  void customedSetGearCharges(Participant *participant);
  Core::FunctionReplyObject modifyUasStateRequest(const rti::core::SampleIdentity &cookie, const ParticipantManagement::ModifyUasStateRequest &request);

  private: // attributes
  MainHandler *m_mainHandler;
  FiringUnitValidator *m_firingUnitValidator{nullptr};
  std::shared_ptr<ExerciseManagement::Interface::Dtc> m_exmDtc;
  std::shared_ptr<TrainingAreaBase::Interface::Dts> m_dtsTab;
  std::shared_ptr<ParticipantManagement::Interface::Dtc> m_ppmDtc;
  std::shared_ptr<ProjectDataManagement::Interface::Dtc> m_pdmDtc;
  std::unique_ptr<ProxyListener> m_proxyListener;
  QElapsedTimer m_longActionTimer;
  QTimer *m_hitLineInfoTimer;
  QTimer *m_publishEquipmentExerciseMappingsTimer;
  QHash<int, Database::EquipmentExerciseMapping> m_equipmentExerciseMappings; // QHash<eqId, Database::EquipmentExerciseMapping>
  bool m_publishEquipmentExerciseMappings;
}; // class ParticipantHandler
} // namespace ParticipantHandling
} // namespace ParticipantManagement