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

#include "hla_handler_rx.h"
#include "hla_dispatcher.h"
#include "aes_handler.h"
#include "ppm_handler.h"
#include <TrainingAreaBase/training_area_telegrams.h>
#include <QJsonDocument>

namespace ApHlaJson
{
/*!
 * \brief HlaHandlerRx::HlaHandlerRx
 * \param recvFromTabCb
 * \param sendToTabCb
 * \param dispatcher
 * \param aesHandler
 * \param ppmHandler
 * \author Niklas Schmidt
 * \details Handles all incoming telegrams from Apache
 */
HlaHandlerRx::HlaHandlerRx(const std::shared_ptr<TrainingAreaBase::RecvFromTab> &recvFromTabCb,
                           const std::shared_ptr<TrainingAreaBase::TxMixin> &sendToTabCb,
                           HlaDispatcher *dispatcher,
                           AesHandler* aesHandler,
                           PpmHandler* ppmHandler)
  : m_rxHandler(recvFromTabCb)
  , m_txHandler(sendToTabCb)//std::static_pointer_cast<TrainingAreaBase::SendToTab>(sendToTabCb))
  , m_dispatcher(dispatcher)
  , m_bWarnedOnce(false)
  , m_bWarnedOnceTx(false)
  , m_aesHandler(aesHandler)
  , m_ppmHandler(ppmHandler)
  , m_logger(getLogger("HlaHandlerRx"))
{}

bool HlaHandlerRx::handleTelegram(const QByteArray &baJson)
{
  using namespace TrainingAreaBase::TetraIcd;

  if (baJson.isEmpty())
    return false;
  const QJsonObject obj = QJsonDocument::fromJson(baJson).object();


  const QJsonValue typeId = obj.value(QStringLiteral("typeId"));
  if (!typeId.isDouble())
  {
    ERROR_LOG(m_logger) << "Can not read type id: " << baJson;
    return false;
  }
  const QJsonObject data = obj.value(QStringLiteral("data")).toObject();
  if(typeId.toInt() != 21)
    ERROR_LOG(m_logger) << "Telegram before filter: " << baJson;
  try
  {
    QJsonValue header = data[QStringLiteral("header")];
    QJsonObject obj = header.toObject();
    if (!obj.isEmpty())
    {
      int eqNo = obj[QStringLiteral("equipmentNumber")].toInt(0);
      if (eqNo <= 0)
        return false;
      if (!checkExercise(eqNo))
        return false;
    }
    if(typeId.toInt() != 21)
      ERROR_LOG(m_logger) << "Telegram after filter: " << baJson;
    switch (typeId.toInt())
    {
    case Constraints<ProxyConnectionState>::id(): // 2013
    {
      bool connected = ProxyConnectionState::fromJson(data).connectedToSystem;
      m_dispatcher->onHlaExternalConnectionStateChanged(connected);
    }
      break;
    case Constraints<CesHitInformation>::id(): // 211
      if(checkExercise(data[QStringLiteral("originatorEquipmentNumber")].toInt()))
        txData(CesHitInformation::fromJson(data));
      break;
    case Constraints<PositionReport>::id(): // 21
      rxData(PositionReport::fromJson(data));
      break;
    case Constraints<StateChangeDirect>::id(): //has originator
      rxData(StateChangeDirect::fromJson(data));
      break;
    case Constraints<StateChange>::id(): //has originator
      rxData(StateChange::fromJson(data));
      break;
    case Constraints<EquipmentGearEvent>::id():
      rxData(EquipmentGearEvent::fromJson(data));
      break;
    case Constraints<EquipmentGearAssignment>::id():
      rxData(EquipmentGearAssignment::fromJson(data));
      break;
    case Constraints<EquipmentGearChargeState>::id():
      rxData(EquipmentGearChargeState::fromJson(data));
      break;
    case Constraints<SpecialSensorData>::id():
      rxData(SpecialSensorData::fromJson(data));
      break;
    case 8006 :
      m_aesHandler->sendAesModifyRequest(data);
      break;
    case Constraints<ApacheLaserDesignation>::id():
      rxData(ApacheLaserDesignation::fromJson(data));
      break;
    case Constraints<WlsParticipantsConnectionState>::id(): // 3004
    {
      const auto tele = WlsParticipantsConnectionState::fromJson(data);
      if (checkExercise(tele.equipmentNumber))
        emit participantConnectionState(tele.equipmentNumber, tele.dataCommunicationPossible);
      break;
    }
    default:
      return false;
    }
  }
  catch (const std::exception &e)
  {
    WARNING_LOG(m_logger) << "Could not parse json: " << e.what() << " (" << baJson << ")";
    return false;
  }
  return true;
}

/*!
 \brief
 \details Check if Participant is in same Exercise than the TAB-Process is
 \param equipmentNumber
 \return bool
*/
bool HlaHandlerRx::checkExercise(int equipmentNumber) const
{
  return m_ppmHandler->isEqNumberInExercise(equipmentNumber);
}

template<typename T>
void HlaHandlerRx::rxData(const T &data)
{
  if (!m_rxHandler)
  {
    if (!m_bWarnedOnce)
    {
      ERROR_LOG(m_logger) << "No RecvFromTab available";
      m_bWarnedOnce = true;
    }
    return;
  }
  emit m_dispatcher->hlaTelegramReceived(&data);
  return m_rxHandler->rxData(data);
}

template<typename T>
void HlaHandlerRx::txData(const T &data)
{
  if (!m_txHandler)
  {
    if (!m_bWarnedOnceTx)
    {
      ERROR_LOG(m_logger) << "No RecvFromTab available";
      m_bWarnedOnceTx = true;
    }
    return;
  }
  emit m_dispatcher->hlaTelegramReceived(&data);
  m_txHandler->txData(data);
}

} // namespace HlaJson