#include "pacemaker.h"

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

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::CorePortType 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::CorePortType portType, const QString& properties)
{
    if (!m_state.ports.has_value())
        m_state.ports = std::vector<Core::PortInformation>();
    m_state.ports.value().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();
}

#else // BUILD_RTI

Pacemaker::Pacemaker(void* ddsConnector)
  : QObject(nullptr)
{
    Q_UNUSED(ddsConnector)
}

Pacemaker::~Pacemaker()
{
}

void Pacemaker::setNewState(Core::RunningState newState, const QString& errorString)
{
    Q_UNUSED(newState)
    Q_UNUSED(errorString)
}

void Pacemaker::setNewStateInternal(Core::RunningState newState, const QString& errorString)
{
    Q_UNUSED(newState)
    Q_UNUSED(errorString)
}

void Pacemaker::addPort(unsigned short number, Core::CorePortType portType, const QString& properties)
{
    Q_UNUSED(number)
    Q_UNUSED(portType)
    Q_UNUSED(properties)
}

void Pacemaker::addPortInternal(unsigned short number, Core::CorePortType portType, const QString& properties)
{
    Q_UNUSED(number)
    Q_UNUSED(portType)
    Q_UNUSED(properties)
}

void Pacemaker::publishState()
{
}

void Pacemaker::init(void* ddsConnector)
{
    Q_UNUSED(ddsConnector)
}

void Pacemaker::startTimer()
{
}

#endif // BUILD_RTI

} // namespace Core