NtpClient.h

#pragma once
#include <NDEVR/ItemDownloader.h>
#include <NDEVR/String.h>
#include <cassert>
 
#include <memory>
 
#include <QtCore/QObject>
#include <QtNetwork/QHostAddress>
#include <QtNetwork/QUdpSocket>
#include <QHostInfo>
#include <NDEVR/NtpPacketFlags.h>
#include <NDEVR/NtpTimestamp.h>
#include <NDEVR/NtpPacket.h>
#include <NDEVR/NtpMode.h>
#include <NDEVR/NtpReply.h>
namespace NDEVR
{
    class NtpClient : public TimeRequest
    {
        Q_OBJECT;
    public:
        NtpClient(const StringView& host, uint02 bind_port, uint02 remote_port)
        {
            QHostInfo::lookupHost(host.getAs<QString>(), [this, bind_port, remote_port](const QHostInfo& host)
            {
                if (host.error() != QHostInfo::NoError) 
                {
                    emit errorOccurredSignal(0);
                    return;
                }
                QList<QHostAddress> addresses = host.addresses();
                if(addresses.size() > 0)
                {
                    if (bind(QHostAddress::Any, bind_port))
                        sendRequest(addresses[0], remote_port);
                    else if (bind(QHostAddress::Any, bind_port + 1))
                        sendRequest(addresses[0], remote_port);
                    else if (bind(QHostAddress::Any, bind_port + 2))
                        sendRequest(addresses[0], remote_port);
                    else
                        emit errorOccurredSignal(0);
                }
                else
                {
                    emit errorOccurredSignal(0);
                }
            });
        }

        virtual ~NtpClient() {}

        bool bind(const QHostAddress& bindAddress = QHostAddress::Any, quint16 bindPort = 0)
        {
            m_socket.reset(new QUdpSocket(this));
            if (!m_socket->bind(bindAddress, bindPort))
                return false;
 
            connect(m_socket.get(), &QUdpSocket::readyRead, this, &NtpClient::readPendingDatagrams);
            connect(m_socket.get(), &QUdpSocket::errorOccurred, this, [this]
            {
                emit errorOccurredSignal(0);
            });
            return true;
        }

        bool sendRequest(const String& address, quint16 port)
        {
            return sendRequest(QHostAddress(address.getAs<QString>()), port);
 
        }

        bool sendRequest(const QHostAddress& address, quint16 port)
        {
            assert(m_socket->state() == QAbstractSocket::BoundState); // Call bind() first.
            NtpPacket packet;
            memset(&packet, 0, sizeof(packet));
            packet.flags.mode = NtpMode::ClientMode;
            packet.flags.versionNumber = 4;
            packet.transmitTimestamp = NtpTimestamp(Time::SystemTime());
            if (m_socket->writeDatagram(reinterpret_cast<const char*>(&packet), sizeof(packet), address, port) < 0)
                return false;
 
            return true;
        }

        const QUdpSocket* socket() const {
            return m_socket.get();
        }
 
    Q_SIGNALS:
        void replyReceived(const QHostAddress& address, quint16 port, const NtpReply& reply);
 
    private Q_SLOTS:
        void readPendingDatagrams()
        {
            while (m_socket->hasPendingDatagrams()) {
                NtpFullPacket packet;
                memset(&packet, 0, sizeof(packet));
 
                QHostAddress address;
                quint16 port;
                if (m_socket->readDatagram(reinterpret_cast<char*>(&packet), sizeof(packet), &address, &port) < cast<qint64>(sizeof(NtpPacket)))
                    continue;
 
                m_reply = NtpReply(packet, Time::SystemTime());
                emit replyReceived(address, port, NtpReply(packet, Time::SystemTime()));
                emit finishedSignal();
            }
        }
        virtual Time serverTime() const override
        {
            return m_reply.originTime();
        }

        virtual Time rxTime() const override
        {
            return m_reply.destinationTime();
        }

        virtual Time txTime() const override
        {
            return m_reply.transmitTime();
        }
    private:
        NtpReply m_reply;                       
        std::unique_ptr<QUdpSocket> m_socket;   
    };
}