/**
  * @RDE_HEADER@
  * UnitTests for ExerciseManagement (EXM)
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Philipp Dassow, SLEA, 2017-05-29
  */

#include "gmp_minefieldInterpreter_test.h"

#include <QCoreApplication>
#include <QDateTime>
#include <QtTest/QTest>

#include <NGLLogger/NGLLoggerBootstrap.h>

Q_DECLARE_METATYPE(wirkfeld_minensperre_rt)
Q_DECLARE_METATYPE(ausstossart_et)
Q_DECLARE_METATYPE(Segment_rt)
typedef QPair<int, int> Coordinate;
Q_DECLARE_METATYPE(Coordinate)

//-------------------------------------------------------------------------------------------------------
int main(int argc, char *argv[])
{
  QCoreApplication app(argc, argv);

  // Init the logger
  NGL::NGLLoggerBootstrap::createNGLRootLogger("log4cxx_gmp_tests.props", true);
  GmpMinefieldInterpreterTestsMain *tc = new GmpMinefieldInterpreterTestsMain;

  int retCode = QTest::qExec(tc, argc, argv);

  delete tc;

  return retCode;
}

//-------------------------------------------------------------------------------------------------------
GmpMinefieldInterpreterTestsMain::GmpMinefieldInterpreterTestsMain()
  : m_minefieldInterpreter(nullptr)
  , m_receivedMinefield()
  , m_receivedVeType(0)
  , m_minefieldInterpreterTimer(nullptr)
  , m_minefieldSpy(nullptr)
  , m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("Tests.GmpMinefieldInterpreterTest"))
{
}

//-------------------------------------------------------------------------------------------------------
void GmpMinefieldInterpreterTestsMain::initTestCase()
{
  DEBUG_LOG(m_logger) << "GmpMinefieldInterpreterTestsMain: initTestCase";

  m_minefieldInterpreter = new GuezMinelayerProcessing::ZSSI_WI_Minenfeld_Interpreter();
  QVERIFY2(m_minefieldInterpreter, "Initialisation of GuezMinelayerProcessing::ZSSI_WI_Minenfeld_Interpreter failed");

  // connect to minefield generator
  connect(m_minefieldInterpreter, &GuezMinelayerProcessing::ZSSI_WI_Minenfeld_Interpreter::sendeWirkfeld, this, &GmpMinefieldInterpreterTestsMain::onSendMinefield);

  // set up signal spy
  qRegisterMetaType<wirkfeld_minensperre_rt>();
  m_minefieldSpy = new QSignalSpy(m_minefieldInterpreter, &GuezMinelayerProcessing::ZSSI_WI_Minenfeld_Interpreter::sendeWirkfeld);

  // start interpreter
  m_minefieldInterpreterTimer = new QTimer();
  connect(m_minefieldInterpreterTimer, &QTimer::timeout, m_minefieldInterpreter, &GuezMinelayerProcessing::ZSSI_WI_Minenfeld_Interpreter::processData);
  m_minefieldInterpreterTimer->start(m_minefieldInterpreter->triggerIntervall * 1000);
}

//-------------------------------------------------------------------------------------------------------
void GmpMinefieldInterpreterTestsMain::minefieldTestCase_data()
{
  // define set of data needed
  QTest::addColumn<QVector<int>>("identities");
  QTest::addColumn<uint32_t>("effectDuration");
  QTest::addColumn<int>("operationalState");
  QTest::addColumn<int>("barrierId");
  QTest::addColumn<unsigned short>("mineType");
  QTest::addColumn<short>("mineCount");
  QTest::addColumn<int>("mineLayingDensity");
  QTest::addColumn<QVector<ausstossart_et>>("throwingTypes");
  QTest::addColumn<QVector <QVector<Coordinate>>>("coordinates"); // (Coordinate == QPair) is interpreted as utm_north, utm_east
  QTest::addColumn<int>("identityResult");
  QTest::addColumn<short>("mineCountResult");
  QTest::addColumn<int>("mineDensityResult");
  QTest::addColumn<uint32_t>("layingDepth");
  QTest::addColumn<QVector<Segment_rt>>("segmentsResult");

  // data set: minefield with mutltiple laying vehicles
  // identities
  QVector <int> identities({4000, 4010, 4020});

  uint32_t effectDuration = 10;
  int operationalState = 98;
  int barrierId = 43;
  unsigned short mineType = 214;
  short mineCount = 12;
  int mineLayingDensity = 1;

  QVector<ausstossart_et> throwingTypes({rechts_und_links, links, rechts});

  // List of coordinates for the lane data
  // QPair is utm_north, utm_east
  QVector<Coordinate> coordinates1, coordinates2, coordinates3;
  coordinates1 << QPair<int, int>(79500, 94200);
  coordinates2 << QPair<int, int>(79540, 94200);
  coordinates3 << QPair<int, int>(79460, 94200);
  coordinates1 << QPair<int, int>(79500, 94220);
  coordinates2 << QPair<int, int>(79540, 94220);
  coordinates3 << QPair<int, int>(79460, 94220);
  coordinates1 << QPair<int, int>(79500, 94240);
  coordinates2 << QPair<int, int>(79540, 94240);
  coordinates3 << QPair<int, int>(79460, 94240);
  coordinates1 << QPair<int, int>(79500, 94260);
  coordinates2 << QPair<int, int>(79540, 94260);
  coordinates3 << QPair<int, int>(79460, 94260);
  QVector <QVector<Coordinate>> coordinates;
  coordinates << coordinates1 << coordinates2 << coordinates3;

  // result data
  int identityResult = 4010;
  short mineCountResult = mineCount * 3;
  int mineDensityResult = 60;
  uint32_t layingDepth = 128;
  QVector<Segment_rt> segmentsResult;
  Segment_rt segment;
  segment.anzahl = mineCountResult;
  segment.drehwinkel = 0;
  segment.startpunkt.utm_nordwert = 79500;
  segment.startpunkt.utm_ostwert = 94200;
  segmentsResult << segment;

  QTest::newRow("minefield from multiple vehicles")
      << identities
      << effectDuration
      << operationalState
      << barrierId
      << mineType
      << mineCount
      << mineLayingDensity
      << throwingTypes
      << coordinates
      << identityResult
      << mineCountResult
      << mineDensityResult
      << layingDepth
      << segmentsResult;

  // clear lists
  identities.clear();
  throwingTypes.clear();
  coordinates1.clear();
  coordinates2.clear();
  coordinates3.clear();
  coordinates.clear();
  segmentsResult.clear();

  // data set: minefield with 1 laying vehicle and 5 segments
  identities << 4000;
  effectDuration = 6;
  operationalState = 98;
  barrierId = 42;
  mineType = 215;
  mineCount = 111;
  mineLayingDensity = 4;

  throwingTypes << mitte;

  //coordinates
  coordinates1 << QPair<int, int>(79100, 94100);
  coordinates1 << QPair<int, int>(79120, 94110);
  coordinates1 << QPair<int, int>(79140, 94120);
  coordinates1 << QPair<int, int>(79140, 94140);
  coordinates1 << QPair<int, int>(79130, 94160);
  coordinates1 << QPair<int, int>(79110, 94170);
  coordinates1 << QPair<int, int>(79090, 94160);
  coordinates1 << QPair<int, int>(79080, 94140);
  coordinates1 << QPair<int, int>(79080, 94120);
  coordinates1 << QPair<int, int>(79070, 94100);
  coordinates1 << QPair<int, int>(79080, 94080);
  coordinates1 << QPair<int, int>(79100, 94070);
  coordinates1 << QPair<int, int>(79120, 94060);
  coordinates1 << QPair<int, int>(79130, 94040);
  coordinates << coordinates1;

  // result data
  identityResult = 4000;
  mineCountResult = mineCount;
  mineDensityResult = 41;
  layingDepth = 12;
  // segment 0
  segment.anzahl = 18;
  segment.drehwinkel = 6343;
  segment.startpunkt.utm_nordwert = 79100;
  segment.startpunkt.utm_ostwert = 94100;
  segmentsResult << segment;
  // segment 1
  segment.anzahl = 17;
  segment.drehwinkel = 34596;
  segment.startpunkt.utm_nordwert = 79140;
  segment.startpunkt.utm_ostwert = 94120;
  segmentsResult << segment;
  // segment 2
  segment.anzahl = 16;
  segment.drehwinkel = 27000;
  segment.startpunkt.utm_nordwert = 79130;
  segment.startpunkt.utm_ostwert = 94160;
  segmentsResult << segment;
  // segment 3
  segment.anzahl = 26;
  segment.drehwinkel = 19843;
  segment.startpunkt.utm_nordwert = 79090;
  segment.startpunkt.utm_ostwert = 94160;
  segmentsResult << segment;
  // segment 4
  segment.anzahl = 34;
  segment.drehwinkel = 13500;
  segment.startpunkt.utm_nordwert = 79070;
  segment.startpunkt.utm_ostwert = 94100;
  segmentsResult << segment;

  QTest::newRow("minefield from 1 vehicle with 5 segments")
      << identities
      << effectDuration
      << operationalState
      << barrierId
      << mineType
      << mineCount
      << mineLayingDensity
      << throwingTypes
      << coordinates
      << identityResult
      << mineCountResult
      << mineDensityResult
      << layingDepth
      << segmentsResult;
}

//-------------------------------------------------------------------------------------------------------
void GmpMinefieldInterpreterTestsMain::minefieldTestCase()
{
  DEBUG_LOG(m_logger) << "GmpMinefieldInterpreterTestsMain: multiLaneMinefieldTestCase";
  NOTICE_LOG(m_logger) << "this may take a while.. don't worry";

  uint64_t timeStamp = QDateTime::currentSecsSinceEpoch();
  uint32_t effectStart = timeStamp + 100;

  QFETCH(int, barrierId);
  QFETCH(unsigned short, mineType);

  // inserting start minelayer data
  VERLEGEDATEN_INTERN verlegedaten_intern;
  VERLEGEDATEN_KEY verlegekey_intern;
  verlegedaten_intern.daten.gps_zeit.gps_zeit = timeStamp;
  verlegedaten_intern.daten.verlegedaten.sperren_id = barrierId;
  verlegedaten_intern.daten.verlegedaten.verlegedichte = 0;
  verlegedaten_intern.daten.verlegedaten.wirkbeginn.gps_zeit = effectStart;
  verlegedaten_intern.daten.verlegedaten.wirkzeit = 0;
  verlegedaten_intern.daten.verlegedaten.minentyp = mineType;
  verlegedaten_intern.daten.verlegedaten.anzahl_verlegter_minen = 0;

  verlegekey_intern.zeitpunkt.gps_zeit = timeStamp;

  QFETCH(QVector<int>, identities);
  QFETCH(QVector<QVector<Coordinate>>, coordinates);
  QFETCH(QVector<ausstossart_et>, throwingTypes);

  for (int i = 0; i < identities.size(); ++i)
  {
    verlegekey_intern.fz_id = identities.at(i);
    verlegedaten_intern.daten.header.identitaet = identities.at(i);
    verlegedaten_intern.daten.gps_position.utm_nordwert = coordinates.at(i).first().first;
    verlegedaten_intern.daten.gps_position.utm_ostwert = coordinates.at(i).first().second;
    verlegedaten_intern.daten.verlegedaten.ausstossart = throwingTypes.at(i);
    interne_datenbasis_Verlegedaten.eintrag_container(
      verlegekey_intern, verlegedaten_intern);
  }

  QFETCH(int, operationalState);

  // inserting lane data timed
  FAHRSPUR_INTERN daten_intern;
  VERLEGEDATEN_KEY key_intern;
  //Interpretationsstatus auf 0 setzen
  daten_intern.intstat = 0;
  daten_intern.daten.ss_betriebszustand = operationalState;


  // for each coordinate
  for (int i = 0; i < coordinates.first().size(); ++i)
  {
    key_intern.zeitpunkt.gps_zeit = timeStamp;
    daten_intern.daten.gps_zeit.gps_zeit = timeStamp;

    // for each identity
    for (int j = 0; j < identities.size(); ++j)
    {
      daten_intern.daten.header.identitaet = identities.at(j);
      daten_intern.daten.gps_position.utm_nordwert = coordinates.at(j).at(i).first;
      daten_intern.daten.gps_position.utm_ostwert = coordinates.at(j).at(i).second;

      key_intern.fz_id = identities.at(j);

      interne_datenbasis_Fahrspur.eintrag_container(
        key_intern, daten_intern);
    }
    NOTICE_LOG(m_logger) << "... waiting for next coordinate input";
    QTest::qWait(5000);
    timeStamp += 5;
  }
  NOTICE_LOG(m_logger) << "finished!";

  QFETCH(short, mineCount);
  QFETCH(uint32_t, effectDuration);
  QFETCH(int, mineLayingDensity);

  // inserting end minelayer data
  timeStamp -= 5;

  verlegedaten_intern.daten.gps_zeit.gps_zeit = timeStamp;
  verlegedaten_intern.daten.verlegedaten.sperren_id = barrierId;
  verlegedaten_intern.daten.verlegedaten.verlegedichte = mineLayingDensity;
  verlegedaten_intern.daten.verlegedaten.wirkbeginn.gps_zeit = effectStart;
  verlegedaten_intern.daten.verlegedaten.wirkzeit = effectDuration;
  verlegedaten_intern.daten.verlegedaten.anzahl_verlegter_minen = mineCount;

  verlegekey_intern.zeitpunkt.gps_zeit = timeStamp;

  for (int i = 0; i < identities.size(); ++i)
  {
    verlegekey_intern.fz_id = identities.at(i);
    verlegedaten_intern.daten.header.identitaet = identities.at(i);
    verlegedaten_intern.daten.gps_position.utm_nordwert = coordinates.at(i).last().first;
    verlegedaten_intern.daten.gps_position.utm_ostwert = coordinates.at(i).last().second;
    verlegedaten_intern.daten.verlegedaten.ausstossart = throwingTypes.at(i);
    interne_datenbasis_Verlegedaten.eintrag_container(
      verlegekey_intern, verlegedaten_intern);
  }

  // the interpreter/generator waits for 240 seconds before processing the data
  NOTICE_LOG(m_logger) << "Now we have to wait for minefield generation timeout (270s) ...";
  QVERIFY2(m_minefieldSpy->wait(270 * 1000), "Generation of minefield timed out");

  QFETCH(int, identityResult);
  QFETCH(short, mineCountResult);
  QFETCH(int, mineDensityResult);
  QFETCH(uint32_t, layingDepth);
  QFETCH(QVector<Segment_rt>, segmentsResult);

  // check for correct minefield data
  QCOMPARE(m_receivedMinefield.header.identitaet, identityResult);
  QCOMPARE(m_receivedMinefield.beschreibung.kennung, barrierId);
  QCOMPARE(m_receivedMinefield.beschreibung.wirkbeginn.gps_zeit, effectStart);
  QCOMPARE(m_receivedMinefield.beschreibung.wirkdauer, effectDuration);
  QCOMPARE(m_receivedMinefield.beschreibung.minentyp, mineType);
  QCOMPARE(m_receivedMinefield.beschreibung.minenanzahl, mineCountResult);
  QCOMPARE(m_receivedMinefield.beschreibung.verlegedichte, mineDensityResult);
  QCOMPARE(m_receivedMinefield.beschreibung.verlegetiefe, layingDepth);
  QCOMPARE(m_receivedMinefield.beschreibung.segmente.size(), static_cast<size_t>(segmentsResult.size()));
  // Segments
  for (size_t i = 0; i < m_receivedMinefield.beschreibung.segmente.size(); ++i)
  {
    QCOMPARE(m_receivedMinefield.beschreibung.segmente.at(i).anzahl, segmentsResult.at(i).anzahl);
    QCOMPARE(m_receivedMinefield.beschreibung.segmente.at(i).drehwinkel, segmentsResult.at(i).drehwinkel);
    QCOMPARE(m_receivedMinefield.beschreibung.segmente.at(i).startpunkt.utm_nordwert, segmentsResult.at(i).startpunkt.utm_nordwert);
    QCOMPARE(m_receivedMinefield.beschreibung.segmente.at(i).startpunkt.utm_ostwert, segmentsResult.at(i).startpunkt.utm_ostwert);
  }
}

//-------------------------------------------------------------------------------------------------------
void GmpMinefieldInterpreterTestsMain::cleanupTestCase()
{
  DEBUG_LOG(m_logger) << "GmpMinefieldInterpreterTestsMain: cleanupTestCase";
  m_minefieldInterpreterTimer->stop();
  m_minefieldInterpreterTimer->deleteLater();

  delete m_minefieldInterpreter;

  delete m_minefieldSpy;
}

//-------------------------------------------------------------------------------------------------------
void GmpMinefieldInterpreterTestsMain::onSendMinefield(const wirkfeld_minensperre_rt &minefield, int veType)
{
  m_receivedMinefield = minefield;
  m_receivedVeType = veType;
}

//-------------------------------------------------------------------------------------------------------