/**
  * @RDE_HEADER@
  * Routing Test - Watch for Exercises and create routes
  * $Id$
  * $HeadURL$
  * $Author$
  */

#include "partition_handler.h"
#include <DDS/DDSConnector/dds_connector.h>

namespace RoutingService
{
PartitionHandler::PartitionHandler(const std::shared_ptr<DDSConnector::DdsConnector> &ddsConnector, QObject *parent)
  : QObject(parent)
  , m_exmDtc(ExerciseManagement::Interface::Dtc::create(ddsConnector))
  , m_destroyTimer(new QTimer(this))
  , m_logger(getLogger("PartitionHandler"))
{
  m_exmDtc->enableExercise();

  m_destroyTimer->setInterval(1000);
  m_destroyTimer->setSingleShot(false);

  connect(m_destroyTimer, &QTimer::timeout, this, &PartitionHandler::onDestroyTimerTimeout);
}

PartitionHandler::~PartitionHandler()
{
  qDeleteAll(m_destroyMap);
}

bool PartitionHandler::init()
{
  connect(m_exmDtc.get(), &ExerciseManagement::Interface::Dtc::exerciseChanged,
          this, &PartitionHandler::onExerciseChanged);

  m_exmDtc->exercises([this](const ExerciseManagement::Exercise &exercise) {onExerciseChanged(exercise, DataModification::eAdded);});
  return true;
}

void PartitionHandler::partitionModified(const QString &partitionName, const ExerciseManagement::ExerciseState &state)
{
  if (state == ExerciseManagement::ExerciseState::Unknown ||
      state == ExerciseManagement::ExerciseState::Terminated)
  {
    partitionRemoved(partitionName);
    return;
  }

  m_destroyMap.remove(partitionName);
  auto it = m_activeSessions.find(partitionName);
  if (it != m_activeSessions.end())
    return;
  m_activeSessions.insert(partitionName);
  if (!m_destroyTimer->isActive())
    m_destroyTimer->start();

  emit createSession(partitionName, partitionName);
}

void PartitionHandler::partitionRemoved(const QString &partitionName)
{
  QElapsedTimer *et = new QElapsedTimer;
  et->start();
  m_destroyMap.insert(partitionName, et);
}

void PartitionHandler::onExerciseChanged(const ExerciseManagement::Exercise &data, DataModification modType)
{
  const QString partitionName(QString::fromStdString(DDSConnector::DdsConnector::getPartitionString(IDL::PartitionType::Exercise, data.id())));
  DEBUG_LOG(m_logger) << "onExerciseChanged: " << data << ", modType: " << modType;
  switch (modType)
  {
  case DataModification::eRemoved:
    partitionRemoved(partitionName);
    break;
  case DataModification::eAdded:
  case DataModification::eModified:
    partitionModified(partitionName, data.state());
    break;
  }
}

void PartitionHandler::onDestroyTimerTimeout()
{
  auto it = m_destroyMap.begin();
  while (it != m_destroyMap.end())
  {
    QElapsedTimer *et = it.value();
    if (et->elapsed() < 5 * 1000)
    {
      ++it;
      continue;
    }
    DEBUG_LOG(m_logger) << "onDestroyTimerTimeout for session " << it.key() << " triggered";
    delete et;
    m_activeSessions.remove(it.key());
    emit destroySession(it.key(), it.key());
    it = m_destroyMap.erase(it);
  }
}


} // namespace RoutingService