/**
  * AES Function Topic Client test executable
  * $Id$
  * $HeadURL$
  * $Author$
  */

#include "aes_test_base.h"
#include <nglapplication/nglcoreapplication.h>
#include <LtsCommandLineParser/LtsCommandLineParser.h>
#include <QTimer>
#include <QtTest/QTest>

namespace AreaEffectSimulation
{

TestBase::TestBase(const char *loggerName, QObject *parent)
  : QObject(parent)
  , m_expectedAesId(-1)
  , m_bIsCreatedRequest(false)
  , m_bExpectedFailure(false)
  , m_replyError(false)
  , m_bTestsSuccessful(true)
  , m_testId(0)
  , m_aesTypeName(QString::fromLatin1(loggerName).splitRef(QLatin1Char('.')).last().toString())
  , m_logger(getLogger(loggerName))
{}


bool TestBase::init(int domainId, int exerciseId, int testId)
{
  INFO_LOG(m_logger) << "init begin";
  m_testId = testId;

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

  INFO_LOG(m_logger) << "init create ftc";
  m_ftc = AreaEffectSimulation::Interface::Ftc::create(m_ddsConnector);
  INFO_LOG(m_logger) << "init init ftc";
  bool bRet = m_ftc->enableAll();

  m_dtc = AreaEffectSimulation::Interface::Dtc::create(m_ddsConnector);
  bRet = bRet && m_dtc->enableAll();

  INFO_LOG(m_logger) << "init end - bRet = " << bRet;
  return bRet;
}

bool TestBase::waitForData(const std::function<bool()> &func)
{
  // wait for data
  for (int i = 0; i  < 100; i++)
  {
    if (func())
      return true;
    QTest::qWait(100);
  }
  return func();
}

bool TestBase::checkAesItem(const AreaEffectSimulation::AesItem &a,
                            const AreaEffectSimulation::AesItem &b) const
{
  if (a.name() != b.name())
  {
    WARNING_LOG(m_logger) << "name does not match: " << a.name() << " - " << b.name();
    return false;
  }
  if (a.effectStart() != b.effectStart())
  {
    WARNING_LOG(m_logger) << "effectStart does not match: " << a.effectStart() << " - " << b.effectStart();
    return false;
  }
  if (a.chargeStruct().chargeTypeId() != b.chargeStruct().chargeTypeId())
  {
    WARNING_LOG(m_logger) << "chargeTypeId does not match: " << a.chargeStruct().chargeTypeId() << " - " << b.chargeStruct().chargeTypeId();
    return false;
  }
  if (a.partyId() != b.partyId())
  {
    WARNING_LOG(m_logger) << "partyId does not match: " << a.partyId() << " - " << b.partyId();
    return false;
  }
  if (a.participantId() != b.participantId())
  {
    WARNING_LOG(m_logger) << "participantId does not match: " << a.participantId() << " - " << b.participantId();
    return false;
  }
  return true;
}

void TestBase::failExit()
{
  ERROR_LOG(m_logger) << "fail exit!";
  m_bTestsSuccessful = false;
  QTimer::singleShot(0, qApp, &QCoreApplication::quit);
}

void TestBase::onAesCreateReply(const Core::FunctionReplyObject &replyObject)
{
  INFO_LOG(m_logger) << "Got create " << m_aesTypeName << " reply with id " << replyObject.id()
                     << ", error = " << replyObject.error()
                     << " and errorString = '" << replyObject.translated() << "'";
  m_replyError = replyObject.error();
  if (m_replyError && !m_bExpectedFailure)
      ERROR_LOG(m_logger) << "Got create " << m_aesTypeName << " reply error: " << replyObject();
  else
    m_expectedAesId = replyObject.id(); // only works as expected because reply is sent before publishing data occours
}

void TestBase::onAesModifyReply(const Core::FunctionReplyObject &replyObject)
{
  if (m_expectedAesId != replyObject.id())
    return;
  INFO_LOG(m_logger) << "Got modify " << m_aesTypeName << " reply with id " << replyObject.id()
                     << ", error = " << replyObject.error()
                     << " and errorString = '" << replyObject.translated() << "'";
  m_replyError = replyObject.error();
  if (m_replyError && !m_bExpectedFailure)
    ERROR_LOG(m_logger) << "Got modify " << m_aesTypeName << " reply error: " << replyObject();
  else
    m_expectedAesId = replyObject.id();
}

void TestBase::onAesRemoveReply(const Core::FunctionReplyObject &replyObject)
{
  INFO_LOG(m_logger) << "Got remove " << m_aesTypeName << " reply with id " << replyObject.id()
                     << " and errorString " << replyObject.translated();
  m_replyError = replyObject.error();
  if (m_replyError && !m_bExpectedFailure)
    ERROR_LOG(m_logger) << "Got remove " << m_aesTypeName << " reply error: " << replyObject();
  else
    m_expectedAesId = replyObject.id();
}

void TestBase::onAesTriggerReply(const Core::FunctionReplyObject &replyObject)
{
  INFO_LOG(m_logger) << "Got trigger " << m_aesTypeName << " reply with id " << replyObject.id()
                     << " and errorString " << replyObject.translated();
  m_replyError = replyObject.error();
  if (m_replyError && !m_bExpectedFailure)
    ERROR_LOG(m_logger) << "Got remove " << m_aesTypeName << " reply error: " << replyObject();
  else
    m_expectedAesId = replyObject.id();
}

// ------------------------------------------------------------------
class CmdLineParser : public LtsCommandLineParser::LtsCommandLineParser
{
public:
  CmdLineParser()
    : LtsCommandLineParser()
  {
    addOption( { QStringList() << QLatin1String("t") << QLatin1String("testId")
                 , QLatin1String("TestId.")
                 , QLatin1String("Default: 0")
                 , QLatin1String("0")
               } );
  }

  int testId() const         { return isSet(QLatin1String("t")) ? value(QLatin1String("t")).toInt() : 0; }
};

// ------------------------------------------------------------------
int mainBase(int argc, char **argv,
             const std::function<TestBase*()> &createFunc)
{
  NGLCoreApplication app(argc, argv);
  app.createLogger("AES", "log4cxx_aes.props");

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

  if (options.exerciseId() <= 0)
  {
    fprintf(stderr, "ExerciseId not set!\n");
    return -2;
  }

  int iRet = -1;
  {
    std::unique_ptr <TestBase> test(createFunc());
    if (!test->init(options.domainId(), options.exerciseId(), options.testId()))
      return iRet;

    QTimer::singleShot(0, test.get(), &TestBase::startTest);

    STARTUP_LOG(app.baseLogger());

    app.exec();

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

    SHUTDOWN_LOG(app.baseLogger());
  }

  return iRet;
}

} // namespace AreaEffectSimulation