#include "PrtCnvInjectionSocket.hpp"
#include <CoPrtCnv/CoPrtCnvInjectionHeader.hpp>
#include <CoPrtCnv/CoPrtCnvCentralTelegram.hpp>
#include "PrtCnvInjectionThread.hpp"
#include <QtCore/QByteArray>
#include <QTcpSocket>

namespace PrtCnv
{

PrtCnvInjectionSocket::PrtCnvInjectionSocket()
  : m_Socket(nullptr)
  , m_Server(nullptr)
  , m_logger(getLogger("PrtCnvInjectionSocket"))
{}

PrtCnvInjectionSocket::~PrtCnvInjectionSocket()
{
  delete m_Socket;
}




void PrtCnvInjectionSocket::disconnectClient()
{
  INFO_LOG(m_logger) << "A client has disconnected from the injection-server";
  emit disconnected(this);
}





void PrtCnvInjectionSocket::processInputData()
{
  INFO_LOG(m_logger) << "Injection-server has data received";
  N_CoPrtCnv::CoPrtCnvInjectionHeader injectionHeader;
  qint64 bytesRead = m_Socket->peek((char*)&injectionHeader, sizeof(injectionHeader));
  if (sizeof(injectionHeader) == bytesRead)
  {
    if (injectionHeader.isIdCorrect())
    {
      
      qint64 available = m_Socket->bytesAvailable();
      if (available < (injectionHeader.m_Size+sizeof(injectionHeader)))
      {
        INFO_LOG(m_logger) << "not enough bytes available - waiting for more data: "
                           << "headersize=" << sizeof(injectionHeader) << " id1="
                           << injectionHeader.m_Id1 << " id2=" << injectionHeader.m_Id2
                           << " kind=" << (int)injectionHeader.m_Kind << " size="
                           << injectionHeader.m_Size;
        return; 
      }
      
      m_Socket->read((char*)&injectionHeader, sizeof(injectionHeader));
      if (injectionHeader.isIdCorrect())
      {
        

        
        QByteArray data(injectionHeader.m_Size, Qt::Uninitialized);
        m_Socket->read(data.data(), injectionHeader.m_Size);

        switch (injectionHeader.m_Kind)
        {
        case N_CoPrtCnv::CoPrtCnvInjectionHeader::eCentral:
        case N_CoPrtCnv::CoPrtCnvInjectionHeader::eRadio:
            {
              N_CoPrtCnv::CoPrtCnvCentralTelegram *tele = new N_CoPrtCnv::CoPrtCnvCentralTelegram(data);

              if (N_CoPrtCnv::CoPrtCnvInjectionHeader::eCentral == injectionHeader.m_Kind &&
                  tele->telegramId() != TrainingAreaBase::TetraIcd::TelegramId::DATENVERKEHR_TDS_SRT)
              {
                INFO_LOG(m_logger) << "Got an injection-central-telegram with telId=" << tele->telegramId();
                m_Server->addToCentralList(tele);
              }
              else
              {
                INFO_LOG(m_logger) << "Got an injection-radio-telegram with telId=" << tele->telegramId();
                m_Server->addToRadioList(tele);
              }
            }
            break;

          default:
            ERROR_LOG(m_logger) << "Unknown kind (" << injectionHeader.m_Kind << ") of injection-telegram";
            break;
        }
      }
    }
    else
    {
      ERROR_LOG(m_logger) << "Corrupt injection-telegram received => reconnect";
      m_Socket->disconnectFromHost();
    }
  }
}


void PrtCnvInjectionSocket::setSocket(QTcpSocket* a_socket, PrtCnvInjectionThread* a_server)
{
  m_Socket = a_socket;
  m_Server = a_server;
  connect(this, &PrtCnvInjectionSocket::disconnected, m_Server, &PrtCnvInjectionThread::disconnectClient, Qt::QueuedConnection);
  if (m_Socket)
  {
    connect(m_Socket, &QTcpSocket::readyRead, this, &PrtCnvInjectionSocket::processInputData, Qt::QueuedConnection);
    connect(m_Socket, &QTcpSocket::disconnected, this, &PrtCnvInjectionSocket::disconnectClient, Qt::QueuedConnection);
  }
}

}