/**
  * Convert telegrams to Json and sent to WLS proxy
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Christian Ehrlicher, SLSE, 2016-09-26
  */

#include "hla_handler_tx.h"
#include "ppm_handler.h"
#include "pdm_handler.h"
#include <QJsonDocument>
#include <QWebSocket>
namespace ApHlaJson
{
class PpmHandler;
HlaHandlerTx::HlaHandlerTx(TrainingAreaBase::Plugin::DataProvider *pdp, PpmHandler* ppmHandler, PdmHandler* pdmHandler)
  : m_pdp(pdp)
  , m_ppmHandler(ppmHandler)
  , m_pdmHandler(pdmHandler)
  , m_webSocket(nullptr)
  , m_bHlaConnectedToExternalSystem(false)
  , m_logger(getLogger("HlaHandlerTx"))
{}

void HlaHandlerTx::onWebSocketConnected(QWebSocket *webSocket)
{
  m_webSocket = webSocket;
  if (!m_webSocket)
  {
    return;
  }
}

void HlaHandlerTx::onWebSocketDisconnected()
{
  m_ppmHandler->disconnect(this);
  m_pdmHandler->disconnect(this);
  m_webSocket = nullptr;
}

void HlaHandlerTx::onHlaConnectedToExternalSystem(bool bConnected)
{
  m_bHlaConnectedToExternalSystem = bConnected;

  NOTICE_LOG(m_logger) << "Connected to Old HLA Interface - exercise environment, charges and participants";
  const auto tele2 = m_pdp->exerciseEnvironmentData();
  sendToTx(&tele2, true);
  connect(m_ppmHandler, &PpmHandler::participantChanged, this, &HlaHandlerTx::onGenericTelegram, Qt::UniqueConnection);
  connect(m_pdmHandler, &PdmHandler::sendChargeTypes,    this, &HlaHandlerTx::onGenericTelegram, Qt::UniqueConnection);
  m_pdmHandler->getChargeTypes();
  m_ppmHandler->getParticipants();
}

TrainingAreaBase::SendToTab::HandleState HlaHandlerTx::canHandleTelegram(int equipmentNumber, int telegramId) const
{
  if (!m_webSocket || !m_bHlaConnectedToExternalSystem)
    return HandleState::No;

  using namespace TrainingAreaBase::TetraIcd;
//  if (telegramId == Constraints<ExerciseEquipmentAssignmentComplete>::id() ||
//      telegramId == Constraints<ExerciseStateData>::id())
//    return HandleState::YesShare;

  if (equipmentNumber <= 0 || !m_dataCommunicationPossible.value(equipmentNumber, false))
    return HandleState::No;

  if (telegramId == Constraints<Init>::id() ||
      telegramId == Constraints<DemandVulnerabilityStateChange>::id() ||
      telegramId == Constraints<SelectiveReammunition>::id() ||
      telegramId == Constraints<CesHitInformation>::id()
      )
    return HandleState::YesConsume;

  return HandleState::No;
}

void HlaHandlerTx::resetSendCounter()
{
  // nothing to do
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::Init &data)
{
  return sendToTx(&data);
}
bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::DemandVulnerabilityStateChange &data)
{
  return sendToTx(&data);
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::CesHitInformation &data)
{
  return sendToTx(&data);
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::ExerciseEnvironmentData &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::Acknowledge &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::DemandBite &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::SetVulnerabilityModel &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::DemandEquipmentConfigurationReport &data)
{
  Q_UNUSED(data);
  return false;
}


bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::LanguageSelection &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::EquipmentMessage &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::EquipmentMessageOC &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::CreateSingleExplosion &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::CreateAreaExplosion &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::CreateMineArea &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::MineAreaSingleMineState &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::CreateNContamination &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::CreateCContamination &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::DeactivateEffectSimulation &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::ModifyAreaEffectSimulationName &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::PauseEffectSimulation &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::ResumeEffectSimulation &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::MineTriggered &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::DusMineReactivation &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::CreateFunctionalArea &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::CreateDusSingleMine &data)
{
  Q_UNUSED(data);
  return false;
}


bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::ExerciseStateData &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::OpaquePayloadDataOut &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::ParticipantSwVersionsRequest &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::TechnicalArea &data)
{
  Q_UNUSED(data);
  return false; // only for Tetra - really?
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::CesHitRequest &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::ParticipantMode &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::DemandParticipantMode &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::ParticipantConfiguration &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::DemandParticipantConfiguration &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::ExerciseEquipmentAssignmentComplete &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::Sanitation &data)
{
  Q_UNUSED(data);
  return false;
}

bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::SelectiveReammunition &data)
{
  Q_UNUSED(data);
  return false;
}

void HlaHandlerTx::onParticipantConnectionState(int equipmentNumber, bool dataCommunicationPossible)
{
  INFO_LOG(m_logger) << "onParticipantConnectionState - " << equipmentNumber
                     << ", communication possible: " << dataCommunicationPossible;
  if (equipmentNumber == -1)
    m_dataCommunicationPossible.clear();
  m_dataCommunicationPossible[equipmentNumber] = dataCommunicationPossible;
}

void HlaHandlerTx::onGenericTelegram(const QJsonObject &telegram)
{
  if (!m_webSocket || !m_bHlaConnectedToExternalSystem)
    return;
  const QByteArray ba = QJsonDocument(telegram).toJson(QJsonDocument::Compact);
  DEBUG_LOG(m_logger) << "Sending tele: " << ba;
  m_webSocket->sendTextMessage(QString::fromUtf8(ba));
}


bool HlaHandlerTx::sendToTx(const TrainingAreaBase::TetraIcd::TrainingAreaTelegram *data, bool bForce)
{
  Q_UNUSED(bForce);
  QJsonObject telegram;
  telegram[QStringLiteral("data")] = data->toJson();
  telegram[QStringLiteral("type")] = data->type();
  telegram[QStringLiteral("typeId")] = data->id();
  onGenericTelegram(telegram);
  return true;
}

QHash<int, bool> HlaHandlerTx::dataCommunicationPossible() const
{
  return m_dataCommunicationPossible;
}


} // namespace HlaJson