/**
 * @file   Xpl2Client.cpp
 * @brief  TCP client for the Alchemie XPL2 printhead protocol.
 */
#include "Xpl2Client.h"

Xpl2Client::Xpl2Client (QObject *parent) : QObject (parent)
{
  connect (&m_commandSocket, &QTcpSocket::connected, this,
           &Xpl2Client::onCommandSocketConnected);
  connect (&m_commandSocket, &QTcpSocket::disconnected, this,
           &Xpl2Client::onCommandSocketDisconnected);
  connect (&m_commandSocket, &QTcpSocket::readyRead, this,
           &Xpl2Client::onCommandSocketReadyRead);
  connect (&m_commandSocket, &QAbstractSocket::errorOccurred, this,
           &Xpl2Client::onCommandSocketError);

  connect (&m_imagingSocket, &QTcpSocket::connected, this,
           &Xpl2Client::onImagingSocketConnected);
  connect (&m_imagingSocket, &QTcpSocket::disconnected, this,
           &Xpl2Client::onImagingSocketDisconnected);
  connect (&m_imagingSocket, &QTcpSocket::readyRead, this,
           &Xpl2Client::onImagingSocketReadyRead);
  connect (&m_imagingSocket, &QAbstractSocket::errorOccurred, this,
           &Xpl2Client::onImagingSocketError);

  connect (&m_statusSocket, &QTcpSocket::connected, this,
           &Xpl2Client::onStatusSocketConnected);
  connect (&m_statusSocket, &QTcpSocket::disconnected, this,
           &Xpl2Client::onStatusSocketDisconnected);
  connect (&m_statusSocket, &QTcpSocket::readyRead, this,
           &Xpl2Client::onStatusSocketReadyRead);
  connect (&m_statusSocket, &QAbstractSocket::errorOccurred, this,
           &Xpl2Client::onStatusSocketError);
}

QString
Xpl2Client::host () const
{
  return m_host;
}

void
Xpl2Client::setHost (const QString &host)
{
  if (m_host == host)
    return;
  m_host = host;
  emit hostChanged ();
}

quint16
Xpl2Client::commandPort () const
{
  return m_commandPort;
}

void
Xpl2Client::setCommandPort (quint16 port)
{
  if (m_commandPort == port)
    return;
  m_commandPort = port;
  emit commandPortChanged ();
}

quint16
Xpl2Client::imagingPort () const
{
  return m_imagingPort;
}

void
Xpl2Client::setImagingPort (quint16 port)
{
  if (m_imagingPort == port)
    return;
  m_imagingPort = port;
  emit imagingPortChanged ();
}

quint16
Xpl2Client::statusPort () const
{
  return m_statusPort;
}

void
Xpl2Client::setStatusPort (quint16 port)
{
  if (m_statusPort == port)
    return;
  m_statusPort = port;
  emit statusPortChanged ();
}

bool
Xpl2Client::isConnected () const
{
  return m_connected;
}

void
Xpl2Client::connectToServer ()
{
  if (m_connected)
    {
      emit statusMessage (QStringLiteral ("Already connected"));
      return;
    }
  emit statusMessage (QStringLiteral ("Connecting to %1 (ports %2/%3/%4)…")
                          .arg (m_host)
                          .arg (m_commandPort)
                          .arg (m_imagingPort)
                          .arg (m_statusPort));
  m_commandSocket.connectToHost (m_host, m_commandPort);
  m_imagingSocket.connectToHost (m_host, m_imagingPort);
  m_statusSocket.connectToHost (m_host, m_statusPort);
}

void
Xpl2Client::disconnectFromServer ()
{
  m_commandSocket.disconnectFromHost ();
  m_imagingSocket.disconnectFromHost ();
  m_statusSocket.disconnectFromHost ();
}

void
Xpl2Client::sendToCommandSocket (const QString &message)
{
  sendToSocket (m_commandSocket, QStringLiteral ("Command"), message);
}

void
Xpl2Client::sendToImagingSocket (const QString &message)
{
  sendToSocket (m_imagingSocket, QStringLiteral ("Imaging"), message);
}

void
Xpl2Client::sendToStatusSocket (const QString &message)
{
  sendToSocket (m_statusSocket, QStringLiteral ("Status"), message);
}

void
Xpl2Client::sendToSocket (QTcpSocket &socket, const QString &label,
                          const QString &message)
{
  if (socket.state () != QAbstractSocket::ConnectedState)
    {
      emit errorOccurred (
          QStringLiteral ("%1 socket not connected").arg (label));
      return;
    }
  QByteArray data = message.toUtf8 () + '\n';
  socket.write (data);
  emit statusMessage (QStringLiteral ("Sent [%1]: %2").arg (label, message));
}

void
Xpl2Client::updateConnectedState ()
{
  bool allConnected
      = m_commandSocket.state () == QAbstractSocket::ConnectedState
        && m_imagingSocket.state () == QAbstractSocket::ConnectedState
        && m_statusSocket.state () == QAbstractSocket::ConnectedState;
  if (m_connected == allConnected)
    return;
  m_connected = allConnected;
  emit connectedChanged ();
}

void
Xpl2Client::onCommandSocketConnected ()
{
  emit statusMessage (QStringLiteral ("Command socket connected"));
  updateConnectedState ();
}

void
Xpl2Client::onCommandSocketDisconnected ()
{
  emit statusMessage (QStringLiteral ("Command socket disconnected"));
  updateConnectedState ();
}

void
Xpl2Client::onCommandSocketReadyRead ()
{
  while (m_commandSocket.canReadLine ())
    {
      QString line
          = QString::fromUtf8 (m_commandSocket.readLine ()).trimmed ();
      emit commandSocketResponseReceived (line);
    }
}

void
Xpl2Client::onCommandSocketError (QAbstractSocket::SocketError error)
{
  Q_UNUSED (error)
  emit errorOccurred (
      QStringLiteral ("Command: %1").arg (m_commandSocket.errorString ()));
}

void
Xpl2Client::onImagingSocketConnected ()
{
  emit statusMessage (QStringLiteral ("Imaging socket connected"));
  updateConnectedState ();
}

void
Xpl2Client::onImagingSocketDisconnected ()
{
  emit statusMessage (QStringLiteral ("Imaging socket disconnected"));
  updateConnectedState ();
}

void
Xpl2Client::onImagingSocketReadyRead ()
{
  while (m_imagingSocket.canReadLine ())
    {
      QString line
          = QString::fromUtf8 (m_imagingSocket.readLine ()).trimmed ();
      emit imagingSocketResponseReceived (line);
    }
}

void
Xpl2Client::onImagingSocketError (QAbstractSocket::SocketError error)
{
  Q_UNUSED (error)
  emit errorOccurred (
      QStringLiteral ("Imaging: %1").arg (m_imagingSocket.errorString ()));
}

void
Xpl2Client::onStatusSocketConnected ()
{
  emit statusMessage (QStringLiteral ("Status socket connected"));
  updateConnectedState ();
}

void
Xpl2Client::onStatusSocketDisconnected ()
{
  emit statusMessage (QStringLiteral ("Status socket disconnected"));
  updateConnectedState ();
}

void
Xpl2Client::onStatusSocketReadyRead ()
{
  while (m_statusSocket.canReadLine ())
    {
      QString line = QString::fromUtf8 (m_statusSocket.readLine ()).trimmed ();
      emit statusSocketResponseReceived (line);
    }
}

void
Xpl2Client::onStatusSocketError (QAbstractSocket::SocketError error)
{
  Q_UNUSED (error)
  emit errorOccurred (
      QStringLiteral ("Status: %1").arg (m_statusSocket.errorString ()));
}