/**
  * @RDE_HEADER@
  * Interface of AbstractMapObject
  * $Id$
  * $HeadURL$
  * $Author$
  */

// Own
#include "map_settings.h"
#include "situation_map_utils.h"   // fromString(GridType...)
#include "grid.h"


//Qt
#include <QFile>


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

MapSettings::MapSettings(const QString &inifile_ABSOLUTE_Path, QObject *parent)
  : QObject(parent)
  , m_settings(inifile_ABSOLUTE_Path, QSettings::IniFormat)
  , m_logger(getLogger("MapSettings"))
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";

  DEBUG_LOG(m_logger) << LOGFUNCTION << " filename='" << m_settings.fileName();

  if (hasErrors())
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << " filename='" << m_settings.fileName()
                        << "'' has following errors: "
                        << " exists = " << exists()
                        << " accessError = " << accessError()
                        << " formatError = " << formatError();
  }
  else
  {
    DEBUG_LOG(m_logger) << LOGFUNCTION << " filename='" << m_settings.fileName()
                        << "' has no errors ";

    // set default symbology type
    AdvancedSymbology::SymbolDictionary::setDefaultSymbologyType(symbologyType());
  }

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


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


QString MapSettings::filename()    const { return m_settings.fileName();                                 }
bool    MapSettings::hasErrors()   const { return !exists() || m_settings.status() != QSettings::Status::NoError;     }


bool MapSettings::exists() const
{
  QFile file(filename());
  return file.exists();
}


bool    MapSettings::accessError() const { return m_settings.status() == QSettings::Status::AccessError; }
bool    MapSettings::formatError() const { return m_settings.status() == QSettings::Status::FormatError; }


QString MapSettings::licenseStr() const
{
  return m_settings.value(QLatin1String("license/licenseString")).toString();
}

QStringList MapSettings::licenseExtensions()
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";

  QStringList sl;
  int size = m_settings.beginReadArray(QLatin1String("license"));

  sl.reserve(size);
  for (int i = 0; i < size; ++i)
  {
    m_settings.setArrayIndex(i);
    const QString &val = m_settings.value(QLatin1String("extensionString")).toString();
    sl.append(val);
  }
  m_settings.endArray();

  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return sl;
}

EsriNetworkCacheSettings MapSettings::networkCacheSettings()
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
  EsriNetworkCacheSettings encs;

  encs.enabled = m_settings.value(QLatin1String("esriNetworkCache/enabled"), false).toBool();

  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return encs;
}

QString MapSettings::symbologyTypeStr() const
{
  return m_settings.value(QLatin1String("symbology/type")).toString();
}

AdvancedSymbology::SymbologyType MapSettings::symbologyType() const
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
  QString typeStr = symbologyTypeStr();
  AdvancedSymbology::SymbologyType symType = AdvancedSymbology::SymbologyType::None;
  AdvancedSymbology::fromString(symType, typeStr);
  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return symType;
}

QString MapSettings::extraSymbolDirectory() const
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";

  QString extraDir = m_settings.value(QLatin1String("symbology/extraSymbols")).toString();

  TRACE_LOG(m_logger) << LOGFUNCTION << " END, extraDir='" << extraDir << "'";
  return extraDir;
}

QString MapSettings::basemapLayernamePrefix()
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";

  QString val = m_settings.value(QLatin1String("mapUrls/basemapLayernamePrefix")).toString();

  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return val;
}
QVector<QPair<QString, QString>> MapSettings::mapUrlsWithNames()
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";

  int size = m_settings.beginReadArray(QLatin1String("mapUrls"));
  QVector<QPair<QString, QString>> mapUrls;
  mapUrls.reserve(size);

  for (int i = 0; i < size; ++i)
  {
    m_settings.setArrayIndex(i);
    const QString &val = m_settings.value(QLatin1String("url")).toString();
    const QString &name = m_settings.value(QLatin1String("name")).toString();
    mapUrls.append(QPair<QString, QString>(val,name));
    DEBUG_LOG(m_logger) << val << " Name: " << name << " END";
  }
  m_settings.endArray();

  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return mapUrls;
}

QStringList MapSettings::mapUrls()
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";

  QStringList mapUrls;
  int size = m_settings.beginReadArray(QLatin1String("mapUrls"));

  mapUrls.reserve(size);
  for (int i = 0; i < size; ++i)
  {
    m_settings.setArrayIndex(i);
    const QString &val = m_settings.value(QLatin1String("url")).toString();
    mapUrls.append(val);
  }
  m_settings.endArray();

  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return mapUrls;
}

QStringList MapSettings::sceneUrls()
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";

  QStringList sceneUrls;
  int size = m_settings.beginReadArray(QLatin1String("sceneUrls"));

  sceneUrls.reserve(size);
  for (int i = 0; i < size; ++i)
  {
    m_settings.setArrayIndex(i);
    const QString &val = m_settings.value(QLatin1String("url")).toString();
    sceneUrls.append(val);
  }
  m_settings.endArray();

  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return sceneUrls;
}

QVector<QPair<QString, QString>> MapSettings::sceneUrlsWithNames()
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";

  const int size = m_settings.beginReadArray(QLatin1String("sceneUrls"));
  QVector<QPair<QString, QString>> sceneUrls;
  sceneUrls.reserve(size);

  for (int i = 0; i < size; ++i)
  {
    m_settings.setArrayIndex(i);
    const QString &val = m_settings.value(QLatin1String("url")).toString();
    const QString &name = m_settings.value(QLatin1String("name")).toString();
    sceneUrls.append(QPair<QString, QString>(val,name));
  }
  m_settings.endArray();

  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return sceneUrls;
}

QStringList MapSettings::sceneObjectUrls()
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";

  QStringList sceneUrls;
  int size = m_settings.beginReadArray(QLatin1String("sceneObjectUrls"));

  sceneUrls.reserve(size);
  for (int i = 0; i < size; ++i)
  {
    m_settings.setArrayIndex(i);
    const QString &val = m_settings.value(QLatin1String("url")).toString();
    sceneUrls.append(val);
  }
  m_settings.endArray();

  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return sceneUrls;
}

QStringList MapSettings::elevationUrls()
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";

  QStringList elevationUrls;
  int size = m_settings.beginReadArray(QLatin1String("elevationUrls"));

  elevationUrls.reserve(size);
  for (int i = 0; i < size; ++i)
  {
    m_settings.setArrayIndex(i);
    const QString &val = m_settings.value(QLatin1String("url")).toString();
    elevationUrls.append(val);
  }
  m_settings.endArray();

  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return elevationUrls;
}

QStringList MapSettings::operationalLayers()
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";

  QStringList operationalLayers;
  int size = m_settings.beginReadArray(QLatin1String("operationalLayer"));

  operationalLayers.reserve(size);
  for (int i = 0; i < size; ++i)
  {
    m_settings.setArrayIndex(i);
    const QString &val = m_settings.value(QLatin1String("operationalLayer")).toString();
    operationalLayers.append(val);
  }
  m_settings.endArray();

  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return operationalLayers;
}

QString MapSettings::participantLayername()
{
  return m_settings.value(QLatin1String("operationalLayer/participantLayername")).toString();
}

QString MapSettings::operationalLayerForCubes()
{
  return m_settings.value(QLatin1String("operationalLayer/operationalLayerForCubes")).toString();
}

QString MapSettings::localMapFile()
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";

  QString val = m_settings.value(QLatin1String("mapUrls/localMapFile")).toString().trimmed();

  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return val;
}


QString MapSettings::centerPointMgrs() const
{
  return m_settings.value(QLatin1String("map/center"), QLatin1String("32UMD8000085000")).toString();
}


double MapSettings::zoomFactorBase() const
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
  TRACE_LOG(m_logger) << LOGFUNCTION << " END";

  bool   ok    = false;
  double value = m_settings.value(QLatin1String("map/zoomFactorBase")).toDouble(&ok);

  return (ok) ? value : -1;
}


double MapSettings::scale() const
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return m_settings.value(QLatin1String("map/initialScale")).toDouble();
}


double MapSettings::minScale() const
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return m_settings.value(QLatin1String("map/scaleMin")).toDouble();
}


double MapSettings::maxScale() const
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return m_settings.value(QLatin1String("map/scaleMax")).toDouble();
}

double MapSettings::scaleHasVisibility() const
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return m_settings.value(QLatin1String("map/scaleHasVisibility")).toDouble();
}


QString MapSettings::gridStr() const
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return m_settings.value(QLatin1String("map/gridType")).toString();
}


GridType MapSettings::gridType() const
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
  QString gridString = gridStr();
  GridType gridType = GridType::NoType;
  fromString(gridType, gridString);
  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return gridType;
}

double MapSettings::animationDuration() const
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return m_settings.value(QLatin1String("map/animationDuration")).toDouble();
}

double MapSettings::rocketDuration() const
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return m_settings.value(QLatin1String("map/rocketDuration")).toDouble();
}

bool SituationMap::MapSettings::addMapWidgets() const
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return m_settings.value(QLatin1String("widgets/addMapWidgets"), false).toBool();
}

bool MapSettings::addSideBar() const
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return m_settings.value(QLatin1String("widgets/addSideBar"), false).toBool();
}


QString MapSettings::viewshedUrl() const
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return m_settings.value(QLatin1String("viewshed/viewshedUrl")).toString();
}



static QColor s2c(const QString &colorString)
{
  /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   * Creating a QColor from string. The string has one of the following formats:
   *
   *    - #RGB (each of R, G, and B is a single hex digit)
   *    - #RRGGBB
   *    - #AARRGGBB (Since 5.2)
   *    - #RRRGGGBBB
   *    - #RRRRGGGGBBBB
   *    - A name from the list of colors defined in the list of SVG color keyword names provided by the
   *      World Wide Web Consortium; for example, "steelblue" or "gainsboro". These color names work on all platforms.
   *      Note that these color names are not the same as defined by the Qt::GlobalColor enums, e.g. "green" and
   *      Qt::green does not refer to the same color.
   * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  return QColor(colorString);
} // s2c( const QString & colorString )


QColor       MapSettings::rubberbandDrawColor()           const { return s2c(m_settings.value(QLatin1String("rubberband/drawColor"), QLatin1String("black")).toString()); }
QColor       MapSettings::rubberbandFillColor()           const { return s2c(m_settings.value(QLatin1String("rubberband/fillColor"), QLatin1String("#32969696")).toString()); }
QColor       MapSettings::rubberbandHandleDrawColor()     const { return s2c(m_settings.value(QLatin1String("rubberband/handleDrawColor"), QLatin1String("black")).toString()); }
QColor       MapSettings::rubberbandHandleFillColor()     const { return s2c(m_settings.value(QLatin1String("rubberband/handleFillColor"), QLatin1String("yellow")).toString()); }
QColor       MapSettings::rubberbandSelectionColor()      const { return s2c(m_settings.value(QLatin1String("rubberband/selectionColor"), QLatin1String("red")).toString()); }
QColor       MapSettings::rubberbandFrameColor()          const { return s2c(m_settings.value(QLatin1String("rubberband/frameColor"), QLatin1String("black")).toString()); }
QColor       MapSettings::rubberbandFrameFillColor()      const { return s2c(m_settings.value(QLatin1String("rubberband/frameFillColor"), QLatin1String("#32969600")).toString()); }
int          MapSettings::rubberbandFrameHandleMargin()   const { return     m_settings.value(QLatin1String("rubberband/frameHandleMargin"), 10).toInt();    }
QPoint       MapSettings::rubberbandPreviewOffset()       const { return     m_settings.value(QLatin1String("rubberband/previewOffset"), QPoint(32, 32)).toPoint();   }
unsigned int MapSettings::rubberbandPreviewSize()         const { return     m_settings.value(QLatin1String("rubberband/previewSize"), 32).toUInt();    }
unsigned int MapSettings::rubberbandPickingRatio()        const { return     m_settings.value(QLatin1String("rubberband/pickingRatio"), 0).toUInt();    }
unsigned int MapSettings::rubberbandLineHandleWidth()     const { return     m_settings.value(QLatin1String("rubberband/lineHandleWidth"), 2).toUInt();    }


QString MapSettings::toString() const
{
  MapSettings *THIS = const_cast<MapSettings *>(this);

  std::ostringstream stream;
  stream << "symbologyTypeStr: " << this->symbologyTypeStr() << std::endl;
  stream << "symbologyType: "    << this->symbologyType() << std::endl;
  stream << "mapUrls: "          << THIS->mapUrls().join(QLatin1String(";")) << std::endl;
  stream << "operationalLayers: " << THIS->operationalLayers().join(QLatin1String(";")) << std::endl;

  stream << "centerPointMgrs: "     << this->centerPointMgrs() << std::endl;

  stream << "scale: "            << this->scale() << std::endl;
  stream << "minSscale: "        << this->minScale() << std::endl;
  stream << "maxScale: "         << this->maxScale() << std::endl;

  stream << "zoomFactorBase: "   << this->zoomFactorBase() << std::endl;

  stream << "gridStr: "          << this->gridStr() << std::endl;
  stream << "gridType: "         << this->gridType() << std::endl;

  stream << "viewShedUrl: "      << this->viewshedUrl() << std::endl;

  stream << "rubberbandDrawColor: "         << rubberbandDrawColor().name() << std::endl;
  stream << "rubberbandFillColor: "         << rubberbandFillColor().name() << std::endl;
  stream << "rubberbandHandleDrawColor: "   << rubberbandHandleDrawColor().name() << std::endl;
  stream << "rubberbandHandleFillColor: "   << rubberbandHandleFillColor().name() << std::endl;
  stream << "rubberbandSelectionColor: "    << rubberbandSelectionColor().name() << std::endl;
  stream << "rubberbandFrameColor: "        << rubberbandFrameColor().name() << std::endl;
  stream << "rubberbandFrameFillColor: "    << rubberbandFrameFillColor().name() << std::endl;
  stream << "rubberbandFrameHandleMargin: " << rubberbandFrameHandleMargin() << std::endl;
  stream << "rubberbandPreviewOffset: "     << rubberbandPreviewOffset() << std::endl;
  stream << "rubberbandPreviewSize: "       << rubberbandPreviewSize() << std::endl;
  stream << "rubberbandLineHandleWidth: "   << rubberbandLineHandleWidth() << std::endl;

  return QLatin1String(stream.str().c_str());
}


//-----------------------------------------------------------------------------
// output operator:
//-----------------------------------------------------------------------------
std::ostream &operator<< (std::ostream   &stream,
                          const MapSettings &value)
{
  stream << value.toString();
  return stream;
}


} // namespace SituationMap