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

// Own
#include "location_to_elevation_bulk.h"
#include <MapImpl/map_impl.h>
#include "Map/situation_map_utils.h"

#include "location_to_elevation_helper.h"  // to get define USE_ELEVATION_MAP_AS_WORKAROUND


// ESRI
#include <arcgis/Surface.h>
#include <arcgis/Point.h>


// Qt
#include <QPointer>
#include <QVector>


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

//----------------------------------------------------------------------------
class LocationToElevationBulk::Private
{
public:
  Private()     = default;
  ~Private()    = default;


  // ESRI data:
  QPointer<Esri::ArcGISRuntime::Surface>  m_surface;      // for ESRI-Surface-based calculation
  QPointer<Map>                           m_map;          // for ElevationMap-based calculation

  Esri::ArcGISRuntime::Point              m_location;

  Esri::ArcGISRuntime::SpatialReference   m_spatialReference;



  QVector<QSharedPointer<LocationData>>   m_locationDataCont;
  int                                     m_progressCount = 0;
};


//----------------------------------------------------------------------------
LocationToElevationBulk::LocationToElevationBulk(QObject *parent)
  : BaseClass(parent)
  , m_logger(getLogger("LocationToElevationBulk"))
  , d(new Private)
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
  reset();
  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
}

LocationToElevationBulk::~LocationToElevationBulk()
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
  this->stop();
  delete d;
  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
}

bool LocationToElevationBulk::init(Map *map, Esri::ArcGISRuntime::Surface *surface)
{
  this->reset();

  if (!map)
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << " no map";
    return false;
  }
  d->m_map = map;

  connect(d->m_map.data(), &Map::beginDestroy, this, &LocationToElevationBulk::stop);

  MapImpl *mapImpl = static_cast<MapImpl*>(d->m_map.data());
  d->m_spatialReference = mapImpl->getEsriSpatialReference();

  DEBUG_LOG(m_logger) << LOGFUNCTION << " m_spatialReference.wkid = " << d->m_spatialReference.wkid();

  // use ESRI-Surface-based OR ElevationMap-based:

#ifdef USE_ELEVATION_MAP_AS_WORKAROUND
  Q_UNUSED(surface);
  d->m_surface.clear();

  auto elevationMap = static_cast<MapImpl*>(d->m_map.data())->getElevationMapManager();
  if (!elevationMap)
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << " no ElevationMapManager";
    return false;
  }

#else
  d->m_surface = surface;
  if (!d->m_surface)
    return false;


  if (d->m_surface)
  {
    // be prepared in case of destruction:
    connect(d->m_surface.data(), &Esri::ArcGISRuntime::Surface::destroyed, this, &LocationToElevationBulk::stop);
  }
#endif // USE_ELEVATION_MAP_AS_WORKAROUND

  return true;
}

void LocationToElevationBulk::addLocation(const Esri::ArcGISRuntime::Point &esriMapLocation)
{
  d->m_locationDataCont.append(QSharedPointer<LocationData>(new LocationData(esriMapLocation)));
}

void LocationToElevationBulk::start()
{
  d->m_progressCount = 0;

#ifndef USE_ELEVATION_MAP_AS_WORKAROUND

  if (!d->m_surface || d->m_surface->loadStatus() != Esri::ArcGISRuntime::LoadStatus::Loaded)
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << " no surface or surface not loaded yet"
                        << " d->m_surface = " << d->m_surface.data();
    return;
  }
#endif // USE_ELEVATION_MAP_AS_WORKAROUND

  QMutableVectorIterator<QSharedPointer<LocationData>> vecIt(d->m_locationDataCont);
  while (vecIt.hasNext())
  {
    QSharedPointer<LocationData> ld = vecIt.next();
    if(!ld)
      continue;

#ifdef USE_ELEVATION_MAP_AS_WORKAROUND
    ld->setMap(d->m_map);
#else
    ld->setSurface(d->m_surface);
#endif // USE_ELEVATION_MAP_AS_WORKAROUND


    connect(ld.data(), &LocationData::elevationCompleted,
            this, &LocationToElevationBulk::onLocationDataCompleted, Qt::UniqueConnection);

    if (!ld->startLocationToElevation())
      ERROR_LOG(m_logger) << LOGFUNCTION << " startLocationToElevation failed";
  } // while
}


void LocationToElevationBulk::stop()
{
  QMutableVectorIterator<QSharedPointer<LocationData>> vecIt(d->m_locationDataCont);
  while (vecIt.hasNext())
  {
    QSharedPointer<LocationData> ld = vecIt.next();
    if(!ld)
      continue;
    if (!ld->cancel())
      INFO_LOG(m_logger) << LOGFUNCTION << " LocationData.cancel failed";
  } // while
}

void LocationToElevationBulk::reset()
{
  stop();
  d->m_locationDataCont.clear();
  d->m_progressCount = 0;
}

int LocationToElevationBulk::size() const
{
  return d->m_locationDataCont.size();
}

QVector<QPair<QPointF, double> > LocationToElevationBulk::results() const
{
  QVector<QPair<QPointF, double> > results;

  QVectorIterator<QSharedPointer<LocationData>> vecIt(d->m_locationDataCont);
  while (vecIt.hasNext())
  {
    QSharedPointer<LocationData> ld = vecIt.next();
    if(!ld)
      continue;

    const Esri::ArcGISRuntime::Point &location = ld->location();
    QPair<QPointF, double> pair(QPointF(location.x(), location.y()), ld->elevation());
    results.append(pair);
  }
  return results;
}

void LocationToElevationBulk::onLocationDataCompleted()
{
  ++d->m_progressCount;

  if (d->m_progressCount >= d->m_locationDataCont.size())
  {
    DEBUG_LOG(m_logger) << LOGFUNCTION << " emit locationsToElevationsCompleted";
    emit locationsToElevationsCompleted();
  }
}


} // namespace SituationMap