/**
  * Evl Function Topic test executable
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by hjl, SLSE, 2016-04-18
  */
#include "evl_tests.h"

#include <nglapplication/nglcoreapplication.h>
#include <LtsCommandLineParser/LtsCommandLineParser.h>
#include <QtCore/QTimer>
#include <QtCore/QDateTime>
#include <QtCore/QString>
#include <QtCore/QVector>

#include <QtCore/QJsonObject>
#include <QtCore/QJsonDocument>
#include <QtTest/QTest>

#include <Evaluations/evl_ftc.h>
#include <Evaluations/evl_dtc.h>

#include "Evaluations/san_category_line_json.h"

using namespace Evaluations;

//-----------------------------------------------------------------------------
EvlTests::EvlTests(QObject *parent)
  : QObject(parent)
{
  qRegisterMetaType<Core::FunctionReply>("Core::FunctionReply");

  //  connect(m_dtc.get(), &Interface::Dtc::evaluationCriteriumChanged,
  //          this,        &EvlTests::onReceiveCriteriumChanged, Qt::UniqueConnection);

} // end of ctor()


//-----------------------------------------------------------------------------
bool EvlTests::init(int domainId, int exerciseId, int testId, int operatorId, int criteriumId, int elementId, int sanNineLinerId)
{
  INFO_LOG(m_logger) << "EvlTests::init() "
                     << " domainId:" << domainId
                     << " exerciseId:" << exerciseId
                     << " testId: " << testId
                     << " criteriumId: " << criteriumId
                     << " sanNineLinerId: " << sanNineLinerId;

  m_testId = testId;
  m_exerciseId = exerciseId;
  m_criteriumId = criteriumId;
  m_elementId = elementId;
  m_operatorId = operatorId;
  m_sanNineLinerId = sanNineLinerId;

  DEBUG_LOG(m_logger) << "Operator Id = " << m_operatorId;

  // initialize DDS
  m_ddsConnector.reset(new DDSConnector::DdsConnector(domainId, IDL::PartitionType::Exercise, exerciseId));
  if (!m_ddsConnector->init())
    return false;
  m_ddsConnector->initPublisherSubscriber();

  // Access to FTC
  DEBUG_LOG(m_logger) << "create ftc";
  m_ftc = Evaluations::Interface::Ftc::create(m_ddsConnector);
  DEBUG_LOG(m_logger) << "init ftc";
  bool bRet = m_ftc->enableAll();
  DEBUG_LOG(m_logger) << "init end - bRet = " << bRet;

  // Access to DTC
  DEBUG_LOG(m_logger) << "create dtc";
  m_dtc = Evaluations::Interface::Dtc::create(m_ddsConnector);
  DEBUG_LOG(m_logger) << "init dtc";
  bRet = m_dtc->enableAll();
  DEBUG_LOG(m_logger) << "init end - bRet = " << bRet;

  return bRet;
} // end of init()

//-----------------------------------------------------------------------------
void EvlTests::startTest()
{
  INFO_LOG(m_logger) << "startTest() ******* "
                     << " exerciseId: " << m_exerciseId
                     << " testId: " << m_testId
                     << " criteriumId: " << m_criteriumId
                     << " operatorId: " << m_operatorId;

  if (m_testId <= 1)
    QTimer::singleShot(0, this, &EvlTests::tryCreateCriterium);
  else if (m_testId == 2)
    QTimer::singleShot(0, this, &EvlTests::tryModifyCriterium);
  else if (m_testId == 3)
    QTimer::singleShot(0, this, &EvlTests::tryRemoveCriterium);
  else if (m_testId == 4)
    QTimer::singleShot(0, this, &EvlTests::tryCreateElement);
  else if (m_testId == 5)
    QTimer::singleShot(0, this, &EvlTests::tryModifyElement);
  else if (m_testId == 6)
    QTimer::singleShot(0, this, &EvlTests::tryRemoveElement);

  else if (m_testId == 7)
    QTimer::singleShot(0, this, &EvlTests::tryCreateSanNineLiner);
  else if (m_testId == 8)
    QTimer::singleShot(0, this, &EvlTests::tryModifySanNineLiner);
  else if (m_testId == 9)
    QTimer::singleShot(0, this, &EvlTests::tryRemoveSanNineLiner);


  else if (m_testId == 10)
    QTimer::singleShot(0, this, &EvlTests::tryGetAllCriteria);
  else if (m_testId == 11)
    QTimer::singleShot(0, this, &EvlTests::tryGetCriterium);
  else if (m_testId == 12)
    QTimer::singleShot(0, this, &EvlTests::tryGetSanNineLiner);
  else
  {
    ERROR_LOG(m_logger) << "Unknown test case !";
    failExit();
  }
  INFO_LOG(m_logger) << "endTest   ******* ";
  QTimer::singleShot(0, qApp, QCoreApplication::quit);

} // end of startTest()

//-----------------------------------------------------------------------------
void EvlTests::tryCreateCriterium()
{
  m_eTestStep = eCreateCriterium;
  EvlCriteriumModifyRequest data;

  data.id(0);  // id = 0 -> Create request
  data.name("Test Criterium");
  data.description("Test description");
  data.operatorId(m_operatorId);

  INFO_LOG(m_logger) << "trying to send EvlCriteriumModifyRequest";
  if (!m_ftc->evlCriteriumModifyRequest(data, this))
  {
    ERROR_LOG(m_logger) << "Error requesting create data";
    failExit();
  }
  QTest::qWait(1000);
} // end of tryCreateCriterium()

//-----------------------------------------------------------------------------
void EvlTests::tryModifyCriterium()
{
  m_eTestStep = eModifyCriterium;
  EvlCriteriumModifyRequest data;

  data.id(m_criteriumId);
  data.name("Name criterium modified");
  data.description("Description modified");
  data.operatorId(m_operatorId);

  INFO_LOG(m_logger) << "trying to send EvlCriteriumModifyRequest for criteriumId:" << data.id();
  if (!m_ftc->evlCriteriumModifyRequest(data, this))
  {
    ERROR_LOG(m_logger) << "Error requesting modify data for criteriumId:" << data.id();
    failExit();
  }
  QTest::qWait(1000);
} // end of tryModifyCriterium()

//-----------------------------------------------------------------------------
void EvlTests::tryRemoveCriterium()
{
  m_eTestStep = eRemoveCriterium;
  EvlCriteriumRemoveRequest data;

  data.id(m_criteriumId);

  INFO_LOG(m_logger) << "trying to send remove request for criteriumId:" << data.id();
  if (!m_ftc->evlCriteriumRemoveRequest(data, this))
  {
    ERROR_LOG(m_logger) << "Error requesting remove data for criteriumId:" << data.id();
    failExit();
  }
  QTest::qWait(1000);
} // end of tryRemoveCriterum()

//-----------------------------------------------------------------------------
void EvlTests::tryGetAllCriteria()
{
  m_eTestStep = eGetAllCriteria;
  DEBUG_LOG(m_logger) << "trying to get all criteria";

  m_dtc->waitForHistoricalDataEvaluationCriterium(5000);
  m_criteriumId = -1;
  auto cb = [this] (const Evaluations::EvaluationCriterium &c)
  {
    m_criteriumId = c.id();
    INFO_LOG(m_logger) << "Evl("         << c.id() << ") :"
                       << " name:"       << c.name()
                       << " desc:"       << c.description()
                       << " operatorId:" << c.operatorId();
  };
  m_dtc->evaluationCriteriums(cb);
  if (m_criteriumId == -1)
  {
    ERROR_LOG(m_logger) << "Error requesting all criterium data";
    failExit();
  }
  QTimer::singleShot(0, qApp, &QCoreApplication::quit);
} // end of tryGetAllCriteria()

//-----------------------------------------------------------------------------
void EvlTests::tryGetCriterium()
{
  DEBUG_LOG(m_logger) << "trying to get criterium with id:" << m_criteriumId;

  if(m_testId > 1)
  {
    m_eTestStep = eGetCriterium;
  }

  if (m_criteriumId <= 0)
  {
    ERROR_LOG(m_logger) << "invalid criteriumId - test aborted.";
    failExit();
  }

  m_dtc->waitForHistoricalDataEvaluationCriterium(5000);
  Evaluations::EvaluationCriterium data = m_dtc->evaluationCriterium(m_criteriumId);

  if (data.id() <= 0)
  {
    ERROR_LOG(m_logger) << "Error receiving data for criteriumId " << m_criteriumId << " returnVal: " << data.id();
    failExit();
  }
  else
  {
    INFO_LOG(m_logger) << "Evl(" << data.id() << ") :"
                       << " name:"            << data.name()
                       << " desc:"            << data.description()
                       << " operatorId:"      << data.operatorId();
  }

  if (m_testId == 0)
  {
    if (!onCompareCreatedData(data))
    {
      ERROR_LOG(m_logger) << "Compare created data failed!";
      failExit();
    }
    else
    {
      QTimer::singleShot(0, this, &EvlTests::tryModifyCriterium);
      return;
    }
  }
  else
    QTimer::singleShot(0, qApp, QCoreApplication::quit);

} // end of tryGetCriterium()

//-----------------------------------------------------------------------------
void EvlTests::tryCreateElement()
{
  m_eTestStep = eCreateElement;
  EvlElementModifyRequest data;

  data.id(0);
  data.criteriumId(m_criteriumId);
  data.timestamp(QDateTime::currentMSecsSinceEpoch());
  data.note("Test test test");
  data.phaseId(1);
  data.rating(10);

  QJsonObject obj;
  obj[QStringLiteral("actualStream")] = QJsonValue(QStringLiteral("av_0011"));
  obj[QStringLiteral("allStreams")] = QJsonValue(QStringLiteral("av_0011, av_0012, av_0013"));
  data.videoContent().set(QJsonDocument(obj).toJson().constData());

  obj[QStringLiteral("actualStream")] = QJsonValue(QStringLiteral("vhf01"));
  obj[QStringLiteral("allStreams")] = QJsonValue(QStringLiteral("vhf01, hf01, hf02, vhf03"));
  data.audioContent().set(QJsonDocument(obj).toJson().constData());

  INFO_LOG(m_logger) << "trying to send evlElementModifyRequest";
  if (!m_ftc->evlElementModifyRequest(data, this))
  {
    ERROR_LOG(m_logger) << "Error requesting create data";
    failExit();
  }
  QTest::qWait(1000);
} // end of tryCreateElement()

//-----------------------------------------------------------------------------
void EvlTests::tryModifyElement()
{
  m_eTestStep = eModifyElement;
  EvlElementModifyRequest data;

  data.id(m_elementId);
  data.criteriumId(m_criteriumId);
  data.timestamp(QDateTime::currentMSecsSinceEpoch());
  data.note("Test1 test2 test3");
  data.phaseId(2);
  data.rating(5);

  QJsonObject obj;
  obj[QStringLiteral("actualStream")] = QJsonValue(QStringLiteral("av_0013"));
  obj[QStringLiteral("allStreams")] = QJsonValue(QStringLiteral("av_0011, av_0012, av_0013"));
  data.videoContent().set(QJsonDocument(obj).toJson().constData());

  obj[QStringLiteral("actualStream")] = QJsonValue(QStringLiteral("hf01"));
  obj[QStringLiteral("allStreams")] = QJsonValue(QStringLiteral("vhf01, hf01, hf02, vhf03"));
  data.audioContent().set(QJsonDocument(obj).toJson().constData());

  INFO_LOG(m_logger) << "trying to send evlElementModifyRequest for elementId:" << data.id();
  if (!m_ftc->evlElementModifyRequest(data, this))
  {
    ERROR_LOG(m_logger) << "Error requesting modify data for snapshotId:" << data.id();
    failExit();
  }
  QTest::qWait(1000);
} // end of tryModifyElement()

//-----------------------------------------------------------------------------
void EvlTests::tryRemoveElement()
{
  m_eTestStep = eRemoveElement;
  EvlElementRemoveRequest data;

  data.id(m_elementId);
  data.criteriumId(m_criteriumId);

  INFO_LOG(m_logger) << "trying to send remove request for elementId:" << data.id();
  if (!m_ftc->evlElementRemoveRequest(data, this))
  {
    ERROR_LOG(m_logger) << "Error requesting remove data for elementId:" << data.id();
    failExit();
  }
  QTest::qWait(1000);
} // end of tryRemoveElement()

//-----------------------------------------------------------------------------
void EvlTests::tryCreateSanNineLiner()
{
  m_eTestStep = eCreateSanNineLiner;
  SanNineLinerModifyRequest data;

  data.id(0);
  data.lastModified(QDateTime::currentMSecsSinceEpoch());
  data.line1_position(Core::GeoPosition2D(0.100000, 0.2450000));
  data.line2_radioFrequencyCallSignSuffix("32.00 FM, Troublemaker");

  Database::SanCategoryLine cl;
  std::vector<Database::SanCategoryLine> vecCl;

  cl.line = 3;
  cl.amount = 1;
  cl.category = QStringLiteral("A");
  vecCl.push_back(std::move(cl));

  cl.amount = 2;
  cl.category = QStringLiteral("B");
  vecCl.push_back(std::move(cl));

  cl.amount = 1;
  cl.category = QStringLiteral("D");
  vecCl.push_back(std::move(cl));

  cl.line = 4;
  cl.amount = 2;
  cl.category = QStringLiteral("D");
  vecCl.push_back(std::move(cl));

  cl.line = 5;
  cl.amount = 2;
  cl.category = QStringLiteral("A");
  vecCl.push_back(std::move(cl));

  cl.amount = 3;
  cl.category = QStringLiteral("B");
  vecCl.push_back(std::move(cl));

  cl.line = 6;
  cl.category = QStringLiteral("D");
  vecCl.push_back(std::move(cl));

  cl.line = 7;
  cl.category = QStringLiteral("C");
  vecCl.push_back(std::move(cl));

  cl.line = 8;
  cl.amount = 2;
  cl.category = QStringLiteral("A");
  vecCl.push_back(std::move(cl));

  cl.amount = 3;
  cl.category = QStringLiteral("C");
  vecCl.push_back(std::move(cl));

  cl.line = 9;
  cl.category = QStringLiteral("None");
  vecCl.push_back(std::move(cl));

  QJsonDocument doc = SanCategoryLine::toJson(vecCl);
  data.lines(doc.toJson().toStdString());

  INFO_LOG(m_logger) << "lines: " << data.lines();

  INFO_LOG(m_logger) << "trying to send sanNineLinerRequest";
  if (!m_ftc->sanNineLinerModifyRequest(data, this))
  {
    ERROR_LOG(m_logger) << "Error requesting create data";
    failExit();
  }
  QTest::qWait(1000);
} // end of tryCreateElement()

//-----------------------------------------------------------------------------
void EvlTests::tryModifySanNineLiner()
{
  m_eTestStep = eModifySanNineLiner;
  SanNineLinerModifyRequest data;

  data.id(m_sanNineLinerId);
  data.lastModified(QDateTime::currentMSecsSinceEpoch());
  data.line1_position(Core::GeoPosition2D(0.200000, 0.4560000));
  data.line2_radioFrequencyCallSignSuffix("39.000 FM, Troublemaker");

  Database::SanCategoryLine cl;
  std::vector<Database::SanCategoryLine> vecCl;

  cl.line = 3;
  cl.amount = 2;
  cl.category = QStringLiteral("A");
  vecCl.push_back(std::move(cl));

  cl.amount = 1;
  cl.category = QStringLiteral("B");
  vecCl.push_back(std::move(cl));


  cl.line = 4;
  cl.amount = 1;
  cl.category = QStringLiteral("A");
  vecCl.push_back(std::move(cl));

  cl.line = 5;
  cl.amount = 1;
  cl.category = QStringLiteral("A");
  vecCl.push_back(std::move(cl));

  cl.amount = 1;
  cl.category = QStringLiteral("B");
  vecCl.push_back(std::move(cl));

  cl.line = 6;
  cl.amount = 0;
  cl.category = QStringLiteral("D");
  vecCl.push_back(std::move(cl));

  cl.line = 7;
  cl.category = QStringLiteral("C");
  vecCl.push_back(std::move(cl));

  cl.line = 8;
  cl.amount = 1;
  cl.category = QStringLiteral("A");
  vecCl.push_back(std::move(cl));

  cl.amount = 1;
  cl.category = QStringLiteral("C");
  vecCl.push_back(std::move(cl));

  cl.line = 9;
  cl.amount = 0;
  cl.category = QStringLiteral("None");
  vecCl.push_back(std::move(cl));

  QJsonDocument doc = SanCategoryLine::toJson(vecCl);
  data.lines(doc.toJson().toStdString());

  INFO_LOG(m_logger) << "lines: " << data.lines();

  INFO_LOG(m_logger) << "trying to send sanNineLinerRequest";
  if (!m_ftc->sanNineLinerModifyRequest(data, this))
  {
    ERROR_LOG(m_logger) << "Error requesting modify data";
    failExit();
  }
  QTest::qWait(1000);
} // end of tryModifySanNineLiner()

//-----------------------------------------------------------------------------
void EvlTests::tryRemoveSanNineLiner()
{
  m_eTestStep = eRemoveSanNineLiner;
  EvlCriteriumRemoveRequest data;

  data.id(m_sanNineLinerId);

  INFO_LOG(m_logger) << "trying to send remove request for sanNineLinerId:" << data.id();
  if (!m_ftc->sanNineLinerRemoveRequest(data, this))
  {
    ERROR_LOG(m_logger) << "Error requesting remove data for sanNineLinerId:" << data.id();
    failExit();
  }
  QTest::qWait(1000);
} // end of tryRemoveSanNineLiner()

//-----------------------------------------------------------------------------
void EvlTests::tryGetSanNineLiner()
{
  DEBUG_LOG(m_logger) << "trying to get sanNineLinerId with id:" << m_sanNineLinerId;

  if(m_testId > 1)
  {
    m_eTestStep = eGetSanNineLiner;
  }

  if (m_sanNineLinerId <= 0)
  {
    ERROR_LOG(m_logger) << "invalid sanNineLinerId - test aborted.";
    failExit();
  }

  m_dtc->waitForHistoricalDataSanNineLiner(5000);
  Evaluations::SanNineLiner data = m_dtc->sanNineLiner(m_sanNineLinerId);

  if (data.id() <= 0)
  {
    ERROR_LOG(m_logger) << "Error receiving data for sanNineLiner " << m_sanNineLinerId << " returnVal: " << data.id();
    failExit();
  }
  else
  {
    INFO_LOG(m_logger) << "SanNineLiner(" << data.id() << ") :"
                       << " lastModified: " << data.lastModified()
                       << " position lat: " << data.line1_position().lat()
                       << " position lon: " << data.line1_position().lon()
                       << " radiofreq, CallSign: " << data.line2_RadioFrequencyCallSignSuffix()
                       << " lines: " << data.lines();

  }

  if (m_testId == 0)
  {
    if (!onCompareCreatedData(data))
    {
      ERROR_LOG(m_logger) << "Compare created data failed!";
      failExit();
    }
    else
    {
      QTimer::singleShot(0, this, &EvlTests::tryModifySanNineLiner);
      return;
    }
  }
  else
    QTimer::singleShot(0, qApp, QCoreApplication::quit);

} // end of tryGetSanNineLiner()


//-----------------------------------------------------------------------------
void EvlTests::onEvlCriteriumModifyReply(const Core::FunctionReplyObject &replyObject)
{
  INFO_LOG(m_logger) << "Got onEvlCriteriumModifyReply with id " << replyObject.id()
                     << " and errorString " << replyObject.translated();

  m_criteriumId = replyObject.id();

  if (replyObject.error())
  {
    ERROR_LOG(m_logger) << "Error requesting create data";
    failExit();
    return;
  }
  else
  {
    DEBUG_LOG(m_logger) << "Requesting create data ok. Got new id:" << replyObject.id() << " ... ok.";
  }

  QTimer::singleShot(0, this, &EvlTests::tryGetCriterium);
} // end of onEvlCriteriumModifyReply()


//-----------------------------------------------------------------------------
void EvlTests::onEvlCriteriumRemoveReply(const Core::FunctionReplyObject &replyObject)
{
  INFO_LOG(m_logger) << "Got removeReply with id " << replyObject.id()
                     << " and errorString " << replyObject.translated();

  if (replyObject.error())
  {
    ERROR_LOG(m_logger) << "Error requesting remove data for criteriumId:" << replyObject.id();
    failExit();
    return;
  }
  else
  {
    DEBUG_LOG(m_logger) << "Requesting remove data for criteriumd:" << replyObject.id() << " ... ok.";
  }

  QTimer::singleShot(0, qApp, QCoreApplication::quit);

} // end of onEvlCriteriumRemoveReply()

//-----------------------------------------------------------------------------
void EvlTests::onEvlElementModifyReply(const Core::FunctionReplyObject &replyObject)
{
  INFO_LOG(m_logger) << "Got modifyReply with id " << replyObject.id()
                     << " and errorString " << replyObject.translated();

  m_elementId = replyObject.id();

  if (replyObject.error())
  {
    ERROR_LOG(m_logger) << "Error requesting modify data";
    failExit();
    return;
  }
  else
  {
    DEBUG_LOG(m_logger) << "Requesting modify data ok. Got id:" << replyObject.id() << " ... ok.";
  }

  QTimer::singleShot(0, qApp, &QCoreApplication::quit);

} // end of onEvlElementModifyReply()


//-----------------------------------------------------------------------------
void EvlTests::onEvlElementRemoveReply(const Core::FunctionReplyObject &replyObject)
{
  INFO_LOG(m_logger) << "Got removeReply with id " << replyObject.id()
                     << " and errorString " << replyObject.translated();

  if (replyObject.error())
  {
    ERROR_LOG(m_logger) << "Error requesting remove data for elementId:" << replyObject.id();
    failExit();
    return;
  }
  else
  {
    DEBUG_LOG(m_logger) << "Requesting remove data for elementId:" << replyObject.id() << " ... ok.";
  }

  QTimer::singleShot(0, qApp, &QCoreApplication::quit);

} // end of onEvlElementRemoveReplyF()

//-----------------------------------------------------------------------------
void EvlTests::onSanNineLinerModifyReply(const Core::FunctionReplyObject &replyObject)
{
  INFO_LOG(m_logger) << "Got onSanNineLinerModifyReply with id " << replyObject.id()
                     << " and errorString " << replyObject.translated();

  m_sanNineLinerId = replyObject.id();

  if (replyObject.error())
  {
    ERROR_LOG(m_logger) << "Error requesting create data";
    failExit();
    return;
  }
  else
  {
    DEBUG_LOG(m_logger) << "Requesting create data ok. Got new id:" << replyObject.id() << " ... ok.";
  }

  QTimer::singleShot(0, this, &EvlTests::tryGetSanNineLiner);
} // end of onSanNineLinerModifyReply()

//-----------------------------------------------------------------------------
void EvlTests::onSanNineLinerRemoveReply(const Core::FunctionReplyObject &replyObject)
{
  INFO_LOG(m_logger) << "Got removeReply with id " << replyObject.id()
                     << " and errorString " << replyObject.translated();

  if (replyObject.error())
  {
    ERROR_LOG(m_logger) << "Error requesting remove data for sanNineLinerId:" << replyObject.id();
    failExit();
    return;
  }
  else
  {
    DEBUG_LOG(m_logger) << "Requesting remove data for sanNineLinerId:" << replyObject.id() << " ... ok.";
  }

  QTimer::singleShot(0, qApp, &QCoreApplication::quit);

} // end of onEvlElemonEvlElementRemoveReply()


//-----------------------------------------------------------------------------
void EvlTests::onReceiveCriteriumChanged(const EvaluationCriterium &data, DataModification modType)
{
  INFO_LOG(m_logger) << "onReceiveCriteriumChanged()  criteriumId:" << data.id()
                     << " modificationType: = " << (int)modType<< " received";

  switch (modType)
  {
  case DataModification::eAdded:
    INFO_LOG(m_logger) << "*** Criterium added received. criteriumId:" << data.id();
    break;

  case DataModification::eModified:
    INFO_LOG(m_logger) << "*** Criterium modified received. criteriumId:" << data.id();
    break;

  case DataModification::eRemoved:
    INFO_LOG(m_logger) << "*** Criterium removed received. criteriumId:" << data.id();
    break;
  }

} // end of onReceiveCriteriumChanged()


//-----------------------------------------------------------------------------
void EvlTests::getCriteriumModifyRequestData(EvlCriteriumModifyRequest &data)
{  
  data.name("Name criterium modified");
  data.description("Description modified");
  data.operatorId(m_operatorId);

} // end of getCriteriumModifyRequestData()


//-----------------------------------------------------------------------------
void EvlTests::getSanNineLinerModifyRequestData(SanNineLinerModifyRequest &data)
{
  data.line1_position(Core::GeoPosition2D(0.200000, 0.4560000));
  data.line2_radioFrequencyCallSignSuffix("39.000 FM, Troublemaker");
} // end of getNineLinerModifyRequestData()

//-----------------------------------------------------------------------------
bool EvlTests::onCompareCreatedData(EvaluationCriterium &data)
{
  DEBUG_LOG(m_logger) << "start onCompareCreatedData() for id :" << data.id();

  // Vergleicht die zurueckgelesen Datan mit den statischen create Daten

  EvlCriteriumModifyRequest createData;

  getCriteriumModifyRequestData(createData);

  if (createData.name() != data.name())
    return false;

  if (createData.operatorId() != data.operatorId())
    return false;

  if (createData.description() != data.description())
    return false;


  DEBUG_LOG(m_logger) << "successfully finished onCompareCreatedData() for id :" << data.id();

  return true;
} // end of onCompareCreatedData()

//-----------------------------------------------------------------------------
bool EvlTests::onCompareCreatedData(SanNineLiner &data)
{
  DEBUG_LOG(m_logger) << "start onCompareCreatedData() for id :" << data.id();

  SanNineLinerModifyRequest createData;

  getSanNineLinerModifyRequestData(createData);

  if (createData.line1_position() != data.line1_position())
    return false;

  if (createData.line2_radioFrequencyCallSignSuffix() != data.line2_RadioFrequencyCallSignSuffix())
    return false;

  DEBUG_LOG(m_logger) << "successfully finished onCompareCreatedData() for id :" << data.id();

  return true;
} // end of onCompareCreatedData()


//-----------------------------------------------------------------------------
void EvlTests::failExit()
{
  m_bTestsSuccessful = false;
  QTimer::singleShot(0, qApp, &QCoreApplication::quit);
}

//-----------------------------------------------------------------------------
class CmdLineParser : public LtsCommandLineParser::LtsCommandLineParser
{
public:
  CmdLineParser()
    : LtsCommandLineParser()
  {
    addOption( { QStringList() << QLatin1String("t") << QLatin1String("testId")
                 , QLatin1String("TestId.")
                 , QLatin1String("Default: 0 (all FTC/DTC tests), 1 create, 2 modify, 3 remove, 10 getAllCriteria, 11 getCriterium")
                 , QLatin1String("0")
               } );

    addOption( { QStringList() << QLatin1String("o") << QLatin1String("operatorId")
                 , QLatin1String("OperatorId.")
                 , QLatin1String("Used in tests 1, 2.")
                 , QLatin1String("0")
               } );

    addOption( { QStringList() << QLatin1String("c") << QLatin1String("criteriumId")
                 , QLatin1String("CriteriumId.")
                 , QLatin1String("Used for tests 2, 3, 4, 5, 6 & 11 only to select the criterium")
                 , QLatin1String("0")
               } );

    addOption( { QStringList() << QLatin1String("l") << QLatin1String("elementId")
                 , QLatin1String("ElementId.")
                 , QLatin1String("Used for tests 4, 5 & 6 only to select the elementId")
                 , QLatin1String("0")
               } );
    addOption( { QStringList() << QLatin1String("s") << QLatin1String("sanNineLinerId")
                 , QLatin1String("SanNineLinerId.")
                 , QLatin1String("Used for tests 7, 8 & 9 only to select the sanNineLinerId")
                 , QLatin1String("0")
               } );
  }

  int testId() const   { return isSet(QLatin1String("t")) ? value(QLatin1String("t")).toInt() : -1; }
  int operatorId() const   { return isSet(QLatin1String("o")) ? value(QLatin1String("o")).toInt() : -1; }
  int criteriumId() const { return isSet(QLatin1String("c")) ? value(QLatin1String("c")).toInt() : -1; }
  int elementId() const { return isSet(QLatin1String("l")) ? value(QLatin1String("l")).toInt() : -1; }
  int sanNineLinerId() const { return isSet(QLatin1String("s")) ? value(QLatin1String("s")).toInt() : -1; }
};

//-----------------------------------------------------------------------------
int main(int argc, char **argv)
{
  NGLCoreApplication app(argc, argv);

  int iRet = -1;
  CmdLineParser   options;
  if (!options.init())
    return iRet;

  app.createLogger("EVL", options.exerciseId());

  std::unique_ptr<Evaluations::EvlTests> EvlTests(new Evaluations::EvlTests);
  if(!EvlTests->init(options.domainId(), options.exerciseId(), options.testId(), options.operatorId(), options.criteriumId(), options.elementId(), options.sanNineLinerId() ))
    return iRet;

  QTimer::singleShot(2000, EvlTests.get(), &Evaluations::EvlTests::startTest);

  STARTUP_LOG(app.baseLogger());

  app.exec();

  iRet = EvlTests->testsSuccessful() ? 0 : 1;
  fprintf(stderr, "%d\n", iRet);

  DEBUG_LOG(app.baseLogger()) << "** TEST result = " << iRet;

  SHUTDOWN_LOG(app.baseLogger());

  return iRet;
}
//-----------------------------------------------------------------------------