/**
  * @RDE_HEADER@
  * Unittest
  * $Id$
  * $HeadURL$
  * $Author$
  */

#include "unit_test.h"

#include <nglapplication/nglcoreapplication.h>
#include <QtTest/QTest>
#include <QtTest/QSignalSpy>

#include <NGLLogger/NGLLoggerBootstrap.h>

#include <GeometryModel/geometry_model.h>
#include <GeometryModel/geometry_model_factory.h>

#include <GeometryModel/geometry_pixelTextBox.h>

#include <QJsonDocument>

#include <iostream>


using namespace SituationMap;


bool CheckSignal::isConnected()
{
  bool isConnected = isSignalConnected( QMetaMethod::fromSignal(&CheckSignal::mySignal) );
  return isConnected;
}


GeoModelUnitTest::GeoModelUnitTest() : m_logger(getLogger("GeometryModelUnitTest"))
{
}

void GeoModelUnitTest::init()
{
  qRegisterMetaType<GeometryModel::Node>("GeometryModel::Node");                               // not really working?
  qRegisterMetaType<SituationMap::GeometryModel::Node>("SituationMap::GeometryModel::Node");   // not really working?
  qRegisterMetaType<GeometryModel::Attribute>("GeometryModel::Attribute");
}


void GeoModelUnitTest::checkSignals1()
{
  GeometryModel                                   * geoModelW = GeometryModelFactory::singleton()->create();
  QList<QPointF>                                    vertexListW;
  QList<QPair<GeometryModel::Attribute, QVariant>>  attrListW;

  attrListW +=  QPair<GeometryModel::Attribute, QVariant>(GeometryModel::Attribute::Color,QVariant(QColor("red")));

  vertexListW << QPointF(1, 1) << QPointF(2,2);

  QVERIFY2( (geoModelW != nullptr), "Creating empty GeometryModel failed.");

  // connect signals...
  QSignalSpy spyTypeError(geoModelW,      &GeometryModel::typeError);
  QSignalSpy spyAttributeError(geoModelW, &GeometryModel::attributeError);
  QSignalSpy spyModelError(geoModelW,     &GeometryModel::modelError);
  QSignalSpy spyUserDataCleanup(geoModelW,&GeometryModel::userDataCleanup);
  QSignalSpy spyNodeCleanup(geoModelW,    &GeometryModel::nodeCleanup);
  QSignalSpy spyChanged(geoModelW,        &GeometryModel::changed);

  //
  // addPrimitive
  //

  // do operation :
  const GeometryModel::Node  & nodeWP = geoModelW->addPrimitive( GeometryModel::PrimitiveType::Line, vertexListW, attrListW );

  // verify, how often signals are emitted:
  QVERIFY2(spyTypeError.count()       == 0, "GeometryModel: signalCount failed, spyTypeError");
  QVERIFY2(spyAttributeError.count()  == 0, "GeometryModel: signalCount failed, spyAttributeError");
  QVERIFY2(spyModelError.count()      == 0, "GeometryModel: signalCount failed, spyModelError");
  QVERIFY2(spyUserDataCleanup.count() == 0, "GeometryModel: signalCount failed, spyUserDataCleanup");
  QVERIFY2(spyNodeCleanup.count()     == 0, "GeometryModel: signalCount failed, spyNodeCleanup");
  QVERIFY2(spyChanged.count()         == 1, "GeometryModel: signalCount failed, spyChanged");
  // : do operation

  //
  // setUserData
  //
  {
    // do operation :
    qWarning() << "setUserData...";
    spyTypeError.clear();spyAttributeError.clear();spyModelError.clear();spyUserDataCleanup.clear();spyNodeCleanup.clear();spyChanged.clear();
    geoModelW->setUserData( nodeWP, 4711 );
    QVERIFY2(spyTypeError.count()       == 0, "GeometryModel: signalCount failed, spyTypeError");
    QVERIFY2(spyAttributeError.count()  == 0, "GeometryModel: signalCount failed, spyAttributeError");
    QVERIFY2(spyModelError.count()      == 0, "GeometryModel: signalCount failed, spyModelError");
    QVERIFY2(spyUserDataCleanup.count() == 0, "GeometryModel: signalCount failed, spyUserDataCleanup");
    QVERIFY2(spyNodeCleanup.count()     == 0, "GeometryModel: signalCount failed, spyNodeCleanup");
    QVERIFY2(spyChanged.count()         == 1, "GeometryModel: signalCount failed, spyChanged");
    // : do operation
  }

  //
  // Transfer via QByteArray:
  //

  const QByteArray stringRep = geoModelW->toByteArray(); // qDebug() << stringRep;

  GeometryModel * geoModelR = GeometryModelFactory::singleton()->create();
  QVERIFY2(geoModelR, "Creating second GeometryModel failed.");

  {
    //
    // change to mode geoModelR
    //

    QSignalSpy spyTypeError(geoModelR,      &GeometryModel::typeError);
    QSignalSpy spyAttributeError(geoModelR, &GeometryModel::attributeError);
    QSignalSpy spyModelError(geoModelR,     &GeometryModel::modelError);
    QSignalSpy spyUserDataCleanup(geoModelR,&GeometryModel::userDataCleanup);
    QSignalSpy spyNodeCleanup(geoModelR,    &GeometryModel::nodeCleanup);
    QSignalSpy spyChanged(geoModelR,        &GeometryModel::changed);

    //
    // fromString
    //
    {
      // do operation :
      qWarning() << "fromString...";
      spyTypeError.clear();spyAttributeError.clear();spyModelError.clear();spyUserDataCleanup.clear();spyNodeCleanup.clear();spyChanged.clear();
      QVERIFY2( geoModelR->fromByteArray(stringRep)                     , "Building GeometryModel from String failed." );
      QVERIFY2(spyTypeError.count()       == 0, "GeometryModel: signalCount failed, spyTypeError");
      QVERIFY2(spyAttributeError.count()  == 0, "GeometryModel: signalCount failed, spyAttributeError");
      QVERIFY2(spyModelError.count()      == 0, "GeometryModel: signalCount failed, spyModelError");
      QVERIFY2(spyUserDataCleanup.count() == 0, "GeometryModel: signalCount failed, spyUserDataCleanup");
      QVERIFY2(spyNodeCleanup.count()     == 0, "GeometryModel: signalCount failed, spyNodeCleanup");
      QVERIFY2(spyChanged.count()         == 0, "GeometryModel: signalCount failed, spyChanged");                    // correct?
      // : do operation
    }


    //
    // removePrimitive
    //

    {
      geoModelR->enableUndo( true );
      geoModelR->startUndoBlock();

      // do operation :
      qWarning() << "removePrimitive...";
      spyTypeError.clear();spyAttributeError.clear();spyModelError.clear();spyUserDataCleanup.clear();spyNodeCleanup.clear();spyChanged.clear();
      geoModelR->removePrimitive( nodeWP );
      QVERIFY2(spyTypeError.count()       == 0, "GeometryModel: signalCount failed, spyTypeError");
      QVERIFY2(spyAttributeError.count()  == 0, "GeometryModel: signalCount failed, spyAttributeError");
      QVERIFY2(spyModelError.count()      == 0, "GeometryModel: signalCount failed, spyModelError");
      QVERIFY2(spyUserDataCleanup.count() == 1, "GeometryModel: signalCount failed, spyUserDataCleanup");
      QVERIFY2(spyNodeCleanup.count()     == 0, "GeometryModel: signalCount failed, spyNodeCleanup");
      QVERIFY2(spyChanged.count()         == 0, "GeometryModel: signalCount failed, spyChanged"); // see r45452, 'avoid invalid errorMsg'
      //QVERIFY2(spyChanged.count()         == 1, "GeometryModel: signalCount failed, spyChanged");


      // : do operation
    }
    geoModelR->endUndoBlock( QLatin1String("Remove Primitive") );


    //
    // undo
    //
    {
      geoModelR->enableUndo( true );
      geoModelR->startUndoBlock();

      // do operation :
      qWarning() << "undo...";
      spyTypeError.clear();spyAttributeError.clear();spyModelError.clear();spyUserDataCleanup.clear();spyNodeCleanup.clear();spyChanged.clear();
      geoModelR->undo();
      QVERIFY2(spyTypeError.count()       == 0, "GeometryModel: signalCount failed, spyTypeError");
      QVERIFY2(spyAttributeError.count()  == 0, "GeometryModel: signalCount failed, spyAttributeError");
      QVERIFY2(spyModelError.count()      == 0, "GeometryModel: signalCount failed, spyModelError");
      QVERIFY2(spyUserDataCleanup.count() == 0, "GeometryModel: signalCount failed, spyUserDataCleanup");
      QVERIFY2(spyNodeCleanup.count()     == 1, "GeometryModel: signalCount failed, spyNodeCleanup");
      QVERIFY2(spyChanged.count()         == 1, "GeometryModel: signalCount failed, spyChanged");
      // : do operation
    }
  }
} // GeoModelUnitTest::checkSignals1


void GeoModelUnitTest::checkSignals2()
{
  // create Reference model (...W)
  GeometryModel                                   * geoModelW = GeometryModelFactory::singleton()->create();
  QList<QPointF>                                    vertexListW;
  QList<QPair<GeometryModel::Attribute, QVariant>>  attrListW;

  attrListW +=  QPair<GeometryModel::Attribute, QVariant>(GeometryModel::Attribute::Color,QVariant(QColor("red")));
  vertexListW << QPointF(1, 1) << QPointF(2,2);

  geoModelW->addPrimitive( GeometryModel::PrimitiveType::Line, vertexListW, attrListW, 42 );
  // ==> root -> line42

  const GeometryModel::Node   & rootNode = geoModelW->getRootNode();
  const GeometryModel::Node   & nodeWP   = geoModelW->addPrimitive( GeometryModel::PrimitiveType::Line, vertexListW, attrListW, 815 );
  GeometryModel::Node        && groupWP  = geoModelW->createGroup( GeometryModel::NodeList() );
  // ==> root -> line42
  //          -> line815
  //          -> group

  QVERIFY2( groupWP.parentNode() == rootNode, "Group parent is not the root node." );


  QSignalSpy spyTypeError(geoModelW,      &GeometryModel::typeError);
  QSignalSpy spyAttributeError(geoModelW, &GeometryModel::attributeError);
  QSignalSpy spyModelError(geoModelW,     &GeometryModel::modelError);
  QSignalSpy spyUserDataCleanup(geoModelW,&GeometryModel::userDataCleanup);
  QSignalSpy spyNodeCleanup(geoModelW,    &GeometryModel::nodeCleanup);
  QSignalSpy spyChanged(geoModelW,        &GeometryModel::changed);

  //
  // movePrimitiveIntoGroup
  //
  {
    // do operation :
    qWarning() << "movePrimitiveIntoGroup...";
    spyTypeError.clear();spyAttributeError.clear();spyModelError.clear();spyUserDataCleanup.clear();spyNodeCleanup.clear();spyChanged.clear();
    geoModelW -> movePrimitiveIntoGroup( nodeWP, groupWP );
    QVERIFY2(spyTypeError.count()       == 0, "GeometryModel: signalCount failed, spyTypeError");
    QVERIFY2(spyAttributeError.count()  == 0, "GeometryModel: signalCount failed, spyAttributeError");
    QVERIFY2(spyModelError.count()      == 0, "GeometryModel: signalCount failed, spyModelError");
    QVERIFY2(spyUserDataCleanup.count() == 0, "GeometryModel: signalCount failed, spyUserDataCleanup");
    QVERIFY2(spyNodeCleanup.count()     == 0, "GeometryModel: signalCount failed, spyNodeCleanup");
    QVERIFY2(spyChanged.count()         == 1, "GeometryModel: signalCount failed, spyChanged");
    // : do operation
  }
  // ==> root -> line42
  //          -> group -> line815



  //
  // createGroup
  //
  // do operation :
  qWarning() << "createGroup...";
  spyTypeError.clear();spyAttributeError.clear();spyModelError.clear();spyUserDataCleanup.clear();spyNodeCleanup.clear();spyChanged.clear();
  GeometryModel::Node && group  = geoModelW->createGroup( GeometryModel::NodeList() );
  QVERIFY2(spyTypeError.count()       == 0, "GeometryModel: signalCount failed, spyTypeError");
  QVERIFY2(spyAttributeError.count()  == 0, "GeometryModel: signalCount failed, spyAttributeError");
  QVERIFY2(spyModelError.count()      == 0, "GeometryModel: signalCount failed, spyModelError");
  QVERIFY2(spyUserDataCleanup.count() == 0, "GeometryModel: signalCount failed, spyUserDataCleanup");
  QVERIFY2(spyNodeCleanup.count()     == 0, "GeometryModel: signalCount failed, spyNodeCleanup");
  QVERIFY2(spyChanged.count()         == 1, "GeometryModel: signalCount failed, spyChanged");
  // : do operation


  //
  // createGroup
  //
  {
    // do operation :
    qWarning() << "deleteGroup...";
    spyTypeError.clear();spyAttributeError.clear();spyModelError.clear();spyUserDataCleanup.clear();spyNodeCleanup.clear();spyChanged.clear();
    geoModelW -> deleteGroup( group );
    QVERIFY2(spyTypeError.count()       == 0, "GeometryModel: signalCount failed, spyTypeError");
    QVERIFY2(spyAttributeError.count()  == 0, "GeometryModel: signalCount failed, spyAttributeError");
    QVERIFY2(spyModelError.count()      == 0, "GeometryModel: signalCount failed, spyModelError");
    QVERIFY2(spyUserDataCleanup.count() == 0, "GeometryModel: signalCount failed, spyUserDataCleanup");
    QVERIFY2(spyNodeCleanup.count()     == 0, "GeometryModel: signalCount failed, spyNodeCleanup");
    QVERIFY2(spyChanged.count()         == 1, "GeometryModel: signalCount failed, spyChanged");
    // : do operation
  }

  qDebug() << geoModelW->toByteArray();
  delete geoModelW;

} // GeoModelUnitTest::checkSignals2


void GeoModelUnitTest::checkCoordinatePrecision()
{
  GeometryModel                                   * geoModel = GeometryModelFactory::singleton()->create();
  QList<QPointF>                                    vertexList;
  QList<QPair<GeometryModel::Attribute, QVariant>>  attrList;
  QPointF                                           p1( 0.00913852259360125798040230648137, 0.92502450355699467576955610729896 );
  QPointF                                           p2( 0.00913852261853453300889272900885, 0.92502450357271836272445997736134 ); // distance to p1 is 0.0001 mm in geographic coordinates

  vertexList << p1 << p2;

  QVERIFY2( (geoModel != nullptr), "Creating empty GeometryModel failed." );

  const GeometryModel::Node  & node = geoModel->addPrimitive( GeometryModel::PrimitiveType::Line, vertexList, attrList );

  vertexList = geoModel->getPrimitivePoints( node );  // read coordinates back from model

  QVERIFY2((vertexList.size() == 2), "Unexpected size of coordinate list after read." );

  const QPointF & v1 = vertexList[0];
  const QPointF & v2 = vertexList[1];

  QVERIFY2(((p1 == v1) && (p2 == v2) && (v1 != v2)), "Precision test failed." );

} // GeoModelUnitTest::checkCoordinatePrecision


void GeoModelUnitTest::createModelWithLine()
{
  GeometryModel                                   * geoModelW = GeometryModelFactory::singleton()->create();
  QList<QPointF>                                    vertexListW;
  QList<QPair<GeometryModel::Attribute, QVariant>>  attrListW;

  attrListW +=  QPair<GeometryModel::Attribute, QVariant>(GeometryModel::Attribute::Color,QVariant(QColor("red")));

  vertexListW << QPointF(1, 1) << QPointF(2,2);

  QVERIFY2( (geoModelW != nullptr), "Creating empty GeometryModel failed.");

  const GeometryModel::Node  & nodeWP = geoModelW->addPrimitive( GeometryModel::PrimitiveType::Line, vertexListW, attrListW );

  geoModelW->setUserData( nodeWP, 4711 );

  const QByteArray stringRep = geoModelW->toByteArrayDebug(); // qDebug() << stringRep;

  const GeometryModel::Node    & nodeW     = geoModelW->getRootNode();
  GeometryModel::PrimitiveType   nodeTypeW = geoModelW->getType( nodeW );

  //
  // transfer via string:
  //

  GeometryModel * geoModelR = GeometryModelFactory::singleton()->create();

  QVERIFY2( (GeometryModel::PrimitiveType::RootNode == nodeTypeW), "Unexpected root node type.");
  QVERIFY2( (geoModelR != nullptr)                               , "Creating second GeometryModel failed.");
  QVERIFY2( geoModelR->fromByteArrayDebug(stringRep)             , "Building GeometryModel from String failed." );

  const GeometryModel::Node    & nodeR     = geoModelR->getRootNode();
  GeometryModel::PrimitiveType   nodeTypeR = geoModelR->getType( nodeR );

  QVERIFY2( (nodeTypeR == nodeTypeW)        , "Second GeometryModel differs from first one.");

  const GeometryModel::NodeList & nodeList = geoModelR->getGroupPrimitives( nodeR );

  QVERIFY2( nodeList.size() == 1            , "Unexpected size of root node list.");

  const GeometryModel::Node & nodeRP = nodeList.first();

  QVERIFY2( (geoModelR->getType(nodeRP) == GeometryModel::PrimitiveType::Line), "Unexpected primitive type.");

  const QList<QPointF>  & vertexListR = geoModelR->getPrimitivePoints(nodeRP);

  QVERIFY2( geoModelR->hasAttribute(nodeRP,GeometryModel::Attribute::Color), "Attribute color is missing." );

  QColor color = geoModelR->getAttribute<QColor,GeometryModelQDom>(nodeRP,GeometryModel::Attribute::Color);

  QVERIFY2( color == QColor("red")                , "Attribute color has wrong value." );
  QVERIFY2( geoModelR->getUserData(nodeRP) == 4711, "UserData has wrong value." );

  QVERIFY2( ((vertexListR[0] == QPointF(1,1)) && (vertexListR[1] == QPointF(2,2))), "Wrong coordinate values." );
  QVERIFY2( nodeW.hasChildNodes()                                                 , "Wrong return value of Node::hasChildNodes()" );

  const GeometryModel::Node & lineNode = nodeW.firstChildNode();

  QVERIFY2( geoModelR->getUserData(lineNode) == 4711, "Wrong return value of Node::firstChildNode()." );

  delete geoModelW;
  delete geoModelR;
} // GeoModelUnitTest::createModelWithLine()


void GeoModelUnitTest::createModelWithGroup()
{

  // create Reference model (...W)
  GeometryModel                                   * geoModelW = GeometryModelFactory::singleton()->create();
  QList<QPointF>                                    vertexListW;
  QList<QPair<GeometryModel::Attribute, QVariant>>  attrListW;

  attrListW +=  QPair<GeometryModel::Attribute, QVariant>(GeometryModel::Attribute::Color,QVariant(QColor("red")));
  vertexListW << QPointF(1, 1) << QPointF(2,2);

  geoModelW->addPrimitive( GeometryModel::PrimitiveType::Line, vertexListW, attrListW, 42 );
  // ==> root -> line42

  const GeometryModel::Node   & rootNode = geoModelW->getRootNode();
  const GeometryModel::Node   & nodeWP   = geoModelW->addPrimitive( GeometryModel::PrimitiveType::Line, vertexListW, attrListW, 815 );
  GeometryModel::Node        && groupWP  = geoModelW->createGroup( GeometryModel::NodeList() );
  // ==> root -> line42
  //          -> line815
  //          -> group

  QVERIFY2( groupWP.parentNode() == rootNode, "Group parent is not the root node." );

  geoModelW -> movePrimitiveIntoGroup( nodeWP, groupWP );
  // ==> root -> line42
  //          -> group -> line815

  const QByteArray stringRep = geoModelW->toByteArrayDebug();  qDebug() << stringRep;

  delete geoModelW;

  //
  // Rebuild model
  //
  {
    GeometryModel * geoModelRebuilded = GeometryModelFactory::singleton()->create();
    QVERIFY2( geoModelRebuilded->fromByteArrayDebug(stringRep), "Building GeometryModel from String failed." );

    qDebug() << geoModelRebuilded->toByteArray();

    // compare string:
    QVERIFY2( (stringRep == geoModelRebuilded->toByteArrayDebug()), "GeometryModel stringCompare failed." );


    // Find primitive:
    const GeometryModel::Node & lineNode42 = geoModelRebuilded -> findPrimitive( 42 );
    QVERIFY2( lineNode42.isValid(), "GeometryModel::findPrimitive failed." );

    const GeometryModel::Node & lineNode815 = geoModelRebuilded -> findPrimitive( 815 );
    QVERIFY2( lineNode815.isValid(), "GeometryModel::findPrimitive failed." );


    // check isInGroup:
    const GeometryModel::Node & groupNode = geoModelRebuilded->isInGroup( lineNode815 );
    QVERIFY2( groupNode.isValid(), "GeometryModel::isInGroup failed." );

    const GeometryModel::Node & groupNode42 = geoModelRebuilded -> isInGroup( lineNode42 );
    QVERIFY2( groupNode42.isValid() == false, "GeometryModel::isInGroup failed." );

    // check isRootNode:

    QVERIFY2( (groupNode42.isRootNode() ==  false)                    , "GeometryModel::Node::isRootNode for id=42 returns wrong value" );

    QVERIFY2( (!geoModelRebuilded->isInGroup(lineNode815).isRootNode()), "GeometryModel::Node::isRootNode for id=815 returns wrong value" );

    delete geoModelRebuilded;
  }

} // GeoModelUnitTest::createModelWithGroup


void GeoModelUnitTest::createAndDeletePrimitives()
{
  GeometryModel * geoModel = GeometryModelFactory::singleton()->create();
  if (geoModel == nullptr) return;

  const GeometryModel::Node                       & rootNode = geoModel->getRootNode();
  QList<QPointF>                                    vertexList;
  QList<QPair<GeometryModel::Attribute, QVariant>>  attrList;

  attrList +=  QPair<GeometryModel::Attribute, QVariant>(GeometryModel::Attribute::Color,QVariant(QColor("red")));

  vertexList << QPointF(1, 1) << QPointF(2,2);

  geoModel->addPrimitive( GeometryModel::PrimitiveType::Line, vertexList, attrList, 42 );

  // qDebug() << geoModel->toString();

  const GeometryModel::Node & group = geoModel->createGroup( GeometryModel::NodeList() );

  geoModel->setUserData( group, 8888 );

  QVERIFY2( group.parentNode() == rootNode          , "Group parent is not the root node." );
  QVERIFY2( !geoModel->findPrimitive(8888).isValid(), "findPrimitive returns group node"   );

  const GeometryModel::Node & lineNode = geoModel->findPrimitive(42);
  QVERIFY2( lineNode.isValid(), "findPrimitive failed to find primitive" );

  geoModel->movePrimitiveIntoGroup( lineNode, group );

  geoModel->enableUndo( true );
  geoModel->startUndoBlock();
  geoModel->removePrimitive( lineNode );
  geoModel->endUndoBlock( QLatin1String("Remove Primitive") );

  QVERIFY2( !geoModel->findPrimitive(42).isValid(), "deleted primitive found." );

} // GeoModelUnitTest::createAndDeletePrimitives


void GeoModelUnitTest::createAndDeleteGroups()
{
  GeometryModel * geoModel = GeometryModelFactory::singleton()->create();
  if (geoModel == nullptr) return;

  const QByteArray & modelXML = geoModel->toByteArray();

  const GeometryModel::Node                       & rootNode = geoModel->getRootNode();
  QList<QPointF>                                    vertexList;
  QList<QPair<GeometryModel::Attribute, QVariant>>  attrList;

  attrList +=  QPair<GeometryModel::Attribute, QVariant>(GeometryModel::Attribute::Color,QVariant(QColor("red")));

  vertexList << QPointF(1, 1) << QPointF(2,2);

  geoModel->addPrimitive( GeometryModel::PrimitiveType::Line, vertexList, attrList, 42 );

  // qDebug() << geoModel->toString();

  const GeometryModel::Node & group = geoModel->createGroup( GeometryModel::NodeList() );

  geoModel->setUserData( group, 8888 );

  QVERIFY2( group.parentNode() == rootNode          , "Group parent is not the root node." );
  QVERIFY2( !geoModel->findPrimitive(8888).isValid(), "findPrimitive returns group node"   );

  const GeometryModel::Node & lineNode = geoModel->findPrimitive(42);
  QVERIFY2( lineNode.isValid(), "findPrimitive failed to find primitive" );

  geoModel->movePrimitiveIntoGroup( lineNode, group );

  geoModel -> deleteGroup( group );

  // qDebug() << geoModel->toString();

  QVERIFY2( geoModel->toByteArray() == modelXML, "delete group failed." );

} // GeoModelUnitTest::createAndDeleteGroups


void GeoModelUnitTest::checkUndo()
{
  GeometryModel * geoModel = GeometryModelFactory::singleton()->create();
  if (geoModel == nullptr) return;

  geoModel->enableUndo( true );

  const QByteArray geoModelClean = geoModel->toByteArray();

  QList<QPointF>                                    vertexList;
  QList<QPair<GeometryModel::Attribute, QVariant>>  attrList;

  attrList +=  QPair<GeometryModel::Attribute, QVariant>(GeometryModel::Attribute::Color,QVariant(QColor("red")));

  vertexList << QPointF(1, 1) << QPointF(2,2);

  geoModel->addPrimitive( GeometryModel::PrimitiveType::Line, vertexList, attrList, 42 );

  GeometryModel::Node         group    = geoModel->createGroup( GeometryModel::NodeList() );
  const GeometryModel::Node & lineNode = geoModel->findPrimitive(42);

  QVERIFY2( group.isValid()   , "Group node isn't valid." );
  QVERIFY2( lineNode.isValid(), "Line node isn't valid." );

  geoModel->movePrimitiveIntoGroup( lineNode, group );

  const QByteArray geoModelXml = geoModel->toByteArray();

  geoModel->startUndoBlock();
  geoModel->removePrimitive( lineNode );
  geoModel->endUndoBlock( QLatin1String("Remove Primitive") );

  geoModel->undo();

  group = geoModel->isInGroup( geoModel->findPrimitive(42) );

  QVERIFY2( geoModel->toByteArray() == geoModelXml, "Undo doesn't restore deleted nodes." );
  QVERIFY2( group.isValid()                    , "Group node isn't valid after undo." );

  geoModel -> deleteGroup( group );

  // qDebug() << geoModelClean;
  // qDebug() << geoModel->toString();

  QVERIFY2( geoModel->toByteArray() == geoModelClean, "Delete group failed." );

} // GeoModelUnitTest::checkUndo


void GeoModelUnitTest::checkMatrixTransform()
{
  GeometryModel * geoModel = GeometryModelFactory::singleton()->create();
  if (geoModel == nullptr) return;

  geoModel->enableUndo( true );

  QList<QPointF>                                    vertexList;
  QList<QPair<GeometryModel::Attribute, QVariant>>  attrList;

  attrList +=  QPair<GeometryModel::Attribute, QVariant>(GeometryModel::Attribute::Color,QVariant(QColor("red")));

  vertexList << QPointF(1, 1) << QPointF(2,2);

  const GeometryModel::Node & lineNode = geoModel->addPrimitive( GeometryModel::PrimitiveType::Line, vertexList, attrList, 42 );
  const GeometryModel::Node & group    = geoModel->createGroup( GeometryModel::NodeList() );

  geoModel->movePrimitiveIntoGroup( lineNode, group );

  geoModel->startUndoBlock();
  geoModel->translateNode( group, 500, 1000 );
  vertexList = geoModel->getPrimitivePoints( lineNode );
  QVERIFY2( ((vertexList[0].x() == 501) && (vertexList[0].y() == 1001) && (vertexList[1].x() == 502) && (vertexList[1].y() == 1002)), "TranslateNode failed." );

  geoModel->scaleNode( group, 0.5, -0.5 );
  geoModel->scaleNode( group, 4  ,  4   );

  vertexList = geoModel->getPrimitivePoints( lineNode );

  QVERIFY2( ((vertexList[0].x() == 500.5) && (vertexList[0].y() == 1002.5) && (vertexList[1].x() == 502.5) && (vertexList[1].y() == 1000.5)), "ScaleNode failed." );

  geoModel->rotateNode(group,90);

  vertexList = geoModel->getPrimitivePoints( lineNode );

  QVERIFY2( ((vertexList[0].x() == 500.5) && (vertexList[0].y() == 1000.5) && (vertexList[1].x() == 502.5) && (vertexList[1].y() == 1002.5)), "RotateNode failed." );

  geoModel->endUndoBlock( QLatin1String("Move and scale primitive node") );

} // GeoModelUnitTest::checkMatrixTransform


void GeoModelUnitTest::checkMerge()
{
  GeometryModel * geoModel = GeometryModelFactory::singleton()->create();
  if (geoModel == nullptr) return;

  geoModel->enableUndo( true );

  QList<QPointF>                                    vertexList;
  QList<QPair<GeometryModel::Attribute, QVariant>>  attrList;

  attrList +=  QPair<GeometryModel::Attribute, QVariant>(GeometryModel::Attribute::Color,QVariant(QColor("red")));

  vertexList << QPointF(1, 1) << QPointF(2,2);

  const GeometryModel::Node & lineNode = geoModel->addPrimitive( GeometryModel::PrimitiveType::Line, vertexList, attrList, 42 );
  const GeometryModel::Node & group    = geoModel->createGroup( GeometryModel::NodeList() );

  geoModel->movePrimitiveIntoGroup( lineNode, group );

  GeometryModel * geoModel2Merge = GeometryModelFactory::singleton()->create();
  if (geoModel2Merge == nullptr) return;

  geoModel2Merge->enableUndo( true );

  geoModel2Merge->movePrimitiveIntoGroup( geoModel2Merge->addPrimitive( GeometryModel::PrimitiveType::Line, vertexList, attrList, 815 )
                                        , geoModel2Merge->createGroup( GeometryModel::NodeList() ) );

  geoModel->merge( geoModel2Merge->getRootNode() );

  // qDebug() << geoModel->toString();

  QVERIFY2(  geoModel->findPrimitive(42).isValid(), "Primitive node (id=42) is missing." );
  QVERIFY2(  geoModel->findPrimitive(815).isValid(), "Primitive node (id=815) is missing." );

} // GeoModelUnitTest::checkMerge


void GeoModelUnitTest::checkDictionarySymbol()
{
  GeometryModel * geoModel = GeometryModelFactory::singleton()->create();
  if (geoModel == nullptr) return;

  geoModel->enableUndo( true );

  QList<QPointF>                                    vertexList;
  QList<QPair<GeometryModel::Attribute, QVariant>>  attrList;

  attrList +=  QPair<GeometryModel::Attribute, QVariant>(GeometryModel::Attribute::SIDC,QVariant(QLatin1String("GFMPOGL---")));

  vertexList << QPointF(0, 1) << QPointF(20,1) << QPointF(20,5);
  geoModel->addPrimitive( GeometryModel::PrimitiveType::DictionarySymbol, vertexList, attrList, 42 );

  const GeometryModel::Node & symbolNode = geoModel->findPrimitive(42);
  vertexList                             = geoModel->getPrimitivePoints( symbolNode );

  // qDebug() << geoModel->toString();

  QVERIFY2( symbolNode.isValid()               , "DictionarySymbol node isn't valid."  );
  const QString attr = geoModel->getAttribute(symbolNode, GeometryModel::Attribute::SIDC).toString();
  QVERIFY2( attr == QLatin1String("GFMPOGL---"), "Wrong SIDC at dictionary symbol."    );
  QVERIFY2( vertexList.size() == 3             , "Wrong size of primitive point list." );

  QVERIFY2(vertexList[0] == QPointF( 0, 1), "Wrong coordinate." );
  QVERIFY2(vertexList[1] == QPointF(20, 1), "Wrong coordinate." );
  QVERIFY2(vertexList[2] == QPointF(20, 5), "Wrong coordinate." );
}

void GeoModelUnitTest::checkPixelTextBoxData()
{
  // toJsonStr:
  SituationMap::PixelTextBoxData inData;
  inData.m_htmlText        = QStringLiteral("meinText");;
  inData.m_backgroundColor = QColor(Qt::green);
  inData.m_position        = QPoint(11, 22);
  inData.m_size            = QSize(555, 666);

  QString jsonStr = inData.toJsonStr();
  qCritical() << " jsonStr: '" << jsonStr << "'" << " size=" << jsonStr.size();

  QVERIFY2(jsonStr.size() == 184, "Error at pixelTextBoxToJson: wrong size ");

  // fromJsonStr:
  {
    PixelTextBoxData read =  PixelTextBoxData::fromJsonStr(jsonStr);
    QVERIFY2(read.m_htmlText        == inData.m_htmlText       , "Error at pixelTextBoxFromJson: htmlText ");
    QVERIFY2(read.m_backgroundColor == inData.m_backgroundColor, "Error at pixelTextBoxFromJson: backgroundColor ");
    QVERIFY2(read.m_position        == inData.m_position,        "Error at pixelTextBoxFromJson: position ");
    QVERIFY2(read.m_size            == inData.m_size,            "Error at pixelTextBoxFromJson: m_size ");

    qDebug() << read.m_position;
    qDebug() << read.m_size;
  }
}

void GeoModelUnitTest::checkPixelTextBoxDataCont()
{
  SituationMap::PixelTextBoxData inData1(QStringLiteral("meinText11"), QColor(Qt::red));
  SituationMap::PixelTextBoxData inData2(QStringLiteral("meinText22"), QColor(Qt::green));

  QVector<PixelTextBoxData> vec = {inData1, inData2};

  // debug
  const QJsonObject &jObj = PixelTextBoxData::pixelTextBoxContainerToJson(vec);
  qDebug() << " pixelTextBoxContainerToJson =" <<  QJsonDocument(jObj).toJson().toStdString().c_str();

  // toJson/fromJson:
  {
    QVector<PixelTextBoxData> read = PixelTextBoxData::pixelTextBoxContainerFromJson(jObj);
    qCritical() << " pixelTextBoxContainerFromJson: read.size() =" <<  read.size();
    QVERIFY2(read.size() == 2       , "Error at pixelTextBoxContainerFromJson: size");
    QVERIFY2(read.first() == inData1, "Error at pixelTextBoxContainerFromJson: inData1");
  }

  // toJson/fromJson STR:
  {
    const QString &strRef = PixelTextBoxData::pixelTextBoxContainerToJsonStr(vec, QJsonDocument::JsonFormat::Compact);
    qCritical() << " pixelTextBoxContainerToJsonStr Compact: " <<  strRef;
    {
      QVector<PixelTextBoxData> read = PixelTextBoxData::pixelTextBoxContainerFromJsonStr(strRef);
      qCritical() << " pixelTextBoxContainerFromJsonStr: read.size() =" <<  read.size();

      QVERIFY2(read.size() == 2       , "Error at pixelTextBoxContainerFromJsonStr: size");
      QVERIFY2(read.first() == inData1, "Error at pixelTextBoxContainerFromJsonStr: inData1");
    }
  }
}

void GeoModelUnitTest::checkMetaData()
{
  // test GeometryModel::Attributes
  // introduced for storing "MetaPixelBasedTextBoxes" (multiple):

  GeometryModel * geoModel = GeometryModelFactory::singleton()->create();
  if (geoModel == nullptr) return;

  geoModel->enableUndo(true);

  const QString &metaData = QStringLiteral("MyMetaDataString");

  QVector<SituationMap::GeometryModel::Attribute> attCont =
  {
    GeometryModel::Attribute::MetaDataTitle,
        GeometryModel::Attribute::MetaDataAuthor,
        GeometryModel::Attribute::MetaDataDate,
        GeometryModel::Attribute::MetaDataDesciption,
  };

  for (auto att : attCont)
  {
    geoModel->setModelAttribute(att, metaData);
    {
      const QString get = geoModel->getModelAttribute(att).toString();
      QVERIFY2(get == metaData, "set get mismatch");
    }
    geoModel->setModelAttribute(att, {});
  }

  SituationMap::GeometryModel::Attribute att;
  {
    att = GeometryModel::Attribute::MetaDataMinScale;
    geoModel->setModelAttribute(att, 1234);
    const int get = geoModel->getModelAttribute(att).toInt();
    QVERIFY2(get == 1234, "set get mismatch MetaDataMinScale");
  }
  {
    att = GeometryModel::Attribute::MetaDataMaxScale;
    geoModel->setModelAttribute(att, 123456);
    const int get = geoModel->getModelAttribute(att).toInt();
    QVERIFY2(get == 123456, "set get mismatch MetaDataMaxScale");
  }

  // GeometryModel::Attribute::MetaPixelBasedTextBoxes;
  {
    const QString dummyStrIn = QStringLiteral("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\" \"http://www.w3.1111...");

    // save in model:
    geoModel->setModelAttribute(GeometryModel::Attribute::MetaPixelBasedTextBoxes, dummyStrIn);

    {
      const QString read = geoModel->getModelAttribute(GeometryModel::Attribute::MetaPixelBasedTextBoxes).toString();
      QVERIFY2(dummyStrIn == read, "Modelerror set/getPixelTextData");
    }
  }
}


int main(int argc, char *argv[])
{
  NGLCoreApplication app(argc, argv);
  app.createLogger("GeometryModelUnitTest", "log4cxxGeometryModelUnitTest.props");

  QSharedPointer<GeoModelUnitTest> tc = QSharedPointer<GeoModelUnitTest>( new GeoModelUnitTest() );
  int retCode = QTest::qExec(tc.data(), argc, argv);

  return retCode;
} // main(int argc, char *argv[])