/**
  * MainHandler for HighLevelArchitecture
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Christian Ehrlicher, SLSE, 2017-04-07
  */

#include "main_handler.h"
#include <Common/logger.h>
#include "ngs_handler.h"
#include "web_socket_handler.h"
#include <Common/settings.h>
#include <QCoreApplication>
#include <QTimer>
#include <DDS/Core/pacemaker.h>

namespace HighLevelArchitecture
{

MainHandler::MainHandler(QObject *parent)
  : QObject(parent)
  , m_exerciseId(0)
  , m_logger(getLogger("MainHandler"))
{}

MainHandler::~MainHandler()
{
  m_ngsHandler = nullptr;
  m_ddsHandler = nullptr;
}

bool MainHandler::init(int domainId, int exerciseId)
{
  m_exerciseId = exerciseId;
  // initialize DDS
  m_ddsHandler = std::make_shared<DdsHandler>(domainId, exerciseId);
  if (!m_ddsHandler->init())
  {
    ERROR_LOG(m_logger) << "Could not init DDS handler";
    return false;
  }
  connect(m_ddsHandler.get(), &DdsHandler::exerciseHlaStateChanged,
          this, &MainHandler::onExerciseHlaStateChanged);

  onExerciseHlaStateChanged(m_ddsHandler->exerciseHasHlaConnection());

  m_ddsHandler->pacemaker()->setNewState(Core::RunningState::Running);
  return true;
}

bool MainHandler::isConnectedToHla() const
{
  return m_ngsHandler && m_ngsHandler->isConnectedToHla();
}

void MainHandler::onExerciseHlaStateChanged(bool bHlaEnabled)
{
  NOTICE_LOG(m_logger) << "HLA State Changed: HLA is now " << (bHlaEnabled ? "EN" : "DIS") << "ABLED in this exercise";
  if (bHlaEnabled)
  {
    if (m_ngsHandler && m_wsHandler)
      return;

    if (!m_wsHandler)
    {
      m_wsHandler = std::make_shared<WebSocketHandler>(m_exerciseId, this);
      if (!m_wsHandler->init(Settings::webSocketListenPort()))
      {
        m_wsHandler = nullptr;
        return;
      }
    }

    if (!m_ngsHandler)
    {
      m_ngsHandler = std::make_shared<NgsHandler>();
      if (!m_ngsHandler->init(m_ddsHandler))
      {
        m_ngsHandler = nullptr;
        NOTICE_LOG(m_logger) << "Could not init ngs - stopping application";
        QCoreApplication::quit();
        return;
      }
    }
    connect(m_ngsHandler.get(), &NgsHandler::externalEquipmentNumberAdded,
            m_wsHandler.get(), &WebSocketHandler::onExternalEquipmentNumberAdded);
    connect(m_ngsHandler.get(), &NgsHandler::externalEquipmentNumberRemoved,
            m_wsHandler.get(), &WebSocketHandler::onExternalEquipmentNumberRemoved);
    connect(m_wsHandler.get(), &WebSocketHandler::initRequest,
            m_ngsHandler.get(), &NgsHandler::participantInitRequest);
    connect(m_wsHandler.get(), &WebSocketHandler::vulnerabilityStateRequest,
            m_ngsHandler.get(), &NgsHandler::participantVulnerabilityStateRequest);
    connect(m_wsHandler.get(), &WebSocketHandler::cesHitInformationRequest,
            m_ngsHandler.get(), &NgsHandler::participantCesHitInformationRequest);
    NOTICE_LOG(m_logger) << "onExerciseHlaStateChanged - created new ngsHandler";
    m_wsHandler->sendHlaConnectionState();
  }
  else
  {
    if (m_ngsHandler)
      NOTICE_LOG(m_logger) << "onExerciseHlaStateChanged - deleting ngsHandler";
    m_ngsHandler = nullptr;

    if (m_wsHandler)
    {
      m_wsHandler->sendHlaConnectionState();
      auto copy = m_wsHandler;
      QTimer::singleShot(2000, this, [copy]
      {
        copy->deleteLater();
      });
    }
    m_wsHandler = nullptr;
  }
}

} // namespace HighLevelArchitecture