/**
  * Get information about (O/C) participants to be able to send/receive messages for them
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Christian Ehrlicher, SLSE, 2016-12-13
  */


#include "exercises_handler.h"
#include "exercise_handler.h"

// subscribe to ex_* to gather
// 1. PPM::EquipmentExerciseMapping
// 2. TAB::EquipmentMessage
// create ExerciseHandler per Exercise (on demand when a message should be send to an O/C)

namespace Messaging
{
ExercisesHandler::ExercisesHandler(const std::shared_ptr<DdsHandler> &ddsHandler)
  : m_ddsHandler(ddsHandler)
  , m_logger(getLogger("ExercisesHandler"))
{
}

ExercisesHandler::~ExercisesHandler()
{
  qDeleteAll(m_exerciseHandler);
}

bool ExercisesHandler::init()
{
  m_ppmDtc = ParticipantManagement::Interface::Dtc::create(m_ddsHandler->ddsConnector());
  connect(m_ppmDtc.get(), &ParticipantManagement::Interface::Dtc::equipmentExerciseMappingChanged,
          this, &ExercisesHandler::onEquipmentExerciseMappingChanged);

  if (!m_ppmDtc->enableEquipmentExerciseMapping())
    return false;

  ERROR_LOG(m_logger) << "# eem: " << m_ppmDtc->equipmentExerciseMappings().size();
  return true;
}

int ExercisesHandler::findEquipmentNumber(int participantId, int exerciseId)
{
  QPair<int,int> exePart;
  exePart.first = exerciseId;
  exePart.second = participantId;
  return m_participant2EquipNumber.value(exePart);
}

bool ExercisesHandler::sendEquipmentMessage(const TrainingAreaBase::SendEquipmentMessageRequest &request)
{
  if (request.equipmentNumbers().size() == 0)
    return false;
  const int equipmentNumber = request.equipmentNumbers().at(0);
  auto it = m_equipNo2ExerciseId.constFind(equipmentNumber);
  if (it == m_equipNo2ExerciseId.cend())
  {
    ERROR_LOG(m_logger) << "Can not send equipment message to training area - equipment number "
                        << equipmentNumber << " not known";
    return false;
  }
  ExerciseHandler *exH = exerciseHandlerForExerciseId(it.value());
  return exH->sendEquipmentMessage(request);
}

bool ExercisesHandler::sendOcEquipmentMessage(const OcSituationServer::SendEquipmentMessageRequest &request)
{
  if (request.equipmentNumbers().size() == 0)
    return false;
  const int equipmentNumber = request.equipmentNumbers().at(0);
  auto it = m_equipNo2ExerciseId.constFind(equipmentNumber);
  if (it == m_equipNo2ExerciseId.cend())
  {
    ERROR_LOG(m_logger) << "Can not send equipment message to training area - equipment number "
                        << equipmentNumber << " not known";
    return false;
  }
  ExerciseHandler *exH = exerciseHandlerForExerciseId(it.value());
  return exH->sendOcEquipmentMessage(request);
}

ExerciseHandler *ExercisesHandler::exerciseHandlerForExerciseId(int exerciseId)
{
  const auto itEH = m_exerciseHandler.find(exerciseId);
  if (itEH != m_exerciseHandler.end())
    return itEH.value();

  DEBUG_LOG(m_logger) << "new ExerciseHandler for id " << exerciseId;
  auto exH = new ExerciseHandler(m_ddsHandler->ddsConnector(), exerciseId);
  bool result = exH->init();
  DEBUG_LOG(m_logger)<<"result init ="<<result;
  connect(exH, &ExerciseHandler::exerciseHandlerIdleTimeout,
          this, &ExercisesHandler::onExerciseHandlerIdleTimeout);
  m_exerciseHandler[exerciseId] = exH;
  return exH;
}

void ExercisesHandler::onEquipmentExerciseMappingChanged(const ParticipantManagement::EquipmentExerciseMapping &data,
                                                         DataModification modType)
{
  DEBUG_LOG(m_logger) << "onEquipmentExerciseMappingChanged";

  for (auto it = m_equipNo2ExerciseId.begin(); it != m_equipNo2ExerciseId.end(); )
  {
    if (it.value() != data.exerciseId())
      ++it;
    else
      it = m_equipNo2ExerciseId.erase(it);
  }

  switch (modType)
  {
  case DataModification::eAdded:
  case DataModification::eModified:
    for (const ParticipantManagement::Equipment2ParticipantId &e2p : data.mapping())
    {
      m_equipNo2ExerciseId[e2p.equipmentNumber()] = data.exerciseId();
      QPair<int,int> exePart;
      exePart.first = data.exerciseId();
      exePart.second = e2p.participantId();
      m_participant2EquipNumber[exePart] = e2p.equipmentNumber();
    }
    break;
  case DataModification::eRemoved:      
    break;
  }
}

void ExercisesHandler::onEquipmentMessageChanged(const TrainingAreaBase::EquipmentMessage &data, const DataModification modType)
{
  DEBUG_LOG(m_logger) << "onEquipmentMessageChanged";
  if (modType != DataModification::eAdded &&
      modType != DataModification::eModified)
    return;
  const int equipmentNumber = data.equipmentNumber();
  const auto it = m_equipNo2ExerciseId.constFind(equipmentNumber);
  if (it == m_equipNo2ExerciseId.constEnd())
  {
    ERROR_LOG(m_logger) << "Got EquipmentMessage from unknown participant with equipment number " << equipmentNumber;
    return;
  }
  emit messageFromTrainingArea(data);
}

void ExercisesHandler::onExerciseHandlerIdleTimeout()
{
  DEBUG_LOG(m_logger)<<"onExerciseHandlerIdleTimeout";
  ExerciseHandler *exH = qobject_cast<ExerciseHandler *>(sender());
  if (!exH)
    return;
  const int exerciseId = exH->exerciseId();
  auto it = m_exerciseHandler.find(exerciseId);
  if (it != m_exerciseHandler.end())
  {
    exH->deleteLater();
    m_exerciseHandler.erase(it);
  }
}

} // namespace Messaging