#include "worker.h"

#include <QtCore/QTimer>
#include <QtNetwork/QTcpSocket>
#include <NGLLogger/NGLLoggerBootstrap.h>
#include <time.h>
#include <random>
#include <iostream>
#include <QStringList>
#include <QJsonDocument>

TTWorker::TTWorker(QTcpSocket *socket, const TTSArgs &ttsArgs)
  : m_socket(socket)
  , m_timer(new QTimer(this))
  , m_counter(0)
  , m_toogle(true)
  , m_ttsArgs(ttsArgs)
  , m_patternList(interpretPattern(ttsArgs.pattern))
  , m_generalPosition(ttsArgs.position)
  , m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("TTWorker"))
{
  qsrand(time(nullptr)); 
}

bool TTWorker::init()
{
  connect(m_socket, &QTcpSocket::disconnected,
          this, &TTWorker::deleteLater);
  connect(m_socket, QOverload<QAbstractSocket::SocketError>::of(&QTcpSocket::error),
          this, &TTWorker::onSocketError);
  connect(m_socket, &QTcpSocket::readyRead,
          this, &TTWorker::onReadyRead);
  connect(m_timer, &QTimer::timeout,
          this, &TTWorker::onSendPlayerPositions);

  if (m_ttsArgs.movs_per_msec < 200)
  {
    ERROR_LOG(m_logger) << "Invalid value for 'movements per milliseconds'! Please choose a number greater than 200 msecs or equal. Program stopped.";
    return false;
  }
  return true;
}

void TTWorker::startExecution()
{
  
  m_timer->start(m_ttsArgs.movs_per_msec);
  NOTICE_LOG(m_logger) << "Start Exe login all Player";
  
  for (unsigned int i = 0; i < m_ttsArgs.cntPlayer; i++)
  {
    int eqId = m_ttsArgs.eqIdStart + i;
    int issi = m_ttsArgs.eqIdStart + i + 2000; 
    QPointF posUTM((m_generalPosition.x() + (i / m_ttsArgs.pprow) * m_ttsArgs.pspacing),
                   (m_generalPosition.y() + (i % m_ttsArgs.pprow) * m_ttsArgs.pspacing)); 
    Player *p = new Player(eqId, issi, m_ttsArgs.minimumDeathTicks, m_ttsArgs.maximumDeathTicks, posUTM);
    m_playerList.append(p);

    sendLogin(p->eqId, p->issi);
  }

  if (m_ttsArgs.deactivationSingleMines)
    QTimer::singleShot(1000, this, &TTWorker::onSendDeaktivierungEinzelminen);

  if (m_ttsArgs.demandOldBraodcastTelegrams)
    QTimer::singleShot(1000, this, &TTWorker::onSendNachforderungBroadcastTelegramm);



 }

QVector<runningPattern> TTWorker::interpretPattern(QString pattern) const
{
  if (pattern.isEmpty())
  {
    ERROR_LOG(m_logger) << "INVALID PATTERN - pattern-size < 1";
    exit(8);
  }

  if (pattern.at(0) == QLatin1Char('%')) 
  {
    pattern.remove(0, 1); 

    QString patternAlias = pattern;

    pattern = m_ttsArgs.settings->value(QLatin1String("pattern/") + patternAlias).toString();

    if (pattern.isEmpty()) 
    {
      ERROR_LOG(m_logger) << "INVALID PATTERN - alias '" << patternAlias << "' is not available in settings file! Program halted.";
      exit(9);
    }
  }

  

  if (pattern.at(pattern.count() - 1) == QLatin1Char('#')) 
    pattern.remove(pattern.count() - 1, 1);

  QVector<runningPattern> newPatternList; 
  runningPattern rp; 
  QStringList strings = pattern.split(QLatin1Char('#')); 
  QStringList stringy; 
  int i; 

  for (i = 0; i < strings.count(); i++)
  {
    stringy = strings.at(i).split(QLatin1Char(',')); 

    if (stringy.count() != 3) 
      break;

    bool ok = true;

    rp.steps = stringy.at(0).toInt(&ok); if (!ok) break; 
    rp.ethering = stringy.at(1).toInt(&ok); if (!ok) break; 
    rp.northering = stringy.at(2).toInt(&ok); if (!ok) break; 

    newPatternList.append(rp); 

    if (i == strings.count() - 1) 
      return newPatternList; 
  }

  ERROR_LOG(m_logger) << "INVALID PATTERN: '" << strings.at(i) << "'. Cannot start without correct pattern!";

  exit(5); 

  return QVector<runningPattern>(); 
}

void TTWorker::sendLogin(uint32_t eqId, uint32_t issi)
{
  N_CoPrtCnv::CoPrtCnvRadioTelegram *tele = new N_CoPrtCnv::CoPrtCnvRadioTelegram(N_CoPrtCnv::CoPrtCnvRadioTelegram::e_LoginRequest, eqId, issi);

  DEBUG_LOG(m_logger) << "SEND LOGIN FOR ISSI=" << issi << ", eqId=" << eqId;
  sendTelegram(tele, issi);
}

void TTWorker::onReadyRead()
{
  N_CoPrtCnv::CoPrtCnvRadioTelegram::PrtCnvRadioGwHeader header;
  qint64 bytesRead = m_socket->peek((char *)&header, sizeof(header));
  if (sizeof(header) != bytesRead)
  {
    DEBUG_LOG(m_logger) << "To few bytes to read from socket";
    return;
  }

  if (N_CoPrtCnv::CoPrtCnvRadioTelegram::MAGIC_NUMBER != header.m_MagicNumber)
  {
    ERROR_LOG(m_logger) << "Disconnect because radio-Telegram does not begin with magic-number A5: I got "
                       << header.m_MagicNumber;
    m_socket->disconnectFromHost();
    return;
  }

  if (!N_CoPrtCnv::CoPrtCnvRadioTelegram::isTelegramLengthOk(header.m_Length))
  {
    WARNING_LOG(m_logger) << "Radio-Telegram length to big: " << header.m_Length
                         << " - but I proceed with this telegram.";
  }

  
  uint16_t dataSize = header.m_Length + sizeof(header);
  if (m_socket->bytesAvailable() < dataSize)
  {
    DEBUG_LOG(m_logger) << "not enough bytes available - waiting for more data";
    return;
  }
  QByteArray buf(dataSize, Qt::Uninitialized);
  
  bytesRead = 0;
  while (bytesRead < dataSize)
  {
    qint64 br = m_socket->read(&buf.data()[bytesRead], dataSize - bytesRead);
    bytesRead += br;
  }
  handleReceivedTelegram(buf);

  if (m_socket->bytesAvailable())
    QTimer::singleShot(0, this, &TTWorker::onReadyRead);
}

void TTWorker::handleReceivedTelegram(const QByteArray &data)
{
  INFO_LOG(m_logger) << data.size();
  
  switch (data.at(4))
  {
  
  case N_CoPrtCnv::CoPrtCnvRadioTelegram::e_RegisterInd:
    handleRegisterInd();
    startExecution();
    break;

  case N_CoPrtCnv::CoPrtCnvRadioTelegram::e_DataIndReq:
    handleDataIndReq(data); 
    
    break;
  default:
    INFO_LOG(m_logger) << "Radio-Telegram with PDU-Type=" << (int)data[4]
                      << " not implemented!";
    break;
  }
}

void TTWorker::sendTelegram(N_CoPrtCnv::CoPrtCnvRadioTelegram *radioTelegram, uint32_t issi)
{
  radioTelegram->setZaehler(m_counter++);
  radioTelegram->setDestISSI(m_ttsArgs.destIssi);
  radioTelegram->setSrcISSI(issi);
  
  m_socket->write(radioTelegram->data());
  m_socket->flush();
  delete radioTelegram;
}

void TTWorker::onSendNachforderungBroadcastTelegramm()
{
  Player *p = m_playerList.at(0);

  if (p->isLogin)
  {
    N_CoPrtCnv::CoPrtCnvRadioTelegram tel(GEF_NACHFORDERUNG_BROADCAST_TELEGRAMME,
                                          10, p->eqId);
    tel.setZaehler(0);
    tel.setBroadcastIndex(0);
    tel.setDestISSI(m_ttsArgs.destIssi);
    tel.setSrcISSI(p->issi);
    tel.setPayload4Byte(0); 
    tel.setPayload1Byte(0); 
    tel.setPayload2Byte(m_ttsArgs.demandOldBraodcastTelegramsCounter);  
    m_socket->write(tel.data());
  }
  else
    QTimer::singleShot(1000, this, &TTWorker::onSendNachforderungBroadcastTelegramm);
}

void TTWorker::onSendDeaktivierungEinzelminen()
{
  if (m_playerList.isEmpty())
  {
    ERROR_LOG(m_logger) << "No player for onSendDeaktivierungEinzelminen...";
    return;
  }
  Player *p = m_playerList.at(0);
  static unsigned int mineId = m_ttsArgs.minimumMineId;

  NOTICE_LOG(m_logger) << "onSendDeaktivierungEinzelminen " << p->isLogin;
  if (p->isLogin)
  {
    TrainingAreaBase::TetraIcd::MineTriggered tele;
    tele.header.equipmentNumber = p->eqId;
    tele.header.timeStamp = time(nullptr) * 1000;
    tele.mineIndex = mineId++;
    tele.mineAreaId = 0;

    sendTelegram(tele, p->issi);
  }

  if (mineId <= m_ttsArgs.maximumMineId)
    QTimer::singleShot(1000, this, &TTWorker::onSendDeaktivierungEinzelminen);
}




















































void TTWorker::sendTaktischerStatus(uint32_t eqId, uint32_t issi, TrainingAreaBase::TetraIcd::VulnerabilityState vbg)
{
  TrainingAreaBase::TetraIcd::StateChange tele;
  tele.header.equipmentNumber = eqId;
  tele.header.timeStamp = time(nullptr) * 1000;

  tele.tasVitality = 90;
  tele.tasVulnerabilityKindId = 459008;
  tele.vulnerabilityBits = 0;

  for (Player *p : std::as_const(m_playerList))
  {
    if (p->eqId == eqId)
    {
      p->vbg = vbg;
      tele.vulnerabilityState = vbg;
      DEBUG_LOG(m_logger) << "Player (" << p->eqId << ") - VBG: " << int(vbg);
      break;
    }
  }

  sendTelegram(tele, issi);
}

void TTWorker::sendSanitationReport(uint32_t eqId, uint32_t issi)
{
  m_toogle = false;
  return; 
  TrainingAreaBase::TetraIcd::SanitaryMaterialStockReport tele;
  tele.header.equipmentNumber = eqId;
  tele.header.timeStamp = time(nullptr) * 1000;
  int matCount = 14;
  tele.sanitaryMaterialCount = matCount;
  std::vector<int> mat;
  mat.reserve(matCount);
  for (int i = 1; i <= matCount; i++)
    mat.emplace_back(i);
  tele.sanitaryMaterialStock = mat;
  sendTelegram(tele, issi);

}
















void TTWorker::sendBITE(uint32_t eqId, uint32_t issi)
{
  TrainingAreaBase::TetraIcd::BiteReport tele;
  tele.header.equipmentNumber = eqId;
  tele.header.timeStamp = time(nullptr) * 1000;
  tele.loginType = TrainingAreaBase::TetraIcd::BiteReport::LoginType::Relogin;
  tele.configError = false;
  sendTelegram(tele, issi);
  sendTaktischerStatus(eqId, issi, TrainingAreaBase::TetraIcd::VulnerabilityState::CombatReady); 
}

void TTWorker::handleDataIndReq(const QByteArray &data)
{
  QScopedPointer<N_CoPrtCnv::CoPrtCnvRadioTelegram> radioTelegram(new N_CoPrtCnv::CoPrtCnvRadioTelegram(data));
  int telID = radioTelegram->getTelID(); 

  switch (telID)
  {
#if 0
  TODO
      case GEF_AUSLOESUNG_DUS_TREFFER: 
  {
    

    DEBUG_LOG(mLogger) << "handleAusloeserDUSTreffer: eqId=" << radioTelegram->getIdentity() <<
                          " issi=" << radioTelegram->getDestISSI();


    XDR_Wrapper_it *wrapper = nullptr;
    if (!N_CoPrtCnv::CoPrtCnvTelegramConverter::convertToCentral(wrapper, radioTelegram.data()))
      if (!wrapper)
        return;
    const ausloesung_dus_treffer_rt &rt_data = static_cast<XDR_AUSLOESUNG_DUS_TREFFER_Wrapper *>(wrapper)->get_rt();

    if (rt_data.bek_wirkung > 90)
      sendTaktischerStatus(radioTelegram->getIdentity(), radioTelegram->getDestISSI(), TOTALAUSFALL); 
    else
      sendTaktischerStatus(radioTelegram->getIdentity(), radioTelegram->getDestISSI(), ANNAEHENDER_TREFFER);
    delete wrapper;
    return;
  }
#endif
  case GEF_TAKTISCHER_STATUS: 
  {
    N_CoPrtCnv::CoPrtCnvCentralTelegram *tele = N_CoPrtCnv::CoPrtCnvTelegramConverter::convertToCentral(radioTelegram.data());
    TrainingAreaBase::TetraIcd::StateChange sc = TrainingAreaBase::TetraIcd::StateChange::fromJson(tele->jsonData());
    delete tele;
    DEBUG_LOG(m_logger) << " Try to Resetnd State " << sc.header.equipmentNumber << " we got state: " << static_cast<int>(sc.vulnerabilityState) << " and this bits here: " << sc.vulnerabilityBits;

    sc.header.timeStamp = time(nullptr) * 1000;
    uint32_t issi = 0;
    for (int i = 0; i < m_playerList.count(); i++) 
    {
      if (radioTelegram->getIdentity() == m_playerList.at(i)->eqId)
      {
        issi = m_playerList.at(i)->issi;
        break;
      }
    }

    ERROR_LOG(m_logger) << " Try to Resetnd S2tate " << sc.header.equipmentNumber << " we got state: " << static_cast<int>(sc.vulnerabilityState) << " and this bits here: " << sc.vulnerabilityBits;
    sendTelegram(sc, issi); 
    return;
  }
  case GEF_SANITAETSDIENST_INSTANDSETZUNG_PVSAN:
  {
    N_CoPrtCnv::CoPrtCnvCentralTelegram *tele = N_CoPrtCnv::CoPrtCnvTelegramConverter::convertToCentral(radioTelegram.data());
    TrainingAreaBase::TetraIcd::Sanitation sc = TrainingAreaBase::TetraIcd::Sanitation::fromJson(tele->jsonData());
    delete tele;

    DEBUG_LOG(m_logger) << " Try to Resetnd State " << sc.header.equipmentNumber << " we got procedure: " << sc.proceduresTaken;

    sc.header.timeStamp = time(nullptr) * 1000;
    uint32_t issi = 0;
    for (int i = 0; i < m_playerList.count(); i++) 
    {
      if (radioTelegram->getIdentity() == m_playerList.at(i)->eqId)
      {
        issi = m_playerList.at(i)->issi;
        break;
      }
    }

    ERROR_LOG(m_logger) << " Try to Resetnd S2tate " << sc.header.equipmentNumber << " we got state: " << sc.proceduresTaken;
    sendTelegram(sc, issi); 
    return;
  }
  case GEF_TREFFER_AUSLOESUNG: 
  case GEF_INIT: 
  {
    TrainingAreaBase::TetraIcd::StateChange tele;
    uint32_t issi = 0;
    for (int i = 0; i < m_playerList.count(); i++) 
    {
      if (radioTelegram->getIdentity() == m_playerList.at(i)->eqId)
      {
        issi = m_playerList.at(i)->issi;
        break;
      }
    }
    TrainingAreaBase::TetraIcd::VulnerabilityState state = (telID == GEF_TREFFER_AUSLOESUNG)
        ? static_cast<TrainingAreaBase::TetraIcd::VulnerabilityState>(radioTelegram->getPayloadDataUInt8(7))
        : TrainingAreaBase::TetraIcd::VulnerabilityState::CombatReady; 

    tele.originatorType = TrainingAreaBase::TetraIcd::OriginatorType::Initialisation;  
    tele.header.equipmentNumber = radioTelegram->getIdentity(); 
    tele.header.timeStamp = time(nullptr) * 1000;
    uint32_t vulcomplete = radioTelegram->getPayloadDataUInt32(8, 2);
    uint32_t vitality = vulcomplete &= 0xF000;
    vitality >>= 12;

    tele.tasVulnerabilityKindId = vulcomplete &= 0x0FFF;
    
    tele.tasVulnerabilityKindId <<= 16;
    tele.tasVulnerabilityKindId |= 0xB1;

    tele.tasVitality = (vitality - 1) * 10;
    if (tele.tasVitality < 0)
      tele.tasVitality = 100;

    if (state == TrainingAreaBase::TetraIcd::VulnerabilityState::CombatReady && vitality > 0)
      tele.vulnerabilityState = TrainingAreaBase::TetraIcd::VulnerabilityState::MediumDamage;
    else
      tele.vulnerabilityState = state;

    sendTelegram(tele, issi); 
    return;
  }
  
  
  
  
  
  
  
  
  

  
  }

  

  if (radioTelegram->isLoginTelegram())
  {
    
    DEBUG_LOG(m_logger) << "player cont: " << m_playerList.count();
    for (int i = 0; i < m_playerList.count(); i++) 
    {
      Player *p = m_playerList.at(i);
      if (radioTelegram->getDestISSI() == p->issi) 
      {
        if (p->isLogin)
          return;
        DEBUG_LOG(m_logger) << "Player #" << i << " with eqId=" << p->eqId << " and issi=" << p->issi << " is now logged in.";
        p->isLogin = true;
        sendBITE(p->eqId, p->issi); 
        return;
      }
    }
    
    ERROR_LOG(m_logger) << "Invalid player was logged in. issi: '" << radioTelegram->getDestISSI() << "'";
    return;
  }

  
  DEBUG_LOG(m_logger) << "Received unused or invalid telegram with Telegram-ID: " << telID;
}

static void fillHeader(char *data, int len)
{
  N_CoPrtCnv::CoPrtCnvRadioTelegram::PrtCnvRadioGwHeader *hdr
      = (N_CoPrtCnv::CoPrtCnvRadioTelegram::PrtCnvRadioGwHeader *)data;
  hdr->m_MagicNumber = N_CoPrtCnv::CoPrtCnvRadioTelegram::MAGIC_NUMBER;
  hdr->m_Counter = 0;
  hdr->m_Length = len;
}

void TTWorker::handleRegisterInd()
{
  m_counter = 1;

  QByteArray buf;
  buf.resize(6);
  fillHeader(buf.data(), 2);
  buf[4] = N_CoPrtCnv::CoPrtCnvRadioTelegram::e_RegisterRsp;
  buf[5] = N_CoPrtCnv::CoPrtCnvRadioTelegram::e_IssiSuccessfulRegistered;

  m_socket->write(buf);

  
}

void TTWorker::movePlayer(Player *p) 
{
  

  if (p->patternInList > m_patternList.count() - 1) 
    p->patternInList = 0; 
  else
  {
    if (p->stepInPattern > m_patternList.at(p->patternInList).steps) 
    {
      p->stepInPattern = 1; 
      if (p->patternInList == m_patternList.count() - 1) 
        p->patternInList = 0;
      else
        p->patternInList++; 
    }
  }

  p->posUTM.setX(p->posUTM.x() +
                 m_patternList.at(p->patternInList).northering); 
  p->posUTM.setY(p->posUTM.y() +
                 m_patternList.at(p->patternInList).ethering); 

  p->stepInPattern++; 
}

void TTWorker::onSendPlayerPositions()
{
  
  qint64 bytesSent = 0;
  int playerCount = 0;
  TrainingAreaBase::TetraIcd::PositionReport tele;
  for (int i = 0; i < m_playerList.count(); i++)
  {
    Player *p = m_playerList.at(i);

    if (!p->isLogin) 
    {
      INFO_LOG(m_logger) << "Player with eqId=" << p->eqId << " and issi=" << p->issi << " is not logged in.";
      break;
    }
    playerCount++;

    
    if (p->vbg != TrainingAreaBase::TetraIcd::VulnerabilityState::CombatReady && p->isEndOfTicks()) 
      sendTaktischerStatus(p->eqId, p->issi, TrainingAreaBase::TetraIcd::VulnerabilityState::CombatReady); 

    tele.header.equipmentNumber = p->eqId;
    if (m_toogle)
      sendSanitationReport(p->eqId, p->issi);
    
    
    movePlayer(p); 
    tele.relPosition.offsetY = p->posUTM.y();
    tele.relPosition.offsetX = p->posUTM.x();

    tele.header.timeStamp = time(nullptr) * 1000;

    N_CoPrtCnv::CoPrtCnvCentralTelegram ct(tele);
    N_CoPrtCnv::CoPrtCnvRadioTelegram *tel = N_CoPrtCnv::CoPrtCnvTelegramConverter::convertToRadio(&ct);
    tel->setZaehler(m_counter++);
    tel->setDestISSI(m_ttsArgs.destIssi);
    tel->setSrcISSI(p->issi);
    m_socket->write(tel->data());
    bytesSent += tel->getPayloadSize();
    delete tel;
  }
  bool bFlushed = m_socket->flush();
  INFO_LOG(m_logger) << "Sent " << bytesSent << "bytes (" << playerCount << " players), bFlushed=" << bFlushed;
}

void TTWorker::onSocketError()
{
  if (m_socket)
    m_socket->disconnectFromHost();
}