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

// Own
#include "map_initializer.h"
#include "grid.h"

#include <Map/viewshed.h>
#include <Map/situation_map_utils.h>
#include <Map/abstract_map_object.h>

#include <Rubberbands/rubberband_factory.h>
#include <Rubberbands/event_mouse_navigator.h>
#include <LtsCoordTrans/lts_coord_trans.h>

#include <arcgis/arcgisversion.h>  // This file is created by RME, not ESRI

#include <QtCore/QCoreApplication>
#include <QtCore/QJsonDocument>
#include <QtCore/QJsonObject>
#include <QtCore/QJsonArray>
#include <QNetworkProxy>
#include <QtWidgets/QMessageBox>
#include <utility>


//----------------------------------------------------------------------------
namespace SituationMap
{

//----------------------------------------------------------------------------
BaseUrl::BaseUrl(const QString &url, double minScale, double maxScale)
  : m_url(url), m_minScale(minScale), m_maxScale(maxScale)
{}

BaseUrl BaseUrl::read(const QJsonObject &json)
{
  BaseUrl baseUrl;
  baseUrl.m_url            = json[QStringLiteral("url")].toString();
  baseUrl.m_minScale       = json[QStringLiteral("minScale")].toDouble();
  baseUrl.m_maxScale       = json[QStringLiteral("maxScale")].toDouble();

  if (json.contains(QStringLiteral("altitudeOffset")))
    baseUrl.m_altitudeOffset = json[QStringLiteral("altitudeOffset")].toDouble();
  else
    baseUrl.m_altitudeOffset = 0.0;

  // tbc !!!

  return baseUrl;
}

QJsonObject BaseUrl::toJsonObject() const
{
  QJsonObject json;
  json[QStringLiteral("url")]            = m_url;
  json[QStringLiteral("minScale")]       = m_minScale;
  json[QStringLiteral("maxScale")]       = m_maxScale;

  if (!qFuzzyIsNull(m_altitudeOffset))
  json[QStringLiteral("altitudeOffset")] = m_altitudeOffset;

  // tbc !!!

  return json;
}
//----------------------------------------------------------------------------


//----------------------------------------------------------------------------
// MapSettingsJson

static inline QJsonArray toJsonArray(const QVector<BaseUrl> &urls)
{
  QJsonArray jArray;
  for (const BaseUrl &baseUrl : urls)
    jArray.append(baseUrl.toJsonObject());
  return jArray;
}

static inline QVector<BaseUrl> fromJsonArray(const QJsonValue &val)
{
  const QJsonArray &arr = val.toArray();
  QVector<BaseUrl> urls;
  urls.reserve(arr.size());
  for (const auto &item : arr)
    urls.append(BaseUrl::read(item.toObject()));

  return urls;
}

QJsonObject MapSettingsJson::toJsonObject() const
{
  QJsonObject obj;

  obj[QLatin1String("mapUrls")] = toJsonArray(m_mapUrls);
  obj[QLatin1String("sceneUrls")] = toJsonArray(m_sceneUrls);
  obj[QLatin1String("sceneObjectUrls")] = toJsonArray(m_sceneObjectUrls);
  obj[QLatin1String("elevationUrls")] = toJsonArray(m_elevationUrls);

  return obj;
}

bool MapSettingsJson::fromJsonObject(const QJsonObject &json)
{
  m_mapUrls = fromJsonArray(json[QLatin1String("mapUrls")]);
  m_sceneUrls = fromJsonArray(json[QLatin1String("sceneUrls")]);
  m_sceneObjectUrls = fromJsonArray(json[QLatin1String("sceneObjectUrls")]);
  m_elevationUrls = fromJsonArray(json[QLatin1String("elevationUrls")]);

  return true;
}
//----------------------------------------------------------------------------



MapInitializer::MapInitializer(Map           &map,
                               MapSettings   &mapSettings,
                               const QString &debugName,
                               QObject       *parent)
  : QObject(parent)
  , m_map(map)
  , m_mapSettings(mapSettings)
  , m_debugName(debugName)
  , m_logger(getLogger("MapInitializer"))
{
  TRACE_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " START";

  connect(&m_map, &SituationMap::Map::mapReady, this, &MapInitializer::onMapReady);

  TRACE_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " END";
}

void MapInitializer::setMapSettingsJson(const MapSettingsJson &mapSettingJson)
{
  m_mapSettingJson = mapSettingJson;
}

MapInitializer::~MapInitializer()
{
  TRACE_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " START";
  TRACE_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " END";
}

QString MapInitializer::filename()    const { return m_mapSettings.filename();    }
bool    MapInitializer::hasErrors()   const { return m_mapSettings.hasErrors();   }

bool    MapInitializer::exists()      const { return m_mapSettings.exists();      }
bool    MapInitializer::accessError() const { return m_mapSettings.accessError(); }
bool    MapInitializer::formatError() const { return m_mapSettings.formatError(); }


bool MapInitializer::initMap(Mode mapMode)
{
  TRACE_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " START"
                      << " mapMode=" << mapMode;

  m_mapMode = mapMode;

  QString job;
  bool success = true;

  job = QLatin1String("applyLicense");
  if (applyLicense())
    INFO_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
  else
  {
    FATAL_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";

    QMessageBox::critical(nullptr, tr("Apply License"), tr("ESRI License no valid"));
    QCoreApplication::quit();

    return false;
  }

#if ACRGIS_VERSION >= 0x640700 // 100.7.0 / Update 7
  job = QLatin1String("applyNetworkCache");
  if (applyNetworkCache())
    INFO_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
  else
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
    success = false;
  }
#endif // ACRGIS_VERSION

  job = QLatin1String("setSymbologyType");
  if (setSymbologyType())
    DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
  else
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
    success = false;
  }

  job = QLatin1String("setBasemapLayernamePrefix");
  if (setBasemapLayernamePrefix())
    DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
  else
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
    success = false;
  }

  job = QLatin1String("setParticipantLayername");
  if (setParticipantLayername())
    DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
  else
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
    success = false;
  }

  job = QLatin1String("map.init");
  if (! m_map.init(m_mapMode))
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
    success = false;
  }

  // DDS, LocalFile or ...
  if (!initializeBasemaps(mapMode))
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
    success = false;
  }
  // DDS, LocalFile or ...


  // elevation:
  job = QLatin1String("initializeElevationSources");
  if (initializeElevationSources())
    DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
  else
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
    success = false;
  }


  if (m_mapMode == Mode::Mode_3D)
  {
    // Objects (like buildings):
    // load from QSetting _OR_ from Dds/Json
    if (m_mapSettingJson.getSceneObjectUrls().isEmpty())
    {
      success = initializeSceneObjectLayers();
    } else {
      success = initializeSceneObjectLayersJson();
    }
  } // if (m_mapMode == Mode::Mode_3D)



  job = QLatin1String("initialzeInitialViewpoint");
  if (initialzeInitialViewpoint())
    DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
  else
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
    success = false;
  }

  // load to call 'setMap' and start Esri's cascading load dependecies...
  INFO_LOG(m_logger) << LOGFUNCTION << " load";
  m_map.load();


  job = QLatin1String("initializeOperationalLayers");
  if (initializeOperationalLayers())
    DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
  else
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
    success = false;
  }

  if (m_mapMode == Mode::Mode_3D)
  {

    job = QLatin1String("initializeUniqueValueRendererForCubes");
    if (initializeUniqueValueRendererForCubes())
      DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
    else
    {
      ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
      success = false;
    }
  }


  job = QLatin1String("initializeExtraSymbolDirectory");
  if (initializeExtraSymbolDirectory())
    DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
  else
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
    success = false;
  }


  job = QLatin1String("initializeGrid");
  if (initializeGrid())
    DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
  else
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
    success = false;
  }


  job = QLatin1String("initializeAnimations");
  if (initializeAnimations())
    DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
  else
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
    success = false;
  }


  job = QLatin1String("initializeObjectFactory");
  if (initializeObjectFactory())
    DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
  else
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
    success = false;
  }


  job = QLatin1String("setObjectContainer");
  if (setObjectContainer())
    DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
  else
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
    success = false;
  }


  job = QLatin1String("initializeCoordTranslationFunctor");
  if (initializeCoordTranslationFunctor())
    DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
  else
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
    success = false;
  }

  job = QLatin1String("initializeRubberFactory");
  if (initializeRubberFactory())
    DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
  else
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
    success = false;
  }



  job = QLatin1String("initializeMapWidgets");
  if (initializeMapWidgets())
    DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
  else
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
    success = false;
  }


  job = QLatin1String("initializeSideBar");
  if (initializeSideBar())
    DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
  else
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
    success = false;
  }

  job = QLatin1String("setViewshedUrl");
  if (setViewshedUrl())
    DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
  else
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
    success = false;
  }


  TRACE_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " " << " END";
  return success;
}
//----------------------------------------------------------------------------


//----------------------------------------------------------------------------
bool MapInitializer::applyLicense()
{
  const QString &licStr                 = m_mapSettings.licenseStr();
  const QStringList &licenseExtensions  = m_mapSettings.licenseExtensions();
  return SituationMap::Map::applyLicense(licStr, licenseExtensions);
}

//----------------------------------------------------------------------------
bool MapInitializer::applyNetworkCache()
{
  SituationMap::EsriNetworkCacheSettings encs = m_mapSettings.networkCacheSettings();
  SituationMap::Map::applyNetworkCacheSettings(encs);

  // re-read:
  const SituationMap::EsriNetworkCacheSettings &readEncs = SituationMap::Map::networkCacheSettings();
  return readEncs.enabled == encs.enabled;
}


bool MapInitializer::setSymbologyType()
{
  AdvancedSymbology::SymbologyType symbologyType = this->symbologyType();
  return m_map.setSymbologyType(symbologyType);
}


bool MapInitializer::setBasemapLayernamePrefix()
{
  const QString &basemapLayernamePrefix = m_mapSettings.basemapLayernamePrefix();
  if (!basemapLayernamePrefix.isEmpty())
  {
    INFO_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")"
                       << " set basemapLayernamePrefix to '" << basemapLayernamePrefix << "'";
    m_map.layerFactory().setBasemapLayernamePrefix(basemapLayernamePrefix);
  }
  return true;
}

bool MapInitializer::setParticipantLayername()
{
  // like 'Participants:Dynamic:Relative'
  const QString &participantLayername = m_mapSettings.participantLayername();
  if (participantLayername.isEmpty())
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")"
                        << ", participantLayername is empty";
    return false;
  }

  const QStringList &sl = participantLayername.split(QLatin1Char(':'));
  if (sl.size() != 3)
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << " logicalLayerName configuration not correct."
                        << ", participantLayername='" << participantLayername << "'";
    return false;
  }

  // Layername
  const QString &layername = sl.first();

  // V100.0.0:
  // Dynamic RenderMode has known issue related to military symbology at 3D.
  // recommendation: use static:
  RenderingMode     renderingMode    = RenderingMode::Dynamic;   // ToDo V100: Dynamic vs. Static
  SurfacePlacement  surfacePlacement = SurfacePlacement::Draped;

  // RenderingMode
  const QString &rmName = sl[1];
  if (!fromString(renderingMode, rmName))
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << " parseError on renderMode: rmName='" << rmName << "'";
    return false;
  }

  // SurfacePlacement
  const QString &spName = sl[2];
  if (!fromString(surfacePlacement, spName))
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << " parseError on surfacePlacement: spName='" << rmName << "'";
    return false;
  }

  INFO_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")"
                     << " set participantLayername to '" << layername << "'"
                     << " renderingMode=" << renderingMode
                     << " surfacePlacement=" << surfacePlacement;

  m_map.layerFactory().setParticipantLayer(layername, renderingMode, surfacePlacement);
  return true;
}

AdvancedSymbology::SymbologyType MapInitializer::symbologyType() const
{
  AdvancedSymbology::SymbologyType symbologyType = m_mapSettings.symbologyType();
  return symbologyType;
}

bool MapInitializer::initalizeLocalMapFile()
{
  const QString &localMapFile = m_mapSettings.localMapFile();
  if (!localMapFile.isEmpty())
  {
    INFO_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")"
                       << " localMapFile = '" << localMapFile << "'";
    return m_map.layerFactory().initializeBasemapBuiltIn(localMapFile);
  }
  return true;
}

//----------------------------------------------------------------------------
bool MapInitializer::initializeBasemaps(Mode mapMode)
{
  QVector<BaseUrl> baseUrls;
  switch (mapMode)
  {
  case Mode::Undefined:
    break;
  case Mode::Mode_2D:
    baseUrls = m_mapSettingJson.getMapUrls();
    break;
  case Mode::Mode_3D:
    baseUrls = m_mapSettingJson.getSceneUrls();
    break;
  default:
    break;
  }

  QString job;
  bool success = true;
  if (baseUrls.isEmpty())
  {
    // use QSettings
    if (m_mapSettings.localMapFile().isEmpty())
    {
      job = QLatin1String("initializeBasemapsQSettings");
      if (initializeBasemapsQSettings(mapMode))
        DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
      else
      {
        ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
        success = false;
      }
    } else {
      job = QLatin1String("initalizeLocalMapFile");
      if (initalizeLocalMapFile())
        DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
      else
      {
        ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
        success = false;
      }
    }
  } else {
    //
    // Values are initially taken from DB -> MapDescription@TrainingArea@DDS
    //
    job = QLatin1String("initializeBasemapsJSON");
    if (initializeBasemapsJson(baseUrls))
      DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
    else
    {
      ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
      success = false;
    }
  }
  return success;
}

bool MapInitializer::initializeBasemapsQSettings(Mode mapMode)
{
  QVector<QPair<QString, QString>> basemapUrls;
  switch (mapMode)
  {
  case Mode::Undefined:
    break;
  case Mode::Mode_2D:
    basemapUrls = m_mapSettings.mapUrlsWithNames();
    break;
  case Mode::Mode_3D:
    basemapUrls = m_mapSettings.sceneUrlsWithNames();
    break;
  default:
    break;
  }

  DEBUG_LOG(m_logger) << LOGFUNCTION
                      << " UrlCount= " << basemapUrls.count();
                     // << " basemapUrls='" << basemapUrls.join(QLatin1String(";")) << "'";

  // Process basemaps:
  bool success = true;
  int localLayerCount = 0;
  // item => val, name
  for (const QPair<QString, QString> &item : std::as_const(basemapUrls))
  {
    QString layername = QStringLiteral("%1%2").arg(m_map.layerFactory().basemapLayernamePrefix()).arg(localLayerCount);

    QString urlVal    = item.first;
    QString displayName = item.second;

    double minScale = -1;
    double maxScale = -1;
    QChar seperator(QLatin1Char('#'));
    QStringList slUrlExt = urlVal.split(seperator);

    QString finalMapUrl = slUrlExt.first();
    if (slUrlExt.size() == 2)
    {
      finalMapUrl                    = slUrlExt[0];
      const QString &mapUrlExtension = slUrlExt[1];

      QChar innerSeperator(QLatin1Char(':'));
      QStringList slMinMax = mapUrlExtension.split(innerSeperator);
      if (slMinMax.size() == 2)
      {
        bool bOk = false;
        QString temp = slMinMax[0];
        minScale = temp.toDouble(&bOk);
        if (!bOk)
        {
          minScale = -1;
          ERROR_LOG(m_logger) << LOGFUNCTION << " String can´t be converted to double. str='" << temp << "'";
        }
        temp = slMinMax[1];
        maxScale = temp.toDouble(&bOk);
        if (!bOk)
        {
          maxScale = -1;
          ERROR_LOG(m_logger) << LOGFUNCTION << " String can´t be converted to double. str='" << temp << "'";
        }
      }
    }

    DEBUG_LOG(m_logger) << " layername = '" << layername << "'"
                        << " displayName = '" << displayName << "'"
                       << " minScale = " << minScale << " maxScale = " << maxScale;

    success = success && m_map.layerFactory().addBasemap(layername,
                                                         QUrl(finalMapUrl),
                                                         (localLayerCount == 0) ? BasemapType::Topographic : BasemapType::Aerial,
                                                         minScale,
                                                         maxScale,
                                                         displayName, // QStringLiteral("dispName_%1").arg(layername),
                                                         QStringLiteral("descrip_%1").arg(localLayerCount),
                                                         QImage());
    ++localLayerCount;
  } // for


  return success;

}

bool MapInitializer::initializeBasemapsJson(const QVector<BaseUrl> &baseUrls)
{
  // Process basemaps:
  bool success = true;

  int localLayerCount = 0;
  for (const BaseUrl &baseUrl : std::as_const(baseUrls))
  {
    const QString &layername = QStringLiteral("%1%2").arg(m_map.layerFactory().basemapLayernamePrefix()).arg(localLayerCount);

    INFO_LOG(m_logger) << " ***** JSON: layername = '" << layername << "'"
                       << " minScale = " << baseUrl.minScale() << " maxScale = " << baseUrl.maxScale()
                       << " url = '" << baseUrl.url();

    success = success && m_map.layerFactory().addBasemap(layername,
                                                         QUrl(baseUrl.url()),
                                                         // (localLayerCount == 0) ? BasemapType::Topographic : BasemapType::Aerial,
                                                         baseUrl.basemapType(),
                                                         baseUrl.minScale(),
                                                         baseUrl.maxScale(),
                                                         baseUrl.name(),
                                                         baseUrl.description(),
                                                         QImage());
    ++localLayerCount;
  } // for

  return success;
}

bool MapInitializer::initializeSceneObjectLayers()
{
  const QStringList &sceneObjectUrls = m_mapSettings.sceneObjectUrls();
  if (sceneObjectUrls.isEmpty())
    return true; // handle as successful

  bool success = true;
  for (const QString &item : std::as_const(sceneObjectUrls))
  {
    QChar seperator(QLatin1Char('#'));
    QStringList slUrlExt = item.split(seperator);

    if (slUrlExt.size() < 1)
    {
      ERROR_LOG(m_logger) << " Error splitting item: '" << item << "'";
      continue;
    }

    const QString realUrl       = slUrlExt.first();
    const QString altitudeOffsetStr = slUrlExt.value(1, QStringLiteral("0.0")); // default value is 0;
    bool ok = false;
    double altitudeOffset = altitudeOffsetStr.toDouble(&ok);
    if (!ok)
      altitudeOffset = 0.001;

    INFO_LOG(m_logger) << " sceneObjectLayers "
                       << " realUrl = '" << realUrl << "'"
                       << " altitudeOffset = " << altitudeOffset;

    int localLayerCount = 0;
    const QString &layername = QStringLiteral("SceneObjectLayer_%1").arg(localLayerCount);

    success = success && m_map.layerFactory().addSceneObjectLayer(layername,
                                                                  QUrl(realUrl),
                                                                  altitudeOffset,
                                                                  QStringLiteral("dispName_%1").arg(layername),
                                                                  QStringLiteral("descrip_%1").arg(localLayerCount),
                                                                  QImage());
  }
  return success;
}

bool MapInitializer::initializeSceneObjectLayersJson()
{
  const QVector<BaseUrl> &urls = m_mapSettingJson.getSceneObjectUrls();
  if (urls.isEmpty())
    return true; // handle as successful

  bool success = true;
  for (const BaseUrl &item : std::as_const(urls))
  {
    const QString &urlVal = item.url();

    QChar seperator(QLatin1Char('#'));
    QStringList slUrlExt = urlVal.split(seperator);

    if (slUrlExt.size() < 1)
    {
      ERROR_LOG(m_logger) << " Error splitting item: '" << urlVal << "'";
      continue;
    }

    const QString realUrl       = slUrlExt.first();

    const QString altitudeOffsetStr = slUrlExt.value(1, QStringLiteral("0.0")); // default value is 0;
    bool ok = false;
    double altitudeOffset = altitudeOffsetStr.toDouble(&ok);
    if (!ok)
      altitudeOffset = 0.001;

    if (!qFuzzyIsNull(item.altitudeOffset()))
      altitudeOffset = item.altitudeOffset();

    NOTICE_LOG(m_logger) << " sceneObjectLayers "
                       << " realUrl = '" << realUrl << "'"
                       << " altitudeOffset = " << altitudeOffset;

    int localLayerCount = 0;
    const QString &layername = QStringLiteral("SceneObjectLayer_%1").arg(localLayerCount);

    success = success && m_map.layerFactory().addSceneObjectLayer(layername,
                                                                  QUrl(realUrl),
                                                                  altitudeOffset,
                                                                  QStringLiteral("dispName_%1").arg(layername),
                                                                  QStringLiteral("descrip_%1").arg(localLayerCount),
                                                                  QImage());
  }
  return success;
}

bool MapInitializer::initializeElevationSources()
{
  bool success = false;
  if (m_mapSettingJson.getElevationUrls().isEmpty())
  {
    success = initializeElevationSourcesQSettings();
  } else {
    success = initializeElevationSourcesJson();
  }
  return success;
}

bool MapInitializer::initializeElevationSourcesQSettings()
{
  const QStringList &elevationUrls = m_mapSettings.elevationUrls();
  if (elevationUrls.isEmpty())
    return true; // handle as successful
  INFO_LOG(m_logger) << LOGFUNCTION << " elevationUrlsQSettings = '" << elevationUrls.join(QLatin1Char(';')) << "'";
  return m_map.layerFactory().initializeElevationSources(elevationUrls);
}

bool MapInitializer::initializeElevationSourcesJson()
{
  const QVector<BaseUrl> &urls = m_mapSettingJson.getElevationUrls();
  if (urls.isEmpty())
    return true; // handle as successful

  QStringList slUrls;
  slUrls.reserve(urls.size());
  for (const auto &item : urls)
    slUrls.append(item.url());
  INFO_LOG(m_logger) << LOGFUNCTION << " elevationUrlsJSON = '" << slUrls.join(QLatin1Char(';')) << "'";
  return m_map.layerFactory().initializeElevationSources(slUrls);
}


bool MapInitializer::initialzeInitialViewpoint()
{
  const QString &centerPointMgrsIni = m_mapSettings.centerPointMgrs();
  double scaleIni                   = m_mapSettings.scale();

  if (m_viewPoint.isNull())
  {
    const QPointF &centerPointGeo = LtsCoordTrans::geographicFromMgrs(centerPointMgrsIni);
    m_viewPoint.setCenterGeo(centerPointGeo);
    m_viewPoint.setScale(scaleIni);
  }

  DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " centerPointMgrsIni=" << centerPointMgrsIni << " scaleIni=" << scaleIni << " m_viewPoint=" << m_viewPoint;

  m_map.setInitialViewpoint(m_viewPoint);  // QPointF(92750, 80525) -> Rennplatz - Bremen

  return true;
}

//----------------------------------------------------------------------------
bool MapInitializer::initializeOperationalLayers()
{
  const QStringList &operationLayers = m_mapSettings.operationalLayers();

  if (operationLayers.isEmpty())
  {
    ERROR_LOG(m_logger) << LOGFUNCTION
                        << " initializeOperationalLayers failed, "
                        << " layerNames empty";
    return false;
  }


  // Lookup for displaynames
  QMap<QString, QString> displayNames;
  displayNames[QStringLiteral("Buildings")]         = tr("Buildings");              // dt. 3D Gebäude
  displayNames[QStringLiteral("MountingPoints")]    = tr("MountingPoints");         // dt. Anbringungspunkte
  displayNames[QStringLiteral("IEDs")]              = tr("IEDs");                   // dt. IEDs
  displayNames[QStringLiteral("BuildingOwnership")] = tr("BuildingOwnership");      // dt. Gebäudebesitz
  displayNames[QStringLiteral("AES")]               = tr("AES");                    // dt. Wirksimulation
  displayNames[QStringLiteral("AESCentral")]        = tr("AesCentral");             // dt. Wirksimulation(Zentral)
  displayNames[QStringLiteral("TechnicalAreas")]    = tr("TechnicalAreas");         // dt. Technische Bereiche
  displayNames[QStringLiteral("RubberbandLayer")]   = tr("RubberbandLayer");

  displayNames[QStringLiteral("Participants")]      = tr("Participants");           // dt. Teilnehmer
  displayNames[QStringLiteral("Participants_1")]    = tr("Participant (Level 1)");  // dt. Teilnehmer (Ebene 1)
  displayNames[QStringLiteral("Participants_2")]    = tr("Participant (Level 2)");  // dt. Teilnehmer (Ebene 2)
  displayNames[QStringLiteral("Participants_3")]    = tr("Participant (Level 3)");  // dt. Teilnehmer (Ebene 3)
  displayNames[QStringLiteral("Participants_4")]    = tr("Participant (Level 4)");  // dt. Teilnehmer (Ebene 4)
  displayNames[QStringLiteral("Participants_5")]    = tr("Participant (Level 5)");  // dt. Teilnehmer (Ebene 5)


  // V100.0.0:
  // Dynamic RenderMode has known issue related to military symbology at 3D.
  // recommendation: use static:
  const RenderingMode     defaultRenderingMode    = RenderingMode::Dynamic;   // ToDo V100: Dynamic vs. Static
  const SurfacePlacement  defaultSurfacePlacement = SurfacePlacement::Draped;

  for (const QString &logicalLayerNameEncoded : operationLayers)
  {
    QString layerName;
    RenderingMode    renderMode       = defaultRenderingMode;
    SurfacePlacement surfacePlacement = defaultSurfacePlacement;

    // RenderingMode configured in layername?
    if (logicalLayerNameEncoded.contains(QLatin1Char(':')))
    {
      const QStringList &sl = logicalLayerNameEncoded.split(QLatin1Char(':'));
      if (sl.size() != 3)
      {
        ERROR_LOG(m_logger) << LOGFUNCTION << " logicalLayerName configuration not correct."
                            << ", logicalLayerName='" << logicalLayerNameEncoded << "'";
        return false;
      }
      // Layername:
      layerName = sl.first();

      // RenderingMode
      const QString &rmName = sl[1];
      if (!fromString(renderMode, rmName))
      {
        ERROR_LOG(m_logger) << LOGFUNCTION << " parseError on renderMode: rmName='" << rmName << "'";
        return false;
      }

      // SurfacePlacement
      const QString &spName = sl[2];
      if (!fromString(surfacePlacement, spName))
      {
        ERROR_LOG(m_logger) << LOGFUNCTION << " parseError on surfacePlacement: spName='" << rmName << "'";
        return false;
      }
    } // if (logicalLayerName.contains(QLatin1Char(':')))

    DEBUG_LOG(m_logger) << LOGFUNCTION << " logicalLayerName configuration"
                        << ", logicalLayerNameEncoded='" << logicalLayerNameEncoded << "'"
                        << ", layerName='" << layerName << "'"
                        << " set to RM=" << renderMode
                        << " set to SP=" << surfacePlacement;

    QString displayName = layerName;
    if (displayNames.contains(layerName))
      displayName = displayNames[layerName];

    if (! m_map.layerFactory().addOperationalLayer(layerName, displayName, renderMode, surfacePlacement))
    {
      ERROR_LOG(m_logger) << LOGFUNCTION
                          << " addOperationalLayer failed, "
                          << " layerName='" << layerName << "'";
      return false;
    }

  } // foreach


  return true;
}

bool MapInitializer::initializeUniqueValueRendererForCubes()
{
  const QString &operationLayers4Cubes = m_mapSettings.operationalLayerForCubes();
  if (operationLayers4Cubes.isEmpty())
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")"
                        << " operationalLayerForCubes missing";
    return false;
  }
  m_map.layerFactory().setLayernameForCubes(operationLayers4Cubes);
  return m_map.layerFactory().assignUniqueValueRendererForCubes();
}

bool MapInitializer::initializeExtraSymbolDirectory()
{
  QString extraSymbolDir = m_mapSettings.extraSymbolDirectory();

  if (extraSymbolDir.isEmpty())
    return true;

  // do it just once
  // data is global and already store in SymbolDictionary
  // see MapInitializer::initializeExtraSymbolDirectory and InterfaceImpl::reCreateSituationMapInit
  static bool s_alreadyInitialized = false;
  if (s_alreadyInitialized)
  {
    INFO_LOG(m_logger) << LOGFUNCTION << " EtsSymbols already initialized";
    return true;
  }
  s_alreadyInitialized = true;

  int addedFiles = m_map.symbolDictionary().addEtsSymbols(extraSymbolDir);
  return addedFiles > 0;
}

bool MapInitializer::initializeAnimations()
{
  // animationDuration
  double animationDuration = m_mapSettings.animationDuration();
  if (animationDuration > 0)
    m_map.setAnimationDuration(animationDuration);


  // animationDuration for 'rocket'
  double rocketDuration = m_mapSettings.rocketDuration();
  if (rocketDuration > 0)
    m_map.setRocketDuration(rocketDuration);

  return true;
}

//----------------------------------------------------------------------------
bool MapInitializer::initializeGrid()
{
  GridType gridType = m_mapSettings.gridType();

  switch (gridType)
  {
  case GridType::NoType:
    //m_map.grid().setGridType(gridType);
    m_map.grid().setVisible(false);
    break;
  case GridType::LatLon:
  case GridType::MGRS:
  case GridType::USGN:
  case GridType::UTM:
    m_map.grid().setGridType(gridType);
    m_map.grid().setVisible(true);
    break;
  }

  return true;
}

bool MapInitializer::initializeObjectFactory()
{
  INFO_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " must be overloaded!!!";
  return false;
}

//----------------------------------------------------------------------------
bool MapInitializer::setObjectContainer()
{
  // use default
  return true;
}


bool MapInitializer::initializeRubberFactory()
{
  m_map.rubberbandFactory().setRubberbandDrawColor(m_mapSettings.rubberbandDrawColor());
  m_map.rubberbandFactory().setRubberbandFillColor(m_mapSettings.rubberbandFillColor());
  m_map.rubberbandFactory().setRubberbandHandleDrawColor(m_mapSettings.rubberbandHandleDrawColor());
  m_map.rubberbandFactory().setRubberbandHandleFillColor(m_mapSettings.rubberbandHandleFillColor());
  m_map.rubberbandFactory().setRubberbandSelectionColor(m_mapSettings.rubberbandSelectionColor());
  m_map.rubberbandFactory().setRubberbandFrameColor(m_mapSettings.rubberbandFrameColor());
  m_map.rubberbandFactory().setRubberbandFrameFillColor(m_mapSettings.rubberbandFrameFillColor());
  m_map.rubberbandFactory().setRubberbandFrameHandleMargin(m_mapSettings.rubberbandFrameHandleMargin());
  m_map.rubberbandFactory().setRubberbandPreviewOffset(m_mapSettings.rubberbandPreviewOffset());
  m_map.rubberbandFactory().setRubberbandPreviewSize(m_mapSettings.rubberbandPreviewSize());
  m_map.rubberbandFactory().setRubberbandPickingRatio(m_mapSettings.rubberbandPickingRatio());
  m_map.rubberbandFactory().setRubberbandLineHandleWidth(m_mapSettings.rubberbandLineHandleWidth());

  SituationMap::RB::EventMouseNavigator::setPickTolerance(m_mapSettings.rubberbandPickingRatio());
  SituationMap::RB::EventMouseNavigator::setZoomFactorBase(m_mapSettings.zoomFactorBase());

  return true;
} //  MapInitializer::initializeRubberFactory()


//----------------------------------------------------------------------------
bool MapInitializer::initializeCoordTranslationFunctor()
{
  m_map.initCoordTranslationFunctor();
  return true;
}

bool MapInitializer::initializeMapWidgets()
{
  if (m_mapSettings.addMapWidgets())
    m_map.addMapWidget();
  return true;
}


bool MapInitializer::initializeSideBar()
{
  if (m_mapSettings.addSideBar())
    m_map.addSideBar();
  return true;
}

bool MapInitializer::setViewshedUrl()
{
  QString viewshedUrl = m_mapSettings.viewshedUrl();
  if (!viewshedUrl.isEmpty())
    m_map.viewshed().setViewshedUrl(viewshedUrl);
  return true;
}

void MapInitializer::onMapReady()
{
  TRACE_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " START";

  // center / scale :
  if (m_map.initialViewpoint().isNull())
  {
    const QString &centerPointMgrsIni = m_mapSettings.centerPointMgrs();
    double scaleIni                   = m_mapSettings.scale();

    if (m_viewPoint.isNull())
    {
      const QPointF &centerPointGeo = LtsCoordTrans::geographicFromMgrs(centerPointMgrsIni);
      m_viewPoint.setCenterGeo(centerPointGeo);
      m_viewPoint.setScale(scaleIni);
    }

    INFO_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")"
                       << " centerPointMgrsIni=" << centerPointMgrsIni
                       << " scaleIni=" << scaleIni
                       << " m_viewPoint=" << m_viewPoint;

    // setViewpoint2D works for 2D and 3D
    m_map.setViewpoint2D(m_viewPoint);  // QPointF(92750, 80525) -> Rennplatz - Bremen
  }
  else
  {
    const Viewpoint2D &iVp = m_map.initialViewpoint();
    INFO_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")"
                       << " skip 'setViewpoint2D' due to setInitialViewpoint"
                       << " (" << iVp << ")";
  }
  // : center / scale


  // minMaxScale is optional:
  double minScale = m_mapSettings.minScale();
  double maxScale = m_mapSettings.maxScale();

  INFO_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")"
                     << " ini -> minScale=" << minScale
                     << " maxScale=" << maxScale;

  if (minScale > 1)
    m_map.setMinScale(minScale);  // big value   (e.g. 10000000)
  if (maxScale > 1)
    m_map.setMaxScale(maxScale);  // small value (e.g. 100)

  // scaleHasVisibility:
  double scaleHasVisibility = m_mapSettings.scaleHasVisibility();

  // set static value (valid for all mapObjects):
  AbstractMapObject::setScaleHasVisibility(scaleHasVisibility);

  TRACE_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " END";
}


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

} // namespace SituationMap