/**
  * @RDE_HEADER@
  * Utilities for SituationMap
  * $Id$
  * $HeadURL$
  * $Author$
  */

// Own
#include "situation_map_utils.h"
#include "abstract_effect_simulation.h"


// Esri
#include <arcgis/CoreTypes.h> // for LicenseStatus
#include <arcgis/MapTypes.h>
#include <arcgis/Viewpoint.h>
#include <arcgis/Camera.h>


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

#if ACRGIS_VERSION >= 0x640600 // 100.6.0 / Update 6
#define HAS_SURFACEPLACEMENT_RELATIVETOSCENE
#endif


// Qt
#include <QString>
#include <QPointF>
#include <QRect>

#include <sstream>


std::ostream &operator<< (std::ostream   &stream,
                          const SituationMap::PositionCont &value)
{
  stream << "PosCont(" << value.size() << "): ";
  for (const SituationMap::Point3D &item : value)
    stream << item << ";";
  return stream;
}


//std::ostream& operator<< (std::ostream&   stream,
//                          const QRect& value)
//{
//  stream << "QRect(topLeft=" << value.topLeft()
//         << " bottomRight=" << value.bottomRight()
//         << " width=" << value.width()
//         << " height=" << value.height()
//         << " center=" << value.center()
//         << " bottom=" << value.bottom()
//         << " left=" << value.left()
//         << ")";
//  return stream;
//}

QString toString(const QRectF &value)
{
  std::ostringstream stream;
  stream << "QRect(topLeft=" << value.topLeft()
         << " bottomRight=" << value.bottomRight()
         << " width=" << value.width()
         << " height=" << value.height()
         << " center=" << value.center()
         << " bottom=" << value.bottom()
         << " left=" << value.left()
         << ")";
  return QString::fromStdString(stream.str());
}


std::ostream &operator<<(std::ostream &stream, const QColor &value)
{
  stream << "QColor("
         << value.name(QColor::HexArgb).toUtf8().data()
         << ")";
  return stream;
}

QString toString(const QColor &value)
{
  return value.name(QColor::HexArgb);
}



namespace SituationMap
{
QString toString(const AesEffectState value)
{
  switch (value)
  {
  case AesEffectState::Removed:
    return QStringLiteral("AesRemoved");
  case AesEffectState::Expired:
    return QStringLiteral("AesExpired");
  case AesEffectState::Error:
    return QStringLiteral("AesError");
  case AesEffectState::Paused:
    return QStringLiteral("AesPaused");
  case AesEffectState::Prepared:
    return QStringLiteral("AesExpired");
  case AesEffectState::Created:
    return QStringLiteral("AesCreated");
  case AesEffectState::Activated:
    return QStringLiteral("AesActivated");
  case AesEffectState::Unknown:
    return QStringLiteral("AesUnknown");
  } // switch
  Q_ASSERT(false);
  return QStringLiteral("AesEffectStateERROR");
}

std::ostream &operator<< (std::ostream   &stream,
                          const AesEffectState &value)
{
  stream << toString(value).data();
  return stream;
}

QString toString(DrawStatus value)
{
  switch (value)
  {
  case SituationMap::DrawStatus::InProgress:
    return QStringLiteral("DSInProgress");
  case SituationMap::DrawStatus::Completed:
    return QStringLiteral("DSCompleted");
  } // switch
  Q_ASSERT(false);
  return QStringLiteral("DrawStatusERROR");
}


QString toString(GridType value)
{
  switch (value)
  {
  case GridType::NoType:
    return QStringLiteral("NoType");
  case GridType::LatLon:
    return QStringLiteral("LatLon");
  case GridType::MGRS:
    return QStringLiteral("MGRS");
  case GridType::USGN:
    return QStringLiteral("USGN");
  case GridType::UTM:
    return QStringLiteral("UTM");
  } // switch
  Q_ASSERT(false);
  return QStringLiteral("GridTypeERROR");
}

QString toString(LayerType value)
{
  switch (value)
  {
  case LayerType::Undefined:
    return QStringLiteral("LTUndefined");
  case LayerType::Basemap:
    return QStringLiteral("LTBasemap");
  case LayerType::JumpPoint:
    return QStringLiteral("LTJumpPoint");
  case LayerType::SnapshotOverlay:
    return QStringLiteral("LTSnapshotOverlay");
  case LayerType::Overlay:
    return QStringLiteral("LTOverlay");
  case LayerType::Operational:
    return QStringLiteral("LTOperational");
  case LayerType::Tools:
    return QStringLiteral("LTTools");
  case LayerType::Rubberband:
    return QStringLiteral("LTRubberband");
  case LayerType::EmergencyCall:
    return QStringLiteral("LTEmergencyCall");
  } // switch
  Q_ASSERT(false);
  return QStringLiteral("LayerTypeERROR");
}

QString toString(BasemapType value)
{
  switch (value)
  {
  case BasemapType::Undefined:
    return QStringLiteral("BMTUndefined");
  case BasemapType::Aerial:
    return QStringLiteral("BMTAerial");
  case BasemapType::Topographic:
    return QStringLiteral("BMTTopographic");
  } // switch
  Q_ASSERT(false);
  return QStringLiteral("BasemapTypeERROR");
}

QString toString(SituationMap::RenderingMode value)
{
  switch (value)
  {
  case RenderingMode::Dynamic:
    return QStringLiteral("Dynamic");
  case RenderingMode::Static:
    return QStringLiteral("Static");
  } // switch
  Q_ASSERT(false);
  return QStringLiteral("RenderingModeERROR");
}
bool fromString(RenderingMode &renderingMode, const QString &str)
{
  if (str.compare(QStringLiteral("Dynamic")) == 0)
  {
    renderingMode = RenderingMode::Dynamic;
    return true;
  }
  if (str.compare(QStringLiteral("Static")) == 0)
  {
    renderingMode = RenderingMode::Static;
    return true;
  }
  return false;
}


QString toString(SurfacePlacement value)
{
  switch (value)
  {
  case SurfacePlacement::Draped:
    return QStringLiteral("Draped");
  case SurfacePlacement::Absolute:
    return QStringLiteral("Absolute");
  case SurfacePlacement::Relative:
    return QStringLiteral("Relative");
  } // switch
  Q_ASSERT(false);
  return QStringLiteral("SurfacePlacementERROR");
}

bool fromString(SituationMap::SurfacePlacement &surfacePlacement, const QString &str)
{
  if (str.compare(QStringLiteral("Draped")) == 0)
  {
    surfacePlacement = SurfacePlacement::Draped;
    return true;
  }
  if (str.compare(QStringLiteral("Absolute")) == 0)
  {
    surfacePlacement = SurfacePlacement::Absolute;
    return true;
  }
  if (str.compare(QStringLiteral("Relative")) == 0)
  {
    surfacePlacement = SurfacePlacement::Relative;
    return true;
  }
  return false;
}



QString toDisplayString(BasemapType value)
{
  switch (value)
  {
  case BasemapType::Undefined:
    return QStringLiteral("TUndefined");
  case BasemapType::Aerial:
    return QStringLiteral("Aerial");
  case BasemapType::Topographic:
    return QStringLiteral("Topographic");
  } // switch
  Q_ASSERT(false);
  return QStringLiteral("BasemapTypeERROR");
}



bool fromString(GridType &gridType, const QString &str)
{
  if (str.compare(QStringLiteral("NoType")) == 0)
  {
    gridType = GridType::NoType;
    return true;
  }
  if (str.compare(QStringLiteral("MGRS"), Qt::CaseInsensitive) == 0)
  {
    gridType = GridType::MGRS;
    return true;
  }
  if (str.compare(QStringLiteral("UTM"), Qt::CaseInsensitive) == 0)
  {
    gridType = GridType::UTM;
    return true;
  }
  if (str.compare(QStringLiteral("USGN"), Qt::CaseInsensitive) == 0)
  {
    gridType = GridType::USGN;
    return true;
  }
  if (str.compare(QStringLiteral("LatLon"), Qt::CaseInsensitive) == 0)
  {
    gridType = GridType::LatLon;
    return true;
  }
  return false;
}

std::ostream  &operator<< (std::ostream &stream,
                           const DrawStatus value)
{
  stream << toString(value).data();
  return stream;
}

std::ostream  &operator<< (std::ostream &stream,
                           const GridType value)
{
  stream << toString(value).data();
  return stream;
}

std::ostream  &operator<< (std::ostream &stream,
                           const SituationMap::LayerType value)
{
  stream << toString(value).data();
  return stream;
}

std::ostream  &operator<< (std::ostream &stream,
                           const SituationMap::BasemapType value)
{
  stream << toString(value).data();
  return stream;
}

std::ostream  &operator<< (std::ostream &stream,
                           const SituationMap::RenderingMode value)
{
  stream << toString(value).data();
  return stream;
}

std::ostream  &operator<< (std::ostream &stream,
                           const SituationMap::SurfacePlacement value)
{
  stream << toString(value).data();
  return stream;
}

std::ostream  &operator<< (std::ostream &stream,
                           const SituationMap::EsriNetworkCacheSettings value)
{
  stream << "EsriNetworkCacheSettings: ";
  stream << value.toString();
  return stream;
}

} // namespace SituationMap

//------------------------------------------------------------------------------
// namespace Esri::ArcGISRuntime
namespace Esri
{
namespace ArcGISRuntime
{

std::ostream &operator<< (std::ostream &stream,
                          const Esri::ArcGISRuntime::Error &value)
{
  stream << toString(value);
  return stream;
}

QString toString(const Error &value)
{
  std::ostringstream stream;
  stream << "Esri::ArcGISRuntime::Error: "
         << " code="                << value.code()
         << ", domain="             << (int)value.domain()
         << ", extendedErrorType="  << (int)value.extendedErrorType()
         << ", message='"           << value.message() << "'"
         << ", additionalMessage='" << value.additionalMessage() << "'";
  return QString::fromStdString(stream.str());
}

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

std::ostream &operator<< (std::ostream &stream,
                          const Esri::ArcGISRuntime::LicenseStatus value)
{
  stream << "EsriLicenseStatus(" << toString(value)
         << ")";
  return stream;
}

QString toString(const Esri::ArcGISRuntime::LicenseStatus value)
{
  switch (value)
  {
  case Esri::ArcGISRuntime::LicenseStatus::Invalid:
    return QStringLiteral("Invalid");
  case Esri::ArcGISRuntime::LicenseStatus::Expired:
    return QStringLiteral("Expired");
  case Esri::ArcGISRuntime::LicenseStatus::LoginRequired:
    return QStringLiteral("LoginRequired");
  case Esri::ArcGISRuntime::LicenseStatus::Valid:
    return QStringLiteral("Valid");
  } // switch
  Q_ASSERT(false);
  return QStringLiteral("Esri-LicenseStatusERROR");
}

//------------------------------------------------------------------------------
#if ACRGIS_VERSION >= 0x640800 // 100.8.0 / Update 8
std::ostream &operator<< (std::ostream &stream,
                          const Esri::ArcGISRuntime::NetworkCachePolicy value)
{
  stream << "EsriNCP(" << toString(value)
         << ")";
  return stream;
}
QString toString(const NetworkCachePolicy value)
{
  switch (value)
  {
  case Esri::ArcGISRuntime::NetworkCachePolicy::AlwaysCache:
    return QStringLiteral("AlwaysCache");
  case Esri::ArcGISRuntime::NetworkCachePolicy::AlwaysNetwork:
    return QStringLiteral("AlwaysNetwork");
  case Esri::ArcGISRuntime::NetworkCachePolicy::PreferCache:
    return QStringLiteral("PreferCache");
  case Esri::ArcGISRuntime::NetworkCachePolicy::PreferNetwork:
    return QStringLiteral("PreferNetwork");
  } // switch
  Q_ASSERT(false);
  return QStringLiteral("Esri-NetworkCachePolicyERROR");
}
#endif // ACRGIS_VERSION

//------------------------------------------------------------------------------
std::ostream &operator<< (std::ostream &stream,
                          const Esri::ArcGISRuntime::LoadStatus value)
{
  stream << "EsriLS(" << toString(value)
         << ")";
  return stream;
}

QString toString(const Esri::ArcGISRuntime::LoadStatus value)
{
  switch (value)
  {
  case Esri::ArcGISRuntime::LoadStatus::Loaded:
    return QStringLiteral("Loaded");
  case Esri::ArcGISRuntime::LoadStatus::Loading:
    return QStringLiteral("Loading");
  case Esri::ArcGISRuntime::LoadStatus::FailedToLoad:
    return QStringLiteral("FailedToLoad");
  case Esri::ArcGISRuntime::LoadStatus::NotLoaded:
    return QStringLiteral("NotLoaded");
  case Esri::ArcGISRuntime::LoadStatus::Unknown:
    return QStringLiteral("Unknown");
  } // switch
  Q_ASSERT(false);
  return QStringLiteral("Esri-LoadStatusERROR");
}

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

std::ostream &operator<< (std::ostream &stream,
                          const Esri::ArcGISRuntime::LayerType value)
{
  stream << "EsriLT(" << toString(value)
         << ")";
  return stream;
}

QString toString(const Esri::ArcGISRuntime::LayerType value)
{
  switch (value)
  {
  case Esri::ArcGISRuntime::LayerType::ImageTiledLayer:
    return QStringLiteral("ImageTiledLayer");
  case Esri::ArcGISRuntime::LayerType::ServiceImageTiledLayer:
    return QStringLiteral("ServiceImageTiledLayer");
  case Esri::ArcGISRuntime::LayerType::ArcGISMapImageLayer:
    return QStringLiteral("ArcGISMapImageLayer");
  case Esri::ArcGISRuntime::LayerType::ArcGISTiledLayer:
    return QStringLiteral("ArcGISTiledLayer");
  case Esri::ArcGISRuntime::LayerType::FeatureCollectionLayer:
    return QStringLiteral("FeatureCollectionLayer");
  case Esri::ArcGISRuntime::LayerType::FeatureLayer:
    return QStringLiteral("FeatureLayer");
  case Esri::ArcGISRuntime::LayerType::KMLLayer:
    return QStringLiteral("KMLLayer");
  case Esri::ArcGISRuntime::LayerType::BingMapLayer:
    return QStringLiteral("BingMapLayer");
  case Esri::ArcGISRuntime::LayerType::RasterLayer:
    return QStringLiteral("RasterLayer");
  case Esri::ArcGISRuntime::LayerType::UnsupportedLayer:
    return QStringLiteral("UnsupportedLayer");
  case Esri::ArcGISRuntime::LayerType::MobileBasemapLayer:
    return QStringLiteral("MobileBasemapLayer");
  case Esri::ArcGISRuntime::LayerType::ArcGISVectorTiledLayer:
    return QStringLiteral("ArcGISVectorTiledLayer");
  case Esri::ArcGISRuntime::LayerType::ArcGISSceneLayer:
    return QStringLiteral("ArcGISSceneLayer");
  case Esri::ArcGISRuntime::LayerType::WmtsLayer:
    return QStringLiteral("WmtsLayer");
  case Esri::ArcGISRuntime::LayerType::OpenStreetMapLayer:
    return QStringLiteral("OpenStreetMapLayer");
  case Esri::ArcGISRuntime::LayerType::BingMapsLayer:
    return QStringLiteral("BingMapsLayer");
  case Esri::ArcGISRuntime::LayerType::WebTiledLayer:
    return QStringLiteral("WebTiledLayer");
  case Esri::ArcGISRuntime::LayerType::EncLayer:
    return QStringLiteral("EncLayer");
  case Esri::ArcGISRuntime::LayerType::WmsLayer:
    return QStringLiteral("WmsLayer");

#if ACRGIS_VERSION >= 0x640500 // 100.5.0 / Update 5
  case Esri::ArcGISRuntime::LayerType::IntegratedMeshLayer:
    return QStringLiteral("IntegratedMeshLayer");
  case Esri::ArcGISRuntime::LayerType::PointCloudLayer:
    return QStringLiteral("PointCloudLayer");
  case Esri::ArcGISRuntime::LayerType::GroupLayer:
    return QStringLiteral("GroupLayer");
  case Esri::ArcGISRuntime::LayerType::AnnotationLayer:
    return QStringLiteral("AnnotationLayer");
#endif // ACRGIS_VERSION

#if ACRGIS_VERSION >= 0x640700 // 100.7.0 / Update 7
  case Esri::ArcGISRuntime::LayerType::SubtypeFeatureLayer:
    return QStringLiteral("SubtypeFeatureLayer");
#endif // ACRGIS_VERSION

#if ACRGIS_VERSION >= 0x640D00 // 100.13.0
  case Esri::ArcGISRuntime::LayerType::DimensionLayer:
    return QStringLiteral("SubtypeFeatureLayer");
#endif // ACRGIS_VERSION

  case Esri::ArcGISRuntime::LayerType::UnknownLayer:
    return QStringLiteral("UnknownLayer");

  } // switch
  Q_ASSERT(false);
  return QStringLiteral("Esri-LayerTypeERROR");
}
//------------------------------------------------------------------------------

std::ostream &operator<< (std::ostream &stream,
                          const Esri::ArcGISRuntime::ElevationSourceType value)
{
  stream << "EsriEST(" << toString(value)
         << ")";
  return stream;
}

QString toString(const Esri::ArcGISRuntime::ElevationSourceType value)
{
  switch (value)
  {
  case Esri::ArcGISRuntime::ElevationSourceType::Unknown:
    return QStringLiteral("Unknown");
  case Esri::ArcGISRuntime::ElevationSourceType::ArcGISTiledElevationSource:
    return QStringLiteral("ArcGISTiledElevationSource");
  case Esri::ArcGISRuntime::ElevationSourceType::RasterElevationSource:
    return QStringLiteral("RasterElevationSource");
  } // switch
  Q_ASSERT(false);
  return QStringLiteral("Esri-ElevationSourceTypeERROR");
}


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

std::ostream &operator<< (std::ostream &stream,
                          const Esri::ArcGISRuntime::GraphicsRenderingMode value)
{
  stream << "EsriGRM(" << toString(value)
         << ")";
  return stream;
}

QString toString(const Esri::ArcGISRuntime::GraphicsRenderingMode value)
{
  switch (value)
  {
  case Esri::ArcGISRuntime::GraphicsRenderingMode::Dynamic:
    return QStringLiteral("Dynamic");
  case Esri::ArcGISRuntime::GraphicsRenderingMode::Static:
    return QStringLiteral("Static");
  } // switch
  Q_ASSERT(false);
  return QStringLiteral("Esri-GraphicsRenderingModeERROR");
}



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

std::ostream &operator<< (std::ostream &stream,
                          const Esri::ArcGISRuntime::GeometryType value)
{
  stream << "EsriGT(" << toString(value) << ")";
  return stream;
}

QString toString(const Esri::ArcGISRuntime::GeometryType value)
{
  switch (value)
  {
  case Esri::ArcGISRuntime::GeometryType::Unknown:
    return QStringLiteral("Unknown");
  case Esri::ArcGISRuntime::GeometryType::Point:
    return QStringLiteral("Point");
  case Esri::ArcGISRuntime::GeometryType::Envelope:
    return QStringLiteral("Envelope");
  case Esri::ArcGISRuntime::GeometryType::Polyline:
    return QStringLiteral("Polyline");
  case Esri::ArcGISRuntime::GeometryType::Polygon:
    return QStringLiteral("Polygon");
  case Esri::ArcGISRuntime::GeometryType::Multipoint:
    return QStringLiteral("Multipoint");
  } // switch
  Q_ASSERT(false);
  return QStringLiteral("Esri-GeometryTypeERROR");
}

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

std::ostream &operator<< (std::ostream &stream,
                          const Esri::ArcGISRuntime::ViewpointType value)
{
  stream << "EsriVPT(" << toString(value) << ")";
  return stream;
}

QString toString(const Esri::ArcGISRuntime::ViewpointType value)
{
  switch (value)
  {
  case Esri::ArcGISRuntime::ViewpointType::Unknown:
    return QStringLiteral("Unknown");
  case Esri::ArcGISRuntime::ViewpointType::CenterAndScale:
    return QStringLiteral("CenterAndScale");
  case Esri::ArcGISRuntime::ViewpointType::BoundingGeometry:
    return QStringLiteral("BoundingGeometry");
  }// switch
  Q_ASSERT(false);
  return QStringLiteral("Esri-ViewpointTypeERROR");
}


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

std::ostream &operator<< (std::ostream &stream,
                          const Esri::ArcGISRuntime::SceneLocationVisibility value)
{
  stream << "EsriSLV(" << toString(value) << ")";
  return stream;
}

QString toString(const Esri::ArcGISRuntime::SceneLocationVisibility value)
{
  switch (value)
  {
  case Esri::ArcGISRuntime::SceneLocationVisibility::Visible:
    return QStringLiteral("Visible");
  case Esri::ArcGISRuntime::SceneLocationVisibility::HiddenByBaseSurface:
    return QStringLiteral("HiddenByBaseSurface");
  case Esri::ArcGISRuntime::SceneLocationVisibility::HiddenByEarth:
    return QStringLiteral("HiddenByEarth");
  case Esri::ArcGISRuntime::SceneLocationVisibility::HiddenByElevation:
    return QStringLiteral("HiddenByElevation");
  case Esri::ArcGISRuntime::SceneLocationVisibility::NotOnScreen:
    return QStringLiteral("NotOnScreen");
  }// switch
  Q_ASSERT(false);
  return QStringLiteral("Esri-SceneLocationVisibilityERROR");
}

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

std::ostream &operator<< (std::ostream &stream,
                          const Esri::ArcGISRuntime::SurfacePlacement value)
{
  stream << "EsriSP(" << toString(value) << ")";
  return stream;
}

QString toString(Esri::ArcGISRuntime::SurfacePlacement value)
{
  switch (value)
  {
  case Esri::ArcGISRuntime::SurfacePlacement::Draped:
    return QStringLiteral("Draped");
  case Esri::ArcGISRuntime::SurfacePlacement::Absolute:
    return QStringLiteral("Absolute");
  case Esri::ArcGISRuntime::SurfacePlacement::Relative:
    return QStringLiteral("Relative");

#ifdef HAS_SURFACEPLACEMENT_RELATIVETOSCENE
  case Esri::ArcGISRuntime::SurfacePlacement::RelativeToScene:
    return QStringLiteral("RelativeToScene");
#endif // HAS_SURFACEPLACEMENT_RELATIVETOSCENE

#if ACRGIS_VERSION >= 0x640700 // 100.7.0 / Update 7
  case Esri::ArcGISRuntime::SurfacePlacement::DrapedFlat:
    return QStringLiteral("DrapedFlat");
#endif // ACRGIS_VERSION

  }// switch
  Q_ASSERT(false);
  return QStringLiteral("Esri-SurfacePlacementERROR");
}


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

std::ostream &operator<< (std::ostream &stream,
                          const Esri::ArcGISRuntime::Viewpoint &value)
{
  stream << "EsriVP:"
         << " targetGeometryType=" << value.targetGeometry().geometryType();
  if (value.targetGeometry().geometryType() == Esri::ArcGISRuntime::GeometryType::Point)
  {
    const Esri::ArcGISRuntime::Point center(value.targetGeometry());
    stream << " center: x=" << center.x() << " - y=" << center.y() << " - z=" << center.z();
  }
  stream << " rotation=" << value.rotation()
         << " targetScale=" << value.targetScale();
  return stream;
}

std::ostream &operator<< (std::ostream &stream,
                          const Esri::ArcGISRuntime::Camera &value)
{
  const Esri::ArcGISRuntime::Point &location = value.location();
  stream << "EsriCam:"
         << " location: xLon=" << location.x() << " - yLat=" << location.y() << " - z=" << location.z()
         << " ; h=" << value.heading() << " p=" << value.pitch() << " r=" << value.roll();
  return stream;
}


}
} // namespace Esri::ArcGISRuntime