#include "pacemaker.h"

#include <QCoreApplication>
#include <QThread>
#include <QTimer>
#include <NGLLogger/NGLLoggerBootstrap.h>
#include <DDS/DTS/generic_dts.h>
#include <DDS/DTS/generic_dts_impl.h>
#include <DDS/DDSConnector/dds_connector.h>

namespace Core
{
Pacemaker::Pacemaker(DDSConnector::DdsConnector *ddsConnector)
  : QObject(nullptr)
  , m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("Core.Pacemaker"))
{
  init(ddsConnector);
}

Pacemaker::~Pacemaker()
{
  m_paceThread->requestInterruption();
  m_paceThread->quit();
  m_paceThread->wait();
  delete m_paceThread;
  m_publishTimer->deleteLater();
  delete m_dtsCurrentRunningState;
}


void Pacemaker::setNewState(Core::RunningState newState, const QString &errorString)
{
  if (QThread::currentThread() == this->thread())
    setNewStateInternal(newState, errorString);
  else
    QTimer::singleShot(0, this, [this, newState, errorString]() { setNewStateInternal(newState, errorString); });
}

void Pacemaker::setNewStateInternal(Core::RunningState newState, const QString &errorString)
{
  m_state.runningState(newState);
  if (errorString.isEmpty())
    m_state.errorString().reset();
  else
    m_state.errorString(errorString.toStdString());
  publishState();
}

void Pacemaker::addPort(unsigned short number, Core::PortType portType, const QString &properties)
{
  if (QThread::currentThread() == this->thread())
    addPortInternal(number, portType, properties);
  else
    QTimer::singleShot(0, this, [this, number, portType, properties]() { addPortInternal(number, portType, properties); });
}

void Pacemaker::addPortInternal(unsigned short number, Core::PortType portType,const QString &properties)
{
  if (!m_state.ports().is_set())
    m_state.ports() = std::vector<Core::PortInformation>();
  m_state.ports().get().push_back(Core::PortInformation(number, portType, properties.toStdString()));

  publishState();
}

void Pacemaker::publishState()
{
  if (!m_dtsCurrentRunningState)
    return;
  m_dtsCurrentRunningState->write(m_state);
}

void Pacemaker::init(DDSConnector::DdsConnector *ddsConnector)
{
  m_dtsCurrentRunningState = ddsConnector->createDTS<DTS::CurrentRunningStateImpl>();
  if (!m_dtsCurrentRunningState)
  {
    WARNING_LOG(m_logger) << "Can not initialize DTS::CurrentRunningState!";
    return;
  }
  m_state.pid(QCoreApplication::applicationPid());
  m_state.runningState(Core::RunningState::Starting);

  m_paceThread = new QThread; 
  this->moveToThread(m_paceThread); 

  startTimer();
  publishState();
}

void Pacemaker::startTimer()
{
  if (m_publishTimer)
    return;

  m_publishTimer = new QTimer();


  m_publishTimer->moveToThread(m_paceThread);

  connect(m_publishTimer, &QTimer::timeout,
          this, &Pacemaker::publishState);

  m_publishTimer->setSingleShot(false);
  m_publishTimer->setInterval(m_publishTimerDelay);
  connect(m_paceThread, &QThread::started, this, [this](){
    m_publishTimer->start();
  });
 

  m_paceThread->start();
}

}