/**
  * Send / Receive telegrams to/from PrtCnv
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Christian Ehrlicher, SLSE, 2016-09-26
  */

#include "nmea_dispatcher.h"
#include "nmea_handler_rx.h"
#include "nmea_handler_tx.h"
#include <QSettings>

namespace Nmea
{

NmeaDispatcher::NmeaDispatcher(TrainingAreaBase::Plugin::DataProvider *pdp,
                               const std::shared_ptr<TrainingAreaBase::RecvFromTab> &recvFromTabCb,
                               NGL::Settings *settings)
  : TrainingAreaBase::Plugin::Interface()
  , m_rxHandler(std::make_shared<NmeaHandlerRx>(recvFromTabCb))
  , m_txHandler(std::make_shared<NmeaHandlerTx>())
  , m_dataProvider(pdp)
  , m_settings(settings)
  , m_logger(getLogger("NmeaDispatcher"))
{

  m_reconnectTimer = new QTimer(this);

  // setup signal and slot
  connect(m_reconnectTimer, &QTimer::timeout,
          this, &NmeaDispatcher::reconnectTimerSlot);


  m_nmeaHost = getNmeaHost();
  m_nmeaPort = getNmeaPort();

  DEBUG_LOG(m_logger) << "Host: " << m_nmeaHost << " Port: " << m_nmeaPort;
  m_socket = new QUdpSocket(this);
  connect(m_socket, &QUdpSocket::connected, this, &NmeaDispatcher::connected);
  connect(m_socket, &QUdpSocket::disconnected, this, &NmeaDispatcher::disconnected);
  connect(m_socket, &QUdpSocket::readyRead, this, &NmeaDispatcher::readyRead);
  connect(m_socket, &QUdpSocket::bytesWritten, this, &NmeaDispatcher::bytesWritten);
  reconnect();
}

bool NmeaDispatcher::init()
{
  return true;
}

std::shared_ptr<TrainingAreaBase::SendToTab> NmeaDispatcher::sendToTab()
{
  return std::static_pointer_cast<TrainingAreaBase::SendToTab>(m_txHandler);
}

bool NmeaDispatcher::canSendData() const
{
  return m_txHandler->isConnected();
}

void NmeaDispatcher::exerciseChanged()
{
}

void NmeaDispatcher::reconnect()
{
  INFO_LOG(m_logger) << "Connecting,.." << " host = " << m_nmeaHost
                     <<  " port = " << m_nmeaPort;;

  if(!m_socket->bind(m_nmeaPort, QAbstractSocket::BindFlag::ShareAddress | QAbstractSocket::BindFlag::ReuseAddressHint))
  {
    ERROR_LOG(m_logger) << "Error from Socket: " << m_socket->errorString();
    m_reconnectTimer->start(10000);
  }
  else
    m_txHandler->onUdpSocketConnected(m_socket, m_nmeaPort, m_nmeaHost);


}

void NmeaDispatcher::connected()
{
  m_reconnectTimer->stop();
  m_txHandler->onUdpSocketConnected(m_socket, m_nmeaPort, m_nmeaHost);
  DEBUG_LOG(m_logger) << "Connected!";
}


void NmeaDispatcher::disconnected()
{
  m_reconnectTimer->start();
  DEBUG_LOG(m_logger) << "Disconnected!";
}

void NmeaDispatcher::bytesWritten(qint64 bytes)
{
  DEBUG_LOG(m_logger) << "We wrote: " << bytes;
}

void NmeaDispatcher::reconnectTimerSlot()
{
  m_reconnectTimer->stop();
  INFO_LOG(m_logger) << "Reconnect NMEA-Socket "
                     << " host = " << m_nmeaHost
                     <<  " port = " << m_nmeaPort;
  reconnect();
}


void NmeaDispatcher::readyRead()
{
  DEBUG_LOG(m_logger) << "Reading...";
  // QByteArray ba = socket->readDatagram();

  QByteArray ba;

  while (m_socket->hasPendingDatagrams())
  {

    ba.resize(int(m_socket->pendingDatagramSize()));
    m_socket->readDatagram(ba.data(), ba.size());
    INFO_LOG(m_logger) << ba;
    QByteArray nmeaDataBa = ba; // ba.mid(startNmeaData, endNmeaData);
    std::string nmeaDataStd = nmeaDataBa.toStdString() ;
    QString nmeaData = QString::fromLocal8Bit(nmeaDataStd.c_str());


    DEBUG_LOG(m_logger) << "nmeaDecoder :" << nmeaData;
    //ba = ba.mid(endNmeaData, ba.length());
    m_rxHandler->handleTelegram(nmeaData);

    DEBUG_LOG(m_logger) << "NMEA-Data=" << nmeaData;
    DEBUG_LOG(m_logger) << "NMEA-Data ba=" << ba;
  }
}

QString NmeaDispatcher::getNmeaHost()
{
  return m_settings->settings()->value(QStringLiteral("NME/nmeaHost"), QStringLiteral("localhost")).toString();
}

int NmeaDispatcher::getNmeaPort()
{
  return m_settings->settings()->value(QStringLiteral("NME/nmeaPort"), 10110).toInt();
}

} // namespace NmeaTabPlugin