#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QFileDialog>
#include <QFile>
#include <cmath>
#include <QIntValidator>
#include <QList>
#include <QSet>
#include <QTimer>



MainWindow::MainWindow(QWidget *parent) :
  QMainWindow(parent),
  ui(new Ui::MainWindow)
{
  ui->setupUi(this);
  init();
}

MainWindow::~MainWindow()
{
  m_files.clear();
  
  
  
  
}

void MainWindow::changeEvent(QEvent *e)
{
  QMainWindow::changeEvent(e);
  switch (e->type())
  {
  case QEvent::LanguageChange:
    ui->retranslateUi(this);
    break;
  default:
    break;
  }
}

void MainWindow::init()
{
  
  connect(ui->pushButtonOrdnerFinden, &QPushButton::clicked, this, &MainWindow::slot_findFolder);
  connect(ui->pushButtonAnalysieren, &QPushButton::clicked, this, &MainWindow::slot_analysieren);
  
  ui->progressBar->setValue(0);
  ui->labelResult->setText(QString());
  QIntValidator intVal;
  intVal.setBottom(0);
  intVal.setTop(100000);
  ui->lineEditISSI->setValidator(&intVal);
}

void MainWindow::slot_findFolder()
{
  
  

  QString name = QFileDialog::getExistingDirectory(this, tr("Choose folder"), QDir::homePath(), QFileDialog::DontResolveSymlinks);
  ui->lineEditOrdner->setText(name);
  ui->labelResult->setText(QString());

}

void MainWindow::slot_analysieren()
{
  ui->labelResult->setText(QString());
  QString ISSI = ui->lineEditISSI->text();
  if (ISSI.isEmpty())
    ISSI = QLatin1String("1");
  m_logfileList.clear();

  
  QDir folder(ui->lineEditOrdner->text());
  m_files = folder.entryList();
  folder.~QDir();
  ui->progressBar->setValue(1);
  const QString paytext = ISSI + QLatin1String("-payload");
  const QString issitext = ISSI + QLatin1String("-1");
  for (int i = 0; i < m_files.count(); i++)
  {
    
    QString name = m_files[i];
    if (name.contains(paytext))
    {
      m_files.removeAt(i);
      i--;
    }
    else
    {
      if (!name.contains(QLatin1String(".dat")))
      {
        m_files.removeAt(i);
        i--;
      }
      else
      {
        if (!name.contains(issitext))
        {
          m_files.removeAt(i);
          i--;
        }
      }
    }
  }

  ui->progressBar->setValue(10);
  if (m_files.count() == 0)
    ui->labelResult->setText(tr("no logfiles found"));
  else
  {
    openLogfile(ui->lineEditOrdner->text(), m_files.count());
    ui->progressBar->setValue(12);
    ui->progressBar->repaint();
    readFiles();
    ui->progressBar->setValue(90);
    ui->progressBar->repaint();
    QString ausgabetext = QLatin1String("\tANALYSIS COMPLETED - ") + QString::number(auswerten()) + QLatin1String(" missing messages");
    ui->labelResult->setText(ausgabetext);
  }
  ui->progressBar->setValue(100);
  ui->progressBar->repaint();
}

void MainWindow::readFiles()
{
  for (int j = 0; j < m_files.count(); j++)
  {
    QString filename = ui->lineEditOrdner->text();
    filename += QLatin1Char('/');
    filename += m_files[j];
    QFile file(filename);
    if (file.open(QIODevice::ReadOnly))
    {
      
      QByteArray ar = file.read(150);
      file.close();
      if (ar.count() > 36)
      {
        QString issi = getISSI(ar);
        QByteArray bytes = ar;

        
        bytes.remove(0, 34);
        bytes.remove(2, 150);
        uint nr = bytes[0] & 255;
        nr *= 256;
        nr += bytes[1] & 255;
        
        
        bytes = ar;
        bytes.remove(0, 30);
        bytes.remove(4, 150);

        const QByteArray test = bytes.toHex();
        qint64 zeit = test.toLongLong(nullptr, 16);
        
        const QDateTime timeStart(QDateTime::fromMSecsSinceEpoch(zeit * 1000));

        writeToLogfile(issi, timeStart, getTimestamp(m_files[j]), m_files[j], nr);
        writeLogZeiten(timeStart, getTimestamp(m_files[j]), issi);

      }
    }
    file.close();
    double val = 70;
    val /= m_files.count();
    val *= (j + 1);
    val += 20;
    ui->progressBar->setValue(int(val));
    
  }

}

void MainWindow::openLogfile(const QString &folder, int count)
{
  m_logfile = folder;
  m_logZeiten = folder;
  m_logfile += QLatin1String("/logfile_analysis.txt");
  QFile file(m_logfile);
  if (file.open(QIODevice::WriteOnly | QIODevice::Text))
  {
    const QString msg = QStringLiteral("There are %1 logfiles evaluated.\nISSI   SENDING TIME        RECIEVING TIME             FILENAME     NO \n").arg(count);
    file.write(msg.toUtf8());
    file.close();
  }
  m_logZeiten += QLatin1String("/transmission_times.csv");
  file.setFileName(m_logZeiten);
  if (file.open(QIODevice::WriteOnly))
  {
    file.write("ISSI;Sending Time ; Receiving Time\n");
    file.close();
  }

}

void MainWindow::writeToLogfile(const QString &issi,
                                const QDateTime &timestamp,
                                const QString &filename,
                                uint lfdNr,
                                const QString &bytes)
{
  QString text = issi;
  text += QLatin1String(": ");
  text += timestamp.toString(QLatin1String("dd.MM.yyyy hh:mm:ss"));
  text += QLatin1String(" - ");
  text += filename;
  text += QLatin1String(" -> ");
  text += bytes;
  text += QLatin1String(" --> ");
  text += QString::number(lfdNr, 10);
  text += QLatin1Char('\n');
  QFile file(m_logfile);
  if (file.open(QIODevice::Append | QIODevice::Text))
  {
    file.write(text.toLatin1());
    file.close();
  }
  LogfileInfo info;
  info.timestamp = timestamp;
  info.issi = issi;
  info.lfdNr = lfdNr;
  m_logfileList.append(info);
}

void MainWindow::writeToLogfile(const QString &issi,
                                const QDateTime &sendeZeit,
                                const QDateTime &timestamp,
                                const QString &filename,
                                uint lfdNr)
{
  QString text = issi;
  text += QLatin1String(": ");
  text += sendeZeit.toString(QLatin1String("hh:mm:ss"));
  text += QLatin1String(" --> ");
  text += timestamp.toString(QLatin1String("dd.MM.yyyy hh:mm:ss"));
  text += QLatin1String(" - ");
  text += filename;
  text += QLatin1String(" --> ");
  text += QString::number(lfdNr, 10);
  text += QLatin1Char('\n');
  QFile file(m_logfile);
  if (file.open(QIODevice::Append | QIODevice::Text))
  {
    file.write(text.toLatin1());
    file.close();
  }
  LogfileInfo info;
  info.timestamp = timestamp;
  info.issi = issi;
  info.lfdNr = lfdNr;
  m_logfileList.append(info);
}

QDateTime MainWindow::getTimestamp(const QString &filename) const
{
  const auto list1 = filename.splitRef(QLatin1Char('-'));
  if (list1.size() < 2)
    return {};
  
  const QStringRef &fn = list1.at(1);
  const auto list2 = fn.split(QLatin1Char('.'));
  auto str = list2.at(0).toString();
  str.remove(10, 10);

  return QDateTime::fromMSecsSinceEpoch(str.toLongLong() * 1000);
}

QString MainWindow::getISSI(QByteArray ar)
{
  
  ar.remove(0, 5);
  ar.remove(4, 200);
  QByteArray issi = ar.toHex();
  
  if (ar.count() == 4)
  {
    if (ar[2] == '\0' && ar[3] == '\0')
    {
      ar.remove(2, 2);
      issi = ar.toHex();
      int hex[4];
      for (int i = 3; i >= 0; i--)
      {
        char c = issi.at(i);
        if (c >= '0' && c <= '9')
          hex[i] = c - '0';
        else if (c >= 'a' && c <= 'f')
          hex[i] = c - 'a' + 10;

      }
      int sum = 0;
      sum += hex[1];
      sum += hex[0] * 16;
      sum += hex[3] * 256;
      sum += hex[2] * 4096;
      issi = QByteArray::number(sum);
    }
  }


  return QString::fromLatin1(issi);
}

int MainWindow::auswerten()
{

  
  QFile f(m_logfile);
  if (!f.open(QIODevice::Append | QIODevice::Text))
    return -1;
  f.write("***************************RESULT************************************\n");
  QSet<QString> issis;
  issis.reserve(100);
  for (int i = 0; i < m_logfileList.count(); i++)
  {
    
    issis += m_logfileList.at(i).issi;
  }
  ui->progressBar->setValue(94);
  ui->progressBar->repaint();
  int fehlcount = 0;
  QVector<uint> numList;
  int i = 0;
  for (const QString &issi : std::as_const(issis))
  {
    
    numList.clear();
    for (int j = 0; j < m_logfileList.count(); j++)
    {
      if (issi == m_logfileList.at(j).issi)
        numList.append(m_logfileList.at(j).lfdNr);
    }
    QByteArray text = issi.toLatin1();
    text += ":\t";
    text += QByteArray::number(numList.count());
    text += " messages transmitted\n";
    text += "\t";
    f.write(text);

    fehlcount += fehlendeNumsEintragen(numList, f);
    

    double val = 5;
    val /= issis.count();
    val *= (i + 1);
    val += 94;
    ui->progressBar->setValue(qRound(val));
    ui->progressBar->repaint();

    ++i;
  }
  return fehlcount;
}

int MainWindow::fehlendeNumsEintragen(const QVector<uint> &numList, QFile &f)
{
  
  QVector<uint> fehlendeNums = getFehlendeNums(numList);
  QByteArray text = QByteArray::number(fehlendeNums.count());
  text += " lost messages\n";
  text += "\t\t following messages are missing (";
  for (int j = 0; j < fehlendeNums.count(); j++)
  {
    text += QByteArray::number(fehlendeNums.at(j));
    text += ", ";
  }
  
  text += ")\n";

  f.write(text);

  return fehlendeNums.count();
}

QVector<uint> MainWindow::getFehlendeNums(const QVector<uint> &numsDurchgang)
{
  
  uint count = numsDurchgang.count();
  uint maxnum = 0;
  uint minnum = 999999;
  for (uint k = 0; k < count; k++)
  {
    
    if (numsDurchgang.at(k) > maxnum)
      maxnum = numsDurchgang.at(k);
    if (numsDurchgang.at(k) < minnum)
      minnum = numsDurchgang.at(k);
  }

  QVector<uint> fehlendeNum;
  for (uint z = minnum; z <= maxnum; z++)
  {
    
    bool vorhanden = false;
    for (uint j = 0; j < count; j++)
    {
      if (numsDurchgang.at(j) == z)
      {
        vorhanden = true;
        break;
      }
    }
    if (!vorhanden)
      fehlendeNum.append(z);
  }
  return fehlendeNum;
}

void MainWindow::writeLogZeiten(const QDateTime &beginn, const QDateTime &end, const QString &issi)
{
  QString msg = issi;
  msg += QLatin1Char(';');
  msg += beginn.toString(QLatin1String("hh:mm:ss"));
  msg += QLatin1Char(';');
  msg += end.toString(QLatin1String("hh:mm:ss"));
  msg += QLatin1Char('\n');
  QFile file(m_logZeiten);
  file.open(QIODevice::Append | QIODevice::Text);
  file.write(msg.toUtf8());
  file.close();

  
}