/**
  * @RDE_HEADER@
  * ISM Function Topic test executable
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Iuliana Ojog, SLSE, 2016-11-28
  */

#include "ism_tests.h"

#include <nglapplication/nglcoreapplication.h>
#include <LtsCommandLineParser/LtsCommandLineParser.h>

#include <QtCore/QTimer>
#include <QtCore/QDateTime>
#include <QTest>
#include <QtCore/QSet>
#include <QtCore/QVector>
#include <QJsonObject>
#include <QJsonDocument>

#include <LtsUtilsCore/pgarray.h>
#include <LtsUtilsCore/dds_vector.h>
#include <InfrastructureManagement/ism_ftc.h>
#include <InfrastructureManagement/ism_dtc.h>
#include <InfrastructureManagement/ism_enums.hpp>
#include <InfrastructureManagement/settings.h>

/* ----------------------------------------------------------------------------------
 * HOW TO RUN THE TESTS (for example)
 * ----------------------------------------------------------------------------------
 *  0. Preconditions:
 *  Start with an empty database (BUILD)
 *     make db
 *  Start services: (SV)
 *     ./bin/svcExerciseManagement -d 74 &
 *     ./bin/svcInfrastructureManagement -d 74 &
 *  Test steps: see ism_tests.csv
 */

// ------------------------------------------------------------------------------
using namespace InfrastructureManagement;

IsmTests::IsmTests(QObject *parent)
  : QObject(parent)
  , m_testId(0)
  , m_assetId(0)
  , m_mainStructureElementId(0)
  , m_structureElementId(0)
  , m_indexNo(0)
  , m_bTestsSuccessful(true)
  , m_logger(getLogger("Test"))
{
  qRegisterMetaType<Core::FunctionReply>("Core::FunctionReply");
}

// ------------------------------------------------------------------------------
IsmTests::~IsmTests()
{
}

// ------------------------------------------------------------------------------
bool IsmTests::init(int domainId, int testId, int assetId, int mainStructureElementId, int structureElementId, int indexNo)
{
  INFO_LOG(m_logger) << "init begin";

  m_testId = testId;
  m_assetId = assetId;
  m_mainStructureElementId = mainStructureElementId;
  m_structureElementId = structureElementId;
  m_indexNo = indexNo;

  // initialize DDS, always on exercise 0
  m_ddsConnector.reset(new DDSConnector::DdsConnector(domainId, IDL::PartitionType::Global));
  if (!m_ddsConnector->init())
    return false;
  m_ddsConnector->initPublisherSubscriber();

  // initialize database
  m_dbHandler = std::make_shared<DbHandler>();
  if(!m_dbHandler->init(0, Settings::settings()))
  {
    ERROR_LOG(m_logger) << "Initialisation dbHandler failed.";
    return false;
  }
  DEBUG_LOG(m_logger) << "Initialisation dbHandler succesful.";
  m_db = m_dbHandler->db();

  TRACE_LOG(m_logger) << "create dtc";
  m_dtc = InfrastructureManagement::Interface::Dtc::create(m_ddsConnector);
  TRACE_LOG(m_logger) << "init dtc";
  bool bRet = m_dtc->enableAll();
  TRACE_LOG(m_logger) << "init dtc end - bRet = " << bRet;

  TRACE_LOG(m_logger) << "create ftc";
  m_ftc = InfrastructureManagement::Interface::Ftc::create(m_ddsConnector);
  TRACE_LOG(m_logger) << "init ftc";
  bRet &= m_ftc->enableAll();
  TRACE_LOG(m_logger) << "init ftc end - bRet = " << bRet;

  DEBUG_LOG(m_logger) << "########### Domain Id = " << domainId;
  DEBUG_LOG(m_logger) << "########### Test Id = " << testId;
  DEBUG_LOG(m_logger) << "########### Asset Id = " << assetId;
  DEBUG_LOG(m_logger) << "########### Main Structure Element Id = " << mainStructureElementId;
  DEBUG_LOG(m_logger) << "########### Structure Element Id = " << structureElementId;
  DEBUG_LOG(m_logger) << "########### Index No = " << indexNo;

  return bRet;
}

// ------------------------------------------------------------------------------
void IsmTests::startTest()
{
  INFO_LOG(m_logger) << "********* startTest **************";
  // main structure elements
  switch (m_testId)
  {
  // main structure elements
  case 101:
    tryCreateMainStructureElement();
    break;
  case 102:
    tryModifyMainStructureElement();
    break;
  case 103:
    tryRemoveMainStructureElement();
    break;
  case 104:
    tryCreateBridge();
    break;
  case 105:
    tryChangeBridgeStatus();
    break;
    // assets
  case 131:
    tryCreateAsset();
    break;
  case 132:
    tryModifyAsset();
    break;
  case 133:
    tryRemoveAsset();
    break;
  case 134:
    tryUnmountAsset();
    break;
    // mounting point asset
  case 141:
    tryCreateMountingPointAsset();
    break;
  case 143:
    tryRemoveMountingPointAsset();
    break;
    // mounting point schedule
  case 151:
    tryCreateMainSchedule();
    break;
  case 152:
    tryModifyMainSchedule();
    break;
  case 153:
    tryRemoveMainSchedule();
    break;
  case 154:
    tryChangeStatusSchedule();
    break;
  case 155:
    tryCopySchedule();
    break;
  case 156:
    checkSchedule();
    break;
    // mouting point plan
  case 161:
    tryCreateMountingPointPlan();
    break;
  default:
    failExit();
    break;
  }
  INFO_LOG(m_logger) << "*********  endTest  **************";
  QTimer::singleShot(0, qApp, &QCoreApplication::quit);
}

// ------------------------------------------------------------------------------
static void addElementToRequest(MainStructureElementModifyRequest &request,
                                const StructureElement &se,
                                int parentIdx)
{
  const size_t size = request.elements.size();
  request.elements.resize(size + 1, se);
  request.childParentRelations.resize(size + 1, parentIdx);
}

// ************* MAIN STRUCTURE ELEMENT **********************************************
// ------------------------------------------------------------------------------
void IsmTests::tryCreateMainStructureElement()
{
  INFO_LOG(m_logger) << "trying to send MainStructureElementCreateRequest";

  MainStructureElementModifyRequest data;

  // Building 56
  data.name = "Test Building";
  QJsonObject jsonObj;
  jsonObj[QStringLiteral("street")] = QStringLiteral("Brueggeweg");
  jsonObj[QStringLiteral("number")] = QStringLiteral("56");
  //    '{"street":"Brueggeweg", "number":"56"}'
  QJsonDocument doc(jsonObj);
  data.description = doc.toJson().toStdString();
  data.angle = 30.5;
  data.modelId = 1001;
  data.externalWlsId = 1001;
  data.geoPosition.lon = 0.1552736550;
  data.geoPosition.lat = 0.9259746511;
  data.geoPosition.z = 0.00;
  data.properties = "{}";
  data.structureElementTypeId = InfrastructureManagement::StructureElementType::Building;

  StructureElement seData;
  // element 1 & 2 -> see ParseBuildingXml::parseXmlInternal()
  // building, idx = 0
  seData.name = "Test Building";
  seData.displayName = "Building 56";
  seData.structureElementTypeId = InfrastructureManagement::StructureElementType::Building;
  seData.relPosition.offsetX = 0;
  seData.relPosition.offsetY = 0;
  seData.relPosition.offsetZ = 0;
  seData.mountingPointTypeId = InfrastructureManagement::MountingPointType::Unknown;
  seData.properties = "{\"description\":\"Info Test Building\"}";

  addElementToRequest(data, seData, -1); // root element has no parent

  // building mounting point, idx = 1
  seData.name = "Test Building - Mounting Point";
  seData.displayName = "Building 56 - MP";
  seData.structureElementTypeId = InfrastructureManagement::StructureElementType::MountingPoint;
  seData.barcode = "4711";
  seData.relPosition.offsetX = 0;
  seData.relPosition.offsetY = 0;
  seData.relPosition.offsetZ = 0;
  seData.mountingPointTypeId = InfrastructureManagement::MountingPointType::BuildingControlUnit;
  seData.properties = "{\"description\":\"Info Test Mounting Point\"}";

  addElementToRequest(data, seData, 0);

  // Floor 1, idx = 1
  seData.name = "Floor 01";
  seData.displayName = "Floor 1";
  seData.structureElementTypeId = InfrastructureManagement::StructureElementType::Floor; // type floor
  seData.barcode = "123xxxx";
  seData.relPosition.offsetX = 70000;
  seData.relPosition.offsetY = 90000;
  seData.relPosition.offsetZ = 10;
  seData.mountingPointTypeId = InfrastructureManagement::MountingPointType::Unknown;
  seData.orientation = Core::Orientation(0, 0, 0);
  seData.properties = "{\"description\":\"Info-Building-56-Floor-01\"}";

  addElementToRequest(data, seData, 0);

  // Floor 2, idx = 2
  seData.name = "Floor 02";
  seData.displayName = "Floor 2";
  seData.structureElementTypeId = InfrastructureManagement::StructureElementType::Floor; // type floor
  seData.barcode = "123xxxx";
  seData.relPosition.offsetX = 70000;
  seData.relPosition.offsetY = 90000;
  seData.relPosition.offsetZ = 10;
  seData.mountingPointTypeId = InfrastructureManagement::MountingPointType::Unknown;
  seData.orientation = Core::Orientation(0, 0, 0);
  seData.properties = "{\"description\":\"Info-Building-56-Floor-02\"}";

  addElementToRequest(data, seData, 0);

  // Room 01-01, idx = 3
  seData.name = "Room 01";
  seData.displayName = "Room 01";
  seData.structureElementTypeId = InfrastructureManagement::StructureElementType::Room; // type room
  seData.barcode = "123xxxx";
  seData.relPosition.offsetX = 70000;
  seData.relPosition.offsetY = 90000;
  seData.relPosition.offsetZ = 10;
  seData.mountingPointTypeId = InfrastructureManagement::MountingPointType::Unknown;
  seData.orientation = Core::Orientation(0, 0, 0);
  seData.properties = "{\"description\":\"Info-Building-56-Floor-01-Room-01\"}";

  addElementToRequest(data, seData, 1);

  // Room 01-02, idx = 4
  seData.name = "Room 02";
  seData.displayName = "Room 02";
  seData.structureElementTypeId = InfrastructureManagement::StructureElementType::Room; // type room
  seData.barcode = "123xxxx";
  seData.relPosition.offsetX = 70000;
  seData.relPosition.offsetY = 90000;
  seData.relPosition.offsetZ = 10;
  seData.mountingPointTypeId = InfrastructureManagement::MountingPointType::Unknown;
  seData.orientation = Core::Orientation(0, 0, 0);
  seData.properties = "{\"description\":\"Info-Building-56-Floor-01-Room-02\"}";

  addElementToRequest(data, seData, 1);

  // Room 02-01, idx = 5
  seData.name = "Room 01";
  seData.displayName = "Room 01";
  seData.structureElementTypeId = InfrastructureManagement::StructureElementType::Room; // type room
  seData.barcode = "123xxxx";
  seData.relPosition.offsetX = 70000;
  seData.relPosition.offsetY = 90000;
  seData.relPosition.offsetZ = 10;
  seData.mountingPointTypeId = InfrastructureManagement::MountingPointType::Unknown;
  seData.orientation = Core::Orientation(0, 0, 0);
  seData.properties = "{\"description\":\"Info-Building-56-Floor-02-Room-01\"}";

  addElementToRequest(data, seData, 2);

  // Room 02-02, idx = 6
  seData.name = "Room 02";
  seData.displayName = "Room 02";
  seData.structureElementTypeId = InfrastructureManagement::StructureElementType::Room; // type room
  seData.barcode = "123xxxx";
  seData.relPosition.offsetX = 70000;
  seData.relPosition.offsetY = 90000;
  seData.relPosition.offsetZ = 10;
  seData.mountingPointTypeId = InfrastructureManagement::MountingPointType::Unknown;
  seData.orientation = Core::Orientation(0, 0, 0);
  seData.properties = "{\"description\":\"Info-Building-56-Floor-02-Room-02\"}";

  addElementToRequest(data, seData, 2);

  // Mounting Point 01-01-01
  seData.name = "Mounting Point 56-01-01-01";
  seData.displayName = "MP 1";
  seData.structureElementTypeId = InfrastructureManagement::StructureElementType::MountingPoint; // type mounting point
  seData.barcode = "123xxxx";
  seData.relPosition.offsetX = 70000;
  seData.relPosition.offsetY = 90000;
  seData.relPosition.offsetZ = 10;
  seData.mountingPointTypeId = InfrastructureManagement::MountingPointType::IndoorCamera;
  seData.orientation = Core::Orientation(0, 0, 0);
  seData.properties = "{\"description\":\"Info-Building-56-Floor-01-Room-01-MP-01\"}";

  addElementToRequest(data, seData, 3);

  // Mounting Point 01-01-02
  seData.name = "Mounting Point 56-01-01-02";
  seData.displayName = "MP 2";
  seData.structureElementTypeId = InfrastructureManagement::StructureElementType::MountingPoint; // type mounting point
  seData.barcode = "123xxxx";
  seData.relPosition.offsetX = 70000;
  seData.relPosition.offsetY = 90000;
  seData.relPosition.offsetZ = 10;
  seData.mountingPointTypeId = InfrastructureManagement::MountingPointType::IndoorCamera;
  seData.orientation = Core::Orientation(0, 0, 0);
  seData.properties = "{\"description\":\"Info-Building-56-Floor-01-Room-01-MP-02\"}";

  addElementToRequest(data, seData, 3);

  // Mounting Point 01-02-01
  seData.name = "Mounting Point 56-01-02-01";
  seData.displayName = "MP 3";
  seData.structureElementTypeId = InfrastructureManagement::StructureElementType::MountingPoint; // type mounting point
  seData.barcode = "123xxxx";
  seData.relPosition.offsetX = 70000;
  seData.relPosition.offsetY = 90000;
  seData.relPosition.offsetZ = 10;
  seData.mountingPointTypeId = InfrastructureManagement::MountingPointType::IndoorCamera;
  seData.orientation = Core::Orientation(0, 0, 0);
  seData.properties = "{\"description\":\"Info-Building-56-Floor-01-Room-02-MP-01\"}";

  addElementToRequest(data, seData, 4);

  // Mounting Point 01-02-02
  seData.name = "Mounting Point 56-01-02-02";
  seData.displayName = "MP 4";
  seData.structureElementTypeId = InfrastructureManagement::StructureElementType::MountingPoint; // type mounting point
  seData.barcode = "123xxxx";
  seData.relPosition.offsetX = 70000;
  seData.relPosition.offsetY = 90000;
  seData.relPosition.offsetZ = 10;
  seData.mountingPointTypeId = InfrastructureManagement::MountingPointType::IndoorCamera;
  seData.orientation = Core::Orientation(0, 0, 0);
  seData.properties = "{\"description\":\"Info-Building-56-Floor-01-Room-02-MP-02\"}";

  addElementToRequest(data, seData, 4);

  // mounting point building central unit
  seData.name = "Test MP Building";
  seData.displayName = "MP 5";
  seData.structureElementTypeId = InfrastructureManagement::StructureElementType::MountingPoint;
  seData.barcode = "4711";
  seData.relPosition.offsetX = 0;
  seData.relPosition.offsetY = 0;
  seData.relPosition.offsetZ = 0;
  seData.mountingPointTypeId = InfrastructureManagement::MountingPointType::BuildingControlUnit;
  seData.properties = "{\"description\":\"Info MP Test Building\"}";

  addElementToRequest(data, seData, 0);

  //Footprint
  InfrastructureManagement::FootprintElement feData;
  std::vector<FootprintElement> elements;
  elements.resize(4);

  // index 1
  feData.id = 1;
  feData.relPosition.offsetX = 0;
  feData.relPosition.offsetY = 0;
  feData.relPosition.offsetZ = 0;

  elements[0] = feData;

  // index 2
  feData.id = 2;
  feData.relPosition.offsetX = 9.11999988555908;
  feData.relPosition.offsetY = 0;
  feData.relPosition.offsetZ = 0;

  elements[1] = feData;

  // index 3
  feData.id = 3;
  feData.relPosition.offsetX = 9.11999988555908;
  feData.relPosition.offsetY = 9.02999973297119;
  feData.relPosition.offsetZ = 0;

  elements[2] = feData;

  // index 4
  feData.id = 4;
  feData.relPosition.offsetX = 0;
  feData.relPosition.offsetY = 9.02999973297119;
  feData.relPosition.offsetZ = 0;

  elements[3] = feData;

  data.footprint = elements;

  QByteArray vmTest;
  vmTest += "bla-bla-bla";
//  data.vulnerabilityData(LtsUtils::convert<std::vector<uint8_t>>(vmTest));

//  if (!m_ftc->mainStructureElementModifyRequest(data, this))
//  {
//    ERROR_LOG(m_logger) << "Error requesting create data (building)";
//    failExit();
//  }

  QTest::qWait(1000);
}

// ------------------------------------------------------------------------------
void IsmTests::tryModifyMainStructureElement()
{
  INFO_LOG(m_logger) << "trying to send MainStructureElementModifyRequest ";
  m_dtc->waitForHistoricalDataMainStructureElement();
  InfrastructureManagement::MainStructureElement mse = m_dtc->mainStructureElement(m_mainStructureElementId);
  InfrastructureManagement::MainStructureElementModifyRequest data;

  if (mse.id == 0)
  {
    ERROR_LOG(m_logger) << "Error requesting modify data";
    failExit();
  }

  DEBUG_LOG(m_logger) << "Modify MainStructureElement with id = " << mse.id;

  // creating ModifyRequest
  data.id = mse.id;
  data.name = mse.name;
  data.description = mse.description;
  data.angle = mse.angle;
  data.modelId = mse.modelId;
  data.externalWlsId = mse.externalWlsId;
  data.geoPosition = mse.geoPosition;
  data.elements = mse.elements;
  data.properties = mse.properties;
  data.structureElementTypeId = mse.structureElementTypeId;

  // changing MSE name
  data.name = "TestBuilding-Updated";

  m_replyFinished = false;
  if (!m_ftc->mainStructureElementModifyRequest(data, this))
  {
    ERROR_LOG(m_logger) << "Error requesting modify data";
    failExit();
  }

  QTRY_COMPARE(m_replyFinished, true);

  // updating SE barcodes

  InfrastructureManagement::StructureElement se;
  InfrastructureManagement::StructureElementModifyRequest seData;
  seData.mainStructureElementId = mse.id;
  seData.elements.reserve(mse.elements.size());

  for (size_t i = 0; i < mse.elements.size(); ++i)
  {
    se = mse.elements.at(i);
    DEBUG_LOG(m_logger) << "Updating barcode for element (" << i << ") with old barcode = " << se.barcode;

    se.barcode = "BARCODE";
    seData.elements.push_back(se);
  }

  if (!m_ftc->structureElementModifyRequest(seData, this))
  {
    ERROR_LOG(m_logger) << "Error requesting modify data";
    failExit();
  }

  QTest::qWait(1000);
}

// ------------------------------------------------------------------------------
void IsmTests::tryRemoveMainStructureElement()
{
  INFO_LOG(m_logger) << "trying to send MainStructureElementRemoveRequest  for mse id = " << m_mainStructureElementId;

  m_dtc->waitForHistoricalDataMainStructureElement();
  InfrastructureManagement::MainStructureElement mse = m_dtc->mainStructureElement(m_mainStructureElementId);

  if (mse.id == 0)
  {
    ERROR_LOG(m_logger) << "Cannot find main structure element with id = " << m_mainStructureElementId;
    failExit();
  }

  if (!m_ftc->mainStructureElementRemoveRequest(MainStructureElementRemoveRequest(m_mainStructureElementId), this))
  {
    ERROR_LOG(m_logger) << "Error requesting delete data";
    failExit();
  }

  QTest::qWait(1000);
}

// ------------------------------------------------------------------------------
void IsmTests::tryCreateBridge()
{
  INFO_LOG(m_logger) << "trying to send MainStructureElementCreateRequest";

  MainStructureElementModifyRequest data;

  data.name = "Test Bridge";
  QJsonObject jsonObj;
  jsonObj[QStringLiteral("bridgeStatus")] = 0;
  //    '{"bridgeStatus":0}'
  QJsonDocument doc(jsonObj);
  data.properties = doc.toJson().toStdString();
  data.angle = 30.5;
  data.modelId = 0;
  data.externalWlsId = 0;
  data.geoPosition.lon = 0.1552736550;
  data.geoPosition.lat = 0.9259746511;
  data.geoPosition.z = 0.00;
  data.description = "{}";
  data.structureElementTypeId = InfrastructureManagement::StructureElementType::Bridge;

  StructureElement seData;
  seData.name = "Test Bridge";
  seData.displayName = "Bridge 001";
  seData.structureElementTypeId = InfrastructureManagement::StructureElementType::Bridge;
  seData.relPosition.offsetX = 0;
  seData.relPosition.offsetY = 0;
  seData.relPosition.offsetZ = 0;
  seData.mountingPointTypeId = InfrastructureManagement::MountingPointType::Unknown;
  seData.properties = "{\"description\":\"Info Test Bridge\"}";

  addElementToRequest(data, seData, -1); // root element has no parent

  if (!m_ftc->mainStructureElementModifyRequest(data, this))
  {
    ERROR_LOG(m_logger) << "Error requesting create data (bridge)";
    failExit();
  }

  QTest::qWait(1000);
}


// ------------------------------------------------------------------------------
void IsmTests::tryChangeBridgeStatus()
{
  INFO_LOG(m_logger) << "trying to send MainStructureElementModifyBridgeStatusRequest ";
  m_dtc->waitForHistoricalDataMainStructureElement();
  InfrastructureManagement::MainStructureElement mse = m_dtc->mainStructureElement(m_mainStructureElementId);
  InfrastructureManagement::MainStructureElementModifyBridgeStatusRequest data;

  if (mse.id == 0)
  {
    ERROR_LOG(m_logger) << "Error requesting modify data";
    failExit();
  }

  DEBUG_LOG(m_logger) << "Modify MainStructureElement with id = " << mse.id;

  // creating ModifyRequest
  data.id = mse.id;
  if (m_dtc->getBridgeStatus(m_mainStructureElementId) == BridgeStatus::Intact)
    data.status = BridgeStatus::Broken;
  else
    data.status = BridgeStatus::Intact;

  m_replyFinished = false;
  if (!m_ftc->mainStructureElementModifyBridgeStatusRequest(data, this))
  {
    ERROR_LOG(m_logger) << "Error requesting modify bridge status";
    failExit();
  }

  QTRY_COMPARE(m_replyFinished, true);

  QTest::qWait(1000);
}


// ************* ASSET **********************************************************
// ------------------------------------------------------------------------------
void IsmTests::tryCreateAsset()
{
  INFO_LOG(m_logger) << "trying to send AssetCreateRequest";

  InstrumentationAssetModifyRequest data;

  data.name = "Camera-01";
  data.mountingPointTypeId = InfrastructureManagement::MountingPointType::IndoorCamera;
  data.barcode = "1";
  data.properties = "{\"description\":\"Info-Camera-01\"}";

  if (!m_ftc->instrumentationAssetModifyRequest(data, this))
  {
    ERROR_LOG(m_logger) << "Error requesting create data";
    failExit();
  }

  QTest::qWait(1000);

  data.name = "Camera-02";
  data.barcode = "2";
  data.mountingPointTypeId = InfrastructureManagement::MountingPointType::IndoorCamera;
  data.properties = "{\"description\":\"Info-Camera-02\"}";

  if (!m_ftc->instrumentationAssetModifyRequest(data, this))
  {
    ERROR_LOG(m_logger) << "Error requesting create data";
    failExit();
  }

  QTest::qWait(1000);

  data.name = "Camera-03";
  data.barcode = "3";
  data.mountingPointTypeId = InfrastructureManagement::MountingPointType::MeteoDataUnit;
  data.properties = "{\"description\":\"Info-Camera-03\"}";

  if (!m_ftc->instrumentationAssetModifyRequest(data, this))
  {
    ERROR_LOG(m_logger) << "Error requesting create data";
    failExit();
  }

  QTest::qWait(1000);

  data.name = "Camera-04";
  data.barcode = "4";
  data.mountingPointTypeId = InfrastructureManagement::MountingPointType::MeteoDataUnit;
  data.properties = "{\"description\":\"Info-Camera-03\"}";

  if (!m_ftc->instrumentationAssetModifyRequest(data, this))
  {
    ERROR_LOG(m_logger) << "Error requesting create data";
    failExit();
  }

  QTest::qWait(1000);

}

// ------------------------------------------------------------------------------
void IsmTests::tryModifyAsset()
{
  INFO_LOG(m_logger) << "trying to send asset modify request ";

  DEBUG_LOG(m_logger) << "m_assetId = " << m_assetId;

  m_dtc->waitForHistoricalDataInstrumentationAsset();
  const InfrastructureManagement::InstrumentationAsset &ast = m_dtc->instrumentationAsset(m_assetId);
  //  const InfrastructureManagement::InstrumentationAsset &ast1 = m_dtc->instrumentationAssets()[m_assetId];
  InfrastructureManagement::InstrumentationAssetModifyRequest data;

  DEBUG_LOG(m_logger) << "ast.id() = " << ast.id;
  //  DEBUG_LOG(m_logger) << "ast1.id() = " << ast1.id();

  if (ast.id == 0)
  {
    ERROR_LOG(m_logger) << "Cannot find Asset Id = " << m_assetId;
    failExit();
  }
  else
  {
    data.id = ast.id;
    data.name = ast.name;
    data.barcode = ast.barcode;
    data.mountingPointTypeId = ast.mountingPointTypeId;
    data.instrumentationAssetStateId = ast.assetStateId;
    data.properties = ast.properties;

    // changing only name
    data.name = "Asset-Updated";

    if (!m_ftc->instrumentationAssetModifyRequest(InstrumentationAssetModifyRequest(data), this))
    {
      ERROR_LOG(m_logger) << "Error requesting modify data";
      failExit();
    }

    QTest::qWait(1000);
  }
}

// ------------------------------------------------------------------------------
void IsmTests::tryRemoveAsset()
{
  INFO_LOG(m_logger) << "trying to send AssetRemoveRequest for id = " << m_assetId;

  m_dtc->waitForHistoricalDataInstrumentationAsset();
  const InfrastructureManagement::InstrumentationAsset &ast = m_dtc->instrumentationAsset(m_assetId);

  if (ast.id == 0)
  {
    ERROR_LOG(m_logger) << "Cannot find Asset Id = " << m_assetId;
    failExit();
  }

  if (!m_ftc->instrumentationAssetRemoveRequest(InstrumentationAssetRemoveRequest(m_assetId), this))
  {
    ERROR_LOG(m_logger) << "Error requesting delete data";
    failExit();
  }
  QTest::qWait(1000);
}

// ------------------------------------------------------------------------------
void IsmTests::tryUnmountAsset()
{
  INFO_LOG(m_logger) << "trying to send asset state modify request ";

  DEBUG_LOG(m_logger) << "m_assetId = " << m_assetId;

  m_dtc->waitForHistoricalDataInstrumentationAsset();
  const InfrastructureManagement::InstrumentationAsset &ast = m_dtc->instrumentationAsset(m_assetId);
  //  const InfrastructureManagement::InstrumentationAsset &ast1 = m_dtc->instrumentationAssets()[m_assetId];
  InfrastructureManagement::InstrumentationAssetSetStateRequest data;

  DEBUG_LOG(m_logger) << "ast.id() = " << ast.id;
  //  DEBUG_LOG(m_logger) << "ast1.id() = " << ast1.id();

  if (ast.id == 0)
  {
    ERROR_LOG(m_logger) << "Cannot find Asset Id = " << m_assetId;
    failExit();
  }
  else
  {
    data.id = ast.id;
    data.instrumentationAssetStateId = InstrumentationAssetState::Unmounted;

    if (!m_ftc->instrumentationAssetSetStateRequest(InstrumentationAssetSetStateRequest(data), this))
    {
      ERROR_LOG(m_logger) << "Error requesting set asset state";
      failExit();
    }

    QTest::qWait(1000);
  }
}

// ************* MOUNTING POINT ASSETS *******************************************
// ------------------------------------------------------------------------------
void IsmTests::tryCreateMountingPointAsset()
{
  INFO_LOG(m_logger) << "trying to send AssetCreateRequest";

  MountingPointAssetModifyRequest data;

  data.assetId = m_assetId;
  data.structureElementId = m_structureElementId;
  data.lastUpdated = QDateTime::currentMSecsSinceEpoch();

  if (!m_ftc->mountingPointAssetModifyRequest(data, this))
  {
    ERROR_LOG(m_logger) << "Error requesting create data";
    failExit();
  }

  QTest::qWait(1000);
}

// ------------------------------------------------------------------------------
void IsmTests::tryRemoveMountingPointAsset()
{
  INFO_LOG(m_logger) << "trying to send MountingPointAssetRemoveRequest ";

  m_dtc->waitForHistoricalDataMountingPointAsset();
  if (!m_dtc->getMountingPointAssetId(m_structureElementId, m_assetId, m_mountingPointAssetId))
  {
    ERROR_LOG(m_logger) << "Cannot find requested mounting point asset";
    failExit();
  }

  DEBUG_LOG(m_logger) << "MountingPointAsset Id = " << m_mountingPointAssetId;

  if (!m_ftc->mountingPointAssetRemoveRequest(MountingPointAssetRemoveRequest(m_mountingPointAssetId), this))
  {
    ERROR_LOG(m_logger) << "Error requesting delete data";
    failExit();
  }

  QTest::qWait(1000);
}

// ************* MOUNTING POINT SCHEDULE **********************************************************
// ------------------------------------------------------------------------------
void IsmTests::tryCreateMainSchedule()
{
  INFO_LOG(m_logger) << "trying to send MainScheduleCreateRequest";

  MainScheduleModifyRequest data0, data1, data2;

  data1.id = 0; // to be inserted
  data1.name = "Instrumentation Plan 1 (ex 42)";
  data1.exerciseId = 42;
  data1.statusId = InfrastructureManagement::ScheduleStatus::Inactive;
  data1.timeCreated = 10000000;
  data1.timeStart = 12000000;
  data1.timeEnd = 13000000;
  data1.description = "Info-Main-Schedule-01";

  if (!m_ftc->mainScheduleModifyRequest(data1, this))
  {
    ERROR_LOG(m_logger) << "Error requesting create data";
    failExit();
  }

  QTest::qWait(1000);

  data2.id = 0; // to be inserted
  data2.name = "Instrumentation Plan 2 (ex 42)";
  data2.exerciseId = 42;
  data2.statusId = InfrastructureManagement::ScheduleStatus::Inactive;
  data2.timeCreated = 14000000;
  data2.timeStart = 16000000;
  data2.timeEnd = 17000000;
  data2.description = "Info-Main-Schedule-02";

  if (!m_ftc->mainScheduleModifyRequest(data2, this))
  {
    ERROR_LOG(m_logger) << "Error requesting create data";
    failExit();
  }

  QTest::qWait(1000);

  data0.id = 0; // to be inserted
  data0.name = "No exercise";
  data0.statusId = InfrastructureManagement::ScheduleStatus::Active;
  data0.timeCreated = 14000000;
  data0.timeStart = 15000000;
  data0.timeEnd = 19000000;
  data0.description = "Info-Main-Schedule-03";

  if (!m_ftc->mainScheduleModifyRequest(data0, this))
  {
    ERROR_LOG(m_logger) << "Error requesting create data";
    failExit();
  }

  QTest::qWait(1000);
}

// ------------------------------------------------------------------------------
void IsmTests::tryModifyMainSchedule()
{
  INFO_LOG(m_logger) << "trying to send mounting point schedule modify request ";

  m_dtc->waitForHistoricalDataMainSchedule();
  // using m_assetId as main schedule id
  InfrastructureManagement::MainSchedule ast = m_dtc->mainSchedule(m_assetId);
  InfrastructureManagement::MainScheduleModifyRequest data;

  DEBUG_LOG(m_logger) << "m_assetId = " << m_assetId;

  DEBUG_LOG(m_logger) << "ast.id() = " << ast.id;

  // creating ModifyRequest
  if (ast.id > 0)
  {
    data.id = ast.id;
    data.name = ast.name;
    data.statusId = ast.statusId;
    data.exerciseId = ast.exerciseId;
    data.timeCreated = ast.timeCreated;
    data.timeStart = ast.timeStart;
    data.timeEnd = ast.timeEnd;
    data.description = ast.description;

    // changing name
    data.name = "MPS-Updated";

    if (!m_ftc->mainScheduleModifyRequest(MainScheduleModifyRequest(data), this))
    {
      ERROR_LOG(m_logger) << "Error requesting modify data";
      failExit();
    }
  }
  else
  {
    ERROR_LOG(m_logger) << "Cannot find main schedule id = " << m_assetId;
    failExit();
  }
  QTest::qWait(1000);
}

// ------------------------------------------------------------------------------
void IsmTests::tryChangeStatusSchedule()
{
  INFO_LOG(m_logger) << "trying to send mounting point schedule modify request ";

  m_dtc->waitForHistoricalDataMainSchedule();
  // using m_assetId as main schedule id
  InfrastructureManagement::MainSchedule ast = m_dtc->mainSchedule(m_assetId);
  InfrastructureManagement::MainScheduleModifyRequest data;

  DEBUG_LOG(m_logger) << "m_assetId = " << m_assetId;

  DEBUG_LOG(m_logger) << "ast.id() = " << ast.id;

  // creating ModifyRequest
  if (ast.id > 0)
  {
    data.id = ast.id;
    data.name = ast.name;
    data.statusId = ast.statusId;
    data.exerciseId = ast.exerciseId;
    data.timeCreated = ast.timeCreated;
    data.timeStart = ast.timeStart;
    data.timeEnd = ast.timeEnd;
    data.description = ast.description;

    // changing name and status
    switch (data.statusId)
    {
    case InfrastructureManagement::ScheduleStatus::Inactive:
    {
      data.name = "MPS-UpdatedStatus-Activated";
      data.statusId = InfrastructureManagement::ScheduleStatus::Active;
      data.timeStart = QDateTime::currentMSecsSinceEpoch();
      break;
    }
    case InfrastructureManagement::ScheduleStatus::Active:
    {
      data.name = "MPS-UpdatedStatus-Inactivated";
      data.statusId = InfrastructureManagement::ScheduleStatus::Inactive;
      data.timeEnd = QDateTime::currentMSecsSinceEpoch();
      break;
    }
    default:
      break;
    }

    if (!m_ftc->mainScheduleModifyRequest(MainScheduleModifyRequest(data), this))
    {
      ERROR_LOG(m_logger) << "Error requesting modify data";
      failExit();
    }
  }
  else
  {
    ERROR_LOG(m_logger) << "Cannot find main schedule id = " << m_assetId;
    failExit();
  }
  QTest::qWait(1000);
}

// ------------------------------------------------------------------------------
void IsmTests::tryRemoveMainSchedule()
{
  INFO_LOG(m_logger) << "trying to send MainScheduleRemoveRequest for id = " << m_assetId;

  m_dtc->waitForHistoricalDataMainSchedule();
  InfrastructureManagement::MainSchedule ast = m_dtc->mainSchedule(m_assetId);

  if (ast.id == 0)
  {
    ERROR_LOG(m_logger) << "Cannot find main schedule id = " << m_assetId;
    failExit();
  }

  if (!m_ftc->mainScheduleRemoveRequest(MainScheduleRemoveRequest(m_assetId), this))
  {
    ERROR_LOG(m_logger) << "Error requesting delete data";
    failExit();
  }
  QTest::qWait(1000);
}

// ------------------------------------------------------------------------------
void IsmTests::tryCopySchedule()
{
  INFO_LOG(m_logger) << "trying to copy schedule";

  m_dtc->waitForHistoricalDataMainSchedule();
  // using m_assetId as main schedule id
  InfrastructureManagement::MainSchedule ms = m_dtc->mainSchedule(m_assetId);

  DEBUG_LOG(m_logger) << "scheduleId = " << m_assetId;
  DEBUG_LOG(m_logger) << "ms.id() = " << ms.id;

  int newId = m_db->copySchedule(ms.id);

  if (newId <= 0)
  {
    ERROR_LOG(m_logger) << "Error copy schedule, code = " << newId;
    failExit();
  }

  QTest::qWait(1000);
}

// ------------------------------------------------------------------------------
void IsmTests::checkSchedule()
{
  ERROR_LOG(m_logger) << "check instrumentation plan";

  m_dtc->waitForHistoricalDataMainSchedule();

  // using m_assetId as main schedule id
  InfrastructureManagement::MainSchedule ms = m_dtc->mainSchedule(m_assetId);

  DEBUG_LOG(m_logger) << "scheduleId = " << m_assetId;
  DEBUG_LOG(m_logger) << "ms.id() = " << ms.id;

  QList<MountingPointPlan> diff;
  bool ok = m_dtc->getScheduleDifferences(m_assetId, diff);

  if (ok)
    ERROR_LOG(m_logger) << "Instrumentation plan complete!";
  else
  {
    ERROR_LOG(m_logger) << "Instrumentation plan not complete !!!";
    for (const MountingPointPlan &mpp : qAsConst(diff))
      ERROR_LOG(m_logger) << "Diff - # mpp.structureElementId() = " << mpp.structureElementId;
  }

  QTest::qWait(1000);
}


// ************* MOUNTING POINT PLAN **********************************************************
// ------------------------------------------------------------------------------
void IsmTests::tryCreateMountingPointPlan()
{
  INFO_LOG(m_logger) << "trying to send MountingPointPlanCreateRequest";

  MountingPointPlanModifyRequest data;

  data.mountingPointScheduleId = m_assetId;
//  data.structureElementId(m_structureElementId);
//  data.mountingPointState(InfrastructureManagement::MountingPointState::Equipped);

  if (!m_ftc->mountingPointPlanModifyRequest(data, this))
  {
    ERROR_LOG(m_logger) << "Error requesting create data";
    failExit();
  }

  QTest::qWait(1000);

  data.mountingPointScheduleId = m_assetId;
//  data.structureElementId(m_mainStructureElementId);
//  data.mountingPointState(InfrastructureManagement::MountingPointState::Idle);

  if (!m_ftc->mountingPointPlanModifyRequest(data, this))
  {
    ERROR_LOG(m_logger) << "Error requesting create data";
    failExit();
  }

  QTest::qWait(1000);
}


//********************* GENERAL *************************************************
// ------------------------------------------------------------------------------
void IsmTests::onError(const QString &reason)
{
  ERROR_LOG(m_logger) << "Got Reply error: " << reason;
  failExit();
}

// ------------------------------------------------------------------------------
void IsmTests::onCreateReply(const Core::FunctionReplyObject &replyObject)
{
  if (replyObject.error())
  {
    onError(replyObject.translated());
    return;
  }
  INFO_LOG(m_logger) << "Got createReply with id " << replyObject.id()
                     << " and errorString " << replyObject.translated();
  QTimer::singleShot(0, qApp, &QCoreApplication::quit);
}

// ------------------------------------------------------------------------------
void IsmTests::onModifyReply(const Core::FunctionReplyObject &replyObject)
{
  m_replyFinished = true;
  if (replyObject.error())
  {
    onError(replyObject.translated());
    return;
  }
  INFO_LOG(m_logger) << "Got modifyRequest with id " << replyObject.id()
                     << " and errorString " << replyObject.translated();
  QTimer::singleShot(0, qApp, &QCoreApplication::quit);
}

// ------------------------------------------------------------------------------
void IsmTests::onRemoveReply(const Core::FunctionReplyObject &replyObject)
{
  if (replyObject.error())
  {
    onError(replyObject.translated());
    return;
  }
  INFO_LOG(m_logger) << "Got removeReply with id " << replyObject.id()
                     << " and errorString " << replyObject.translated();
  QTimer::singleShot(0, qApp, &QCoreApplication::quit);
}

// ------------------------------------------------------------------------------
void IsmTests::failExit()
{
  ERROR_LOG(m_logger) << "FAIL EXIT !";
  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")
                 , QLatin1String("0")
               } );

    addOption( { QStringList() << QLatin1String("a") << QLatin1String("assetId")
                 , QLatin1String("AssetId.MainScheduleId.")
                 , QLatin1String("Default: 0")
                 , QLatin1String("0")
               } );

    addOption( { QStringList() << QLatin1String("m") << QLatin1String("mainStructureElementId")
                 , QLatin1String("MainStructureElementId.")
                 , QLatin1String("Default: 0")
                 , QLatin1String("0")
               } );

    addOption( { QStringList() << QLatin1String("s") << QLatin1String("structureElementId")
                 , QLatin1String("StructureElementId.")
                 , QLatin1String("Default: 0")
                 , QLatin1String("0")
               } );

    addOption( { QStringList() << QLatin1String("i") << QLatin1String("indexNo")
                 , QLatin1String("IndexNo.")
                 , QLatin1String("Default: 0")
                 , QLatin1String("0")
               } );
  }

  int testId() const                  { return isSet(QLatin1String("t")) ? value(QLatin1String("t")).toInt() : -1; }
  int assetId() const                 { return isSet(QLatin1String("a")) ? value(QLatin1String("a")).toInt() : -1; }
  int mainStructureElementId() const  { return isSet(QLatin1String("m")) ? value(QLatin1String("m")).toInt() : -1; }
  int structureElementId() const      { return isSet(QLatin1String("s")) ? value(QLatin1String("s")).toInt() : -1; }
  int indexNo() const                 { return isSet(QLatin1String("i")) ? value(QLatin1String("i")).toInt() : -1; }
};

// ------------------------------------------------------------------
int main(int argc, char **argv)
{
  int iRet = -1;

  NGLCoreApplication app(argc, argv);
  app.createLogger("ISM", 0 );

  CmdLineParser   options;
  if (!options.init())
    return iRet;

  std::unique_ptr<InfrastructureManagement::IsmTests> IsmTests(new InfrastructureManagement::IsmTests);

  if(!IsmTests->init(options.domainId(), options.testId(), options.assetId(), options.mainStructureElementId(), options.structureElementId(), options.indexNo()))
    return iRet;

  QTimer::singleShot(0, IsmTests.get(), &InfrastructureManagement::IsmTests::startTest);

  STARTUP_LOG(app.baseLogger());

  app.exec();

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

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

  SHUTDOWN_LOG(app.baseLogger());

  return iRet;
}