/**
  * @RDE_HEADER@
  * Operator Map Settings
  * $Id$
  * $HeadURL$
  * $Author$
  */

// Own
#include "operator_map_settings.h"


//Qt
#include <QListIterator>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>


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

bool OperatorMapSettings::isEmpty() const
{
  return mode == Mode::Undefined;
}

bool OperatorMapSettings::getLayerParameter(const QString &layername, LayerParameter& layerParameterOut) const
{
  const QVector<QPair<QString, LayerParameter>>::const_iterator it =
      std::find_if(orderedLayers.cbegin(), orderedLayers.cend(),
                   [&layername](const QPair<QString, SituationMap::LayerParameter> &pair) { return pair.first == layername; } );

  if (it == orderedLayers.end())
    return false;

  layerParameterOut = (*it).second;
  return true;
}

bool OperatorMapSettings::updateLayerParameter(const QString &layername, const LayerParameter& layerParameter)
{
  QVector<QPair<QString, LayerParameter>>::iterator it =
      std::find_if(orderedLayers.begin(), orderedLayers.end(),
                   [&layername](const QPair<QString, SituationMap::LayerParameter> &pair) { return pair.first == layername; } );

  if (it == orderedLayers.end())
    return false;

  // update
  (*it).second = layerParameter;
  return false;
}



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

  // mode
  obj[QLatin1String("mode")]       = static_cast<int>(mode);
  obj[QLatin1String("viewpoint")]  = viewpoint.toJsonObject();
  obj[QLatin1String("camera")]     = camera.toJsonObject();

  // below ground:
  obj[QLatin1String("navigationConstraint")] = static_cast<int>(navigationConstraint);
  obj[QLatin1String("baseSurfaceOpacity")] = static_cast<double>(baseSurfaceOpacity);

  // orderedLayers
  {
    QJsonArray jArray;
    for (const QPair<QString, LayerParameter> &pair : qAsConst(orderedLayers))
    {
      const QString &layername = pair.first;
      const LayerParameter &lp = pair.second;

      QJsonObject objTemp = lp.toJsonObject();
      objTemp[QLatin1String("layername")] = layername;
      jArray.append(objTemp);
    }
    obj[QLatin1String("orderedLayers")] = jArray;
  }

  // orderedOverlays
  {
    QJsonArray jArray;
    for (const int overlayId : orderedOverlays)
    {
      QJsonObject objTemp;
      objTemp[QLatin1String("overlayId")] = overlayId;
      jArray.append(objTemp);
    }
    obj[QLatin1String("orderedOverlays")] = jArray;
  }

  // MapWidgetSettings
  obj[QLatin1String("mapWidgetSettings")] = mapWidgetSettings.toJsonObject();

  // symbolScale
  obj[QLatin1String("symbolScale")] = symbolScale;

  // jumpPoints
  {
    QJsonArray jArray;
    for (const JumpPointData &jpd : jumpPoints)
      jArray.append(jpd.toJsonObject());
    obj[QLatin1String("jumpPoints")] = jArray;
  }

  return obj;
}

QByteArray OperatorMapSettings::toJson() const
{
  // final - toJson
  QJsonDocument jDoc(toJsonObject());
  return jDoc.toJson();
}

bool OperatorMapSettings::fromJson(const QByteArray &json)
{
  QJsonParseError parseError;
  QJsonDocument jDoc(QJsonDocument::fromJson(json, &parseError));

  if (parseError.error != QJsonParseError::NoError)
  {
    qCritical() << " QJsonParseError->errorString: '" << parseError.errorString() << "'"
                << ", offset: " << parseError.offset;
    return false;
  }

  return fromJsonObject(jDoc.object());
}

bool OperatorMapSettings::fromJsonObject(const QJsonObject &json)
{
  // mode
  mode = static_cast<Mode>(json[QLatin1String("mode")].toInt(int(Mode::Undefined)));

  // viewpoint
  viewpoint = Viewpoint2D::read(json[QLatin1String("viewpoint")].toObject());

  // camera
  camera = Camera::read(json[QLatin1String("camera")].toObject());

  // below ground:
  navigationConstraint = static_cast<SituationMap::NavigationConstraint>(json[QLatin1String("navigationConstraint")].toInt(int(SituationMap::NavigationConstraint::Undefined)));
  baseSurfaceOpacity   = static_cast<float>(json[QLatin1String("baseSurfaceOpacity")].toDouble(1.0));


  // orderedLayers
  {
    const QJsonArray jArray = json[QLatin1String("orderedLayers")].toArray();
    orderedLayers.clear();
    orderedLayers.reserve(jArray.size());
    for (const auto &val : jArray)
    {
      const QJsonObject &objTemp = val.toObject();
      const QString &layername = objTemp[QLatin1String("layername")].toString();
      if (layername.isEmpty())
        continue;
      const LayerParameter &lp = LayerParameter::read(objTemp);
      orderedLayers.append(QPair<QString, LayerParameter>(layername, lp));
    } // for
  }

  // orderedOverlays
  {
    const QJsonArray jArray = json[QLatin1String("orderedOverlays")].toArray();
    orderedOverlays.clear();
    orderedOverlays.reserve(jArray.size());
    for (const auto &val : jArray)
    {
      const QJsonObject &objTemp = val.toObject();
      const int overlayId = objTemp[QLatin1String("overlayId")].toInt();
      orderedOverlays.append(overlayId);
    } // for
  }

  // MapWidgetSettings
  mapWidgetSettings = MapWidgetSettings::read(json[QLatin1String("mapWidgetSettings")].toObject());


  // symbolScale
  symbolScale = json[QLatin1String("symbolScale")].toDouble(1.0);
  // range symbolScaleMinimum,symbolScaleMaximum is checked later at MapImpl::setSymbolScale()

  // jumpPoints
  {
    const QJsonArray jArray = json[QLatin1String("jumpPoints")].toArray();
    jumpPoints.clear();
    jumpPoints.reserve(jArray.size());
    for (const auto &val : jArray)
    {
      const QJsonObject &objTemp = val.toObject();
      const JumpPointData &jpd = JumpPointData::read(objTemp);
      jumpPoints.append(jpd);
    } // for
  }

  return true;
}

//
// MapWidgetSettings
//

MapWidgetSettings MapWidgetSettings::read(const QJsonObject &json)
{
  MapWidgetSettings mws;
  if (json.contains(QLatin1String("gridVisibility")))                 mws.gridVisibility                = json[QLatin1String("gridVisibility")].toBool();
  if (json.contains(QLatin1String("positionStringVisibility")))       mws.positionStringVisibility      = json[QLatin1String("positionStringVisibility")].toBool();
  if (json.contains(QLatin1String("timeStringVisibility")))           mws.timeStringVisibility          = json[QLatin1String("timeStringVisibility")].toBool();
  // [GUEZE-2921] add missing exerciseTimeString:
  if (json.contains(QLatin1String("exerciseTimeStringVisibility")))   mws.exerciseTimeStringVisibility  = json[QLatin1String("exerciseTimeStringVisibility")].toBool();
  if (json.contains(QLatin1String("compassVisibility")))              mws.compassVisibility             = json[QLatin1String("compassVisibility")].toBool();
  if (json.contains(QLatin1String("overviewMapVisibility")))          mws.overviewMapVisibility         = json[QLatin1String("overviewMapVisibility")].toBool();
  return mws;
}
QJsonObject MapWidgetSettings::toJsonObject() const
{
  QJsonObject json;
  json[QLatin1String("gridVisibility")]               = gridVisibility;
  json[QLatin1String("positionStringVisibility")]     = positionStringVisibility;
  json[QLatin1String("timeStringVisibility")]         = timeStringVisibility;
  json[QLatin1String("exerciseTimeStringVisibility")] = exerciseTimeStringVisibility;    // [GUEZE-2921] add missing exerciseTimeString
  json[QLatin1String("compassVisibility")]            = compassVisibility;
  json[QLatin1String("overviewMapVisibility")]        = overviewMapVisibility;
  return json;
}

//
// JumpPointData
//
JumpPointData JumpPointData::read(const QJsonObject &json)
{
  JumpPointData jpd;

  jpd.key = json[QLatin1String("key")].toString();

  if (json.contains(QLatin1String("originGeoLon")) && json.contains(QLatin1String("originGeoLat")))
  {
    jpd.originGeo.setX(json[QLatin1String("originGeoLon")].toDouble());
    jpd.originGeo.setY(json[QLatin1String("originGeoLat")].toDouble());
    jpd.originGeo.setZ(json[QLatin1String("originGeoZ")].toDouble());
  }

  jpd.mapScale = json[QLatin1String("mapScale")].toDouble(jpd.mapScale);

  return jpd;
}
QJsonObject JumpPointData::toJsonObject() const
{
  return {
    {QLatin1String("key"), key},
    {QLatin1String("originGeoLon"), originGeo.x()},
    {QLatin1String("originGeoLat"), originGeo.y()},
    {QLatin1String("originGeoZ"), originGeo.z()},
    {QLatin1String("mapScale"), mapScale}
  };
}


} // namespace SituationMap