#include "checkmk_handler.h"

#include <QtCore/QTimer>
#include <QtNetwork/QHostAddress>
#include <QtCore/QDateTime>
#include <NGLLogger/NGLLoggerBootstrap.h>





namespace ComponentMonitor
{

CheckmkHandler::CheckmkHandler() : QObject()
  , m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
  , m_socket(new QTcpSocket(this)) {
  TRACE_LOG(m_logger) << Q_FUNC_INFO << " START";
  TRACE_LOG(m_logger) << Q_FUNC_INFO << " END";
}

CheckmkHandler::~CheckmkHandler()
{
  TRACE_LOG(m_logger) << Q_FUNC_INFO << " START";
  if (m_timer)
    m_timer->stop();
  delete m_socket;
  TRACE_LOG(m_logger) << Q_FUNC_INFO << " END";
}

bool CheckmkHandler::initialize(const QString &checkMkServerHostname, int checkMkServerPort,
                                int checkIntervalSec)
{
  DEBUG_LOG(m_logger) << Q_FUNC_INFO << " START"
                       << " , hostname=" << checkMkServerHostname
                       << " , port=" << checkMkServerPort
                       << " , m_checkIntervalSec=" << checkIntervalSec;

  m_checkMkHost       = checkMkServerHostname;
  m_checkMkPort       = checkMkServerPort;
  m_checkIntervalSec  = checkIntervalSec;

  if (!m_timer)
  {
    m_timer = new QTimer(this);
    m_timer->setInterval(m_checkIntervalSec * 1000);
    connect(m_timer, &QTimer::timeout, this, &CheckmkHandler::onTimeout);
  }

  connect(m_socket, &QTcpSocket::stateChanged, this, &CheckmkHandler::onStateChanged);
  connect(m_socket, &QAbstractSocket::errorOccurred,
          this, &CheckmkHandler::onSocketError);

  connect(m_socket, &QTcpSocket::connected,
          this, &CheckmkHandler::onConnected);
  connect(m_socket, &QTcpSocket::readyRead, this, &CheckmkHandler::readData);

  INFO_LOG(m_logger) << Q_FUNC_INFO << " END";
  return true;
}

void CheckmkHandler::run()
{
  INFO_LOG(m_logger) << Q_FUNC_INFO << " START";
  m_timer->start();
  INFO_LOG(m_logger) << Q_FUNC_INFO << " END";
}

void CheckmkHandler::stop()
{
  INFO_LOG(m_logger) << Q_FUNC_INFO << " START";
  m_timer->stop();
  INFO_LOG(m_logger) << Q_FUNC_INFO << " END";
}

void CheckmkHandler::onTimeout()
{
  if (m_highFrequencyCheck>=0)
  {
    --m_highFrequencyCheck;
    m_timer->setInterval(2*1000);
  } else {
    m_timer->setInterval(m_checkIntervalSec*1000);
  }

  INFO_LOG(m_logger) << Q_FUNC_INFO << " Timeout, m_highFrequencyCheck=" << m_highFrequencyCheck
                     << ", current Interval=" << m_timer->interval() << " [msec]";

  if (m_socket->state() == QAbstractSocket::SocketState::ConnectedState)
  {
    writeGetStateRequest();
  } else {
    doConnect();
  }
}

bool CheckmkHandler::doConnect()
{
  INFO_LOG(m_logger) << Q_FUNC_INFO << " START, (int)m_socket->state()=" << (int)m_socket->state();

  
  m_socket->connectToHost(m_checkMkHost, m_checkMkPort);
  if (!m_socket->waitForConnected(5000))
  {
    ERROR_LOG(m_logger) << Q_FUNC_INFO << " Could not (re)open tcp destination " << m_checkMkHost << ":" << m_checkMkPort << ", error: " << m_socket->errorString();
    return false;
  }
  INFO_LOG(m_logger) << Q_FUNC_INFO << " (Re)openend tcp destination " << m_checkMkHost << ":" <<  m_checkMkPort;

  INFO_LOG(m_logger) << Q_FUNC_INFO << " END";
  return true;
}

void CheckmkHandler::onImmediateGetStateRequested()
{
  INFO_LOG(m_logger) << Q_FUNC_INFO << " START";

  
  m_highFrequencyCheck = 3;
  onTimeout();

  INFO_LOG(m_logger) << Q_FUNC_INFO << " END";
}

bool CheckmkHandler::writeGetStateRequest()
{
  if (!m_socket->isOpen())
  {
    ERROR_LOG(m_logger) << Q_FUNC_INFO << " socket not open";
    return false;
  }

  
  
  
  
  
  
  
  



  
  
  
  

  
  


  

  
  
  
  const char* cmdCheck = "GET hosts\nResponseHeader: fixed16\nColumns: name state last_check \nKeepAlive: on\n\n";
  int bWritten = m_socket->write(cmdCheck);
  INFO_LOG(m_logger) << Q_FUNC_INFO << " cmdCheck= '" << cmdCheck << "'";


  INFO_LOG(m_logger) << Q_FUNC_INFO << " bWritten= " << bWritten;
  return true;
}

void CheckmkHandler::readData()
{
  DEBUG_LOG(m_logger) << Q_FUNC_INFO << " XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";

  while (m_socket->canReadLine())
    processLine(m_socket->readLine().trimmed());
}

void CheckmkHandler::onConnected()
{
  writeGetStateRequest();
}

void CheckmkHandler::onStateChanged(const QAbstractSocket::SocketState &newState)
{
  qDebug() << "CheckmkHandler: SocketState changed to: " << newState;
}


void CheckmkHandler::onSocketError(const QAbstractSocket::SocketError &socketError)
{
  qCritical() << "CheckmkHandler: Error occured: " << socketError;
}

bool CheckmkHandler::processLine(const QByteArray &line)
{
  

  if (line.isEmpty())
    return false;

  QString str = QString::fromUtf8(line);
  QStringList sl = str.split(QStringLiteral(";"));

  if (sl.size() < 2)
  {
    if (str.startsWith(QStringLiteral("200")))
      DEBUG_LOG(m_logger) << Q_FUNC_INFO << " size to small " << sl.size()
                         << ", line='" << str << "'";
    else
      WARNING_LOG(m_logger) << Q_FUNC_INFO << " size to small " << sl.size()
                            << ", line='" << str << "'";
    return false;
  }

  QString name = sl.value(0);
  name = name.section(QLatin1Char('.'), 0, 0);  









  
  
  
  QString stateStr = sl.value(1);
  int stateInt = stateStr.toInt();
  bool reachable = stateInt == 0;

  long long lastCheck = 0;

  if (sl.size() >= 3)
  {
    QString lastCheckStr = sl.value(2);
    lastCheck = lastCheckStr.toLongLong();
  }

  DEBUG_LOG(m_logger) << Q_FUNC_INFO
                     << " name: '" << name << "'"
                     << ", stateInt: '" << stateInt << "'"
                     << ", reachable: '" << reachable << "'"
                     << ", lastCheck: '" << lastCheck << "'"
                     ;

  emit newState(name, reachable, lastCheck);
  return true;
}

}