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

#include "main_handler_tx.h"
#include "tetra_handler_tx.h"
#include "wls_handler_tx.h"

using namespace TrainingAreaBase;

namespace WlsTetra
{
template<typename T>
struct HasHeaderStruct
{
  struct Fallback { TetraIcd::Header header; };
  struct Derived : T, Fallback { };

  template<typename C, C> struct ChT;

  template<typename C> static char (&f(ChT<TetraIcd::Header Fallback::*, &C::header> *))[1];
  template<typename C> static char (&f(...))[2];

public:
  static bool const value = sizeof(f<Derived>(nullptr)) == 2;
};

template <typename T, typename std::enable_if<HasHeaderStruct<T>::value, int>::type = 0>
static inline int getEquipNo(const T *data)
{
  return data->header.equipmentNumber;
}

template < typename T, typename std::enable_if < !HasHeaderStruct<T>::value, int >::type = 0 >
static inline int getEquipNo(const T *)
{
  return -1;
}

MainHandlerTx::MainHandlerTx(const std::shared_ptr<WlsHandlerTx> &wlsTx,
                             const std::shared_ptr<TetraHandlerTx> &tetraTx)
  : m_wlsHandlerTx(wlsTx)
  , m_tetraHandlerTx(tetraTx)
  , m_logger(getLogger("MainHandlerTx"))
{}

SendToTab::HandleState MainHandlerTx::canHandleTelegram(int equipmentNumber, int telegramId) const
{
  SendToTab::HandleState hsWls = m_wlsHandlerTx->canHandleTelegram(equipmentNumber, telegramId);
  if (hsWls == SendToTab::HandleState::YesConsume ||
      hsWls == SendToTab::HandleState::YesShare)
    return hsWls;
  SendToTab::HandleState hsTetra = m_tetraHandlerTx->canHandleTelegram(equipmentNumber, telegramId);
  if (hsTetra == SendToTab::HandleState::YesConsume ||
      hsTetra == SendToTab::HandleState::YesShare)
    return hsTetra;
  if (hsWls == SendToTab::HandleState::YesFallback)
    return hsWls;
  if (hsTetra == SendToTab::HandleState::YesFallback)
    return hsTetra;
  if (hsWls == SendToTab::HandleState::Debug)
    return hsWls;
  if (hsTetra == SendToTab::HandleState::Debug)
    return hsTetra;
  return SendToTab::HandleState::No;
}

void MainHandlerTx::resetSendCounter()
{
  m_wlsHandlerTx->resetSendCounter();
}

bool MainHandlerTx::txData(const TetraIcd::Acknowledge &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::DemandBite &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::Init &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::SetVulnerabilityModel &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::DemandEquipmentConfigurationReport &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::DemandVulnerabilityStateChange &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::LanguageSelection &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::EquipmentMessage &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::EquipmentMessageOC &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::CreateSingleExplosion &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::CreateAreaExplosion &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::CreateMineArea &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::MineAreaSingleMineState &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::CreateNContamination &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::CreateCContamination &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::DeactivateEffectSimulation &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::ModifyAreaEffectSimulationName &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::PauseEffectSimulation &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::ResumeEffectSimulation &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::MineTriggered &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::DusMineReactivation &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::CreateFunctionalArea &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::CreateDusSingleMine &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::ExerciseEnvironmentData &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::ExerciseStateData &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::OpaquePayloadDataOut &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::ParticipantSwVersionsRequest &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::TechnicalArea &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::CesHitInformation &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::CesHitRequest &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::ParticipantMode &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::DemandParticipantMode &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::ParticipantConfiguration &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::DemandParticipantConfiguration &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::ExerciseEquipmentAssignmentComplete &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::Sanitation &data)
{
  return sendToTxMixin(&data);
}

bool MainHandlerTx::txData(const TetraIcd::SelectiveReammunition &data)
{
  DEBUG_LOG(m_logger) << "MainHandlerTx::txData SelectiveReammunition";
  return sendToTxMixin(&data);
}
bool MainHandlerTx::txData(const TetraIcd::SetDevicePowerRequest &data)
{
  return sendToTxMixin(&data);
}
template <typename T>
bool MainHandlerTx::sendToTxMixin(const T *data)
{
  const int equipmentNumber = getEquipNo(data);
  SendToTab::HandleState hsWls = m_wlsHandlerTx->canHandleTelegram(equipmentNumber, data->id());
  SendToTab::HandleState hsTetra = m_tetraHandlerTx->canHandleTelegram(equipmentNumber, data->id());
  if (hsWls == SendToTab::HandleState::Debug)
    m_wlsHandlerTx->txData(*data);
  if (hsTetra == SendToTab::HandleState::Debug)
    m_tetraHandlerTx->txData(*data);

  if (hsWls == SendToTab::HandleState::YesConsume)
    return m_wlsHandlerTx->txData(*data);
  if (hsTetra == SendToTab::HandleState::YesConsume)
    return m_tetraHandlerTx->txData(*data);

  bool bRet = false;
  if (hsWls == SendToTab::HandleState::YesShare)
    bRet |= m_wlsHandlerTx->txData(*data);
  if (hsTetra == SendToTab::HandleState::YesShare)
    bRet |= m_tetraHandlerTx->txData(*data);

  if (bRet)
    return bRet;

  if (hsWls == SendToTab::HandleState::YesFallback)
    return m_wlsHandlerTx->txData(*data);
  if (hsTetra == SendToTab::HandleState::YesFallback)
    return m_tetraHandlerTx->txData(*data);

  return false;
}

} // namespace WlsTetra