// SPDX-License-Identifier: LGPL-2.1-or-later
//
// SPDX-FileCopyrightText: 2014 Adam Dabrowski <adabrowski@piap.pl> <adamdbrw@gmail.com>
//


#include <MarbleQuickItem.h>
#include <QQuickWindow>
#include <QScreen>
#include <QPainter>
#include <QPaintDevice>
#include <QtMath>
#include <QQmlContext>
#include <QSettings>

#include <MarbleModel.h>
#include <MarbleMap.h>
#include <ViewportParams.h>
#include <GeoPainter.h>
#include <GeoDataLookAt.h>
#include <Planet.h>
#include <MarbleAbstractPresenter.h>
#include <AbstractFloatItem.h>
#include <MarbleInputHandler.h>
#include <PositionTracking.h>
#include <PositionProviderPlugin.h>
#include <PluginManager.h>
#include <RenderPlugin.h>
#include <MarbleMath.h>
#include <StyleBuilder.h>
#include <GeoDataLatLonAltBox.h>
#include <GeoDataCoordinates.h>
#include <ReverseGeocodingRunnerManager.h>
#include <routing/RoutingManager.h>
#include <routing/RoutingModel.h>
#include <routing/Route.h>
#include <BookmarkManager.h>
#include "GeoDataRelation.h"
#include "osm/OsmPlacemarkData.h"
#include "GeoDataDocument.h"
#include <geodata/parser/GeoSceneTypes.h>
#include <geodata/scene/GeoSceneDocument.h>
#include <geodata/scene/GeoSceneMap.h>
#include <geodata/scene/GeoSceneLayer.h>
#include <geodata/scene/GeoSceneTextureTileDataset.h>

namespace Marble
{
    //TODO - move to separate files
    class QuickItemSelectionRubber : public AbstractSelectionRubber
    { //TODO: support rubber selection in MarbleQuickItem
    public:
        QuickItemSelectionRubber();
        void show() override { m_visible = true; }
        void hide() override { m_visible = false; }
        bool isVisible() const override { return m_visible; }
        const QRect &geometry() const override { return m_geometry; }
        void setGeometry(const QRect &/*geometry*/) override {}
    private:
        QRect m_geometry;
        bool m_visible;
    };

    //TODO - implement missing functionalities
    class MarbleQuickInputHandler : public MarbleDefaultInputHandler
    {
    public:
        MarbleQuickInputHandler(MarbleAbstractPresenter *marblePresenter, MarbleQuickItem *marbleQuick)
            : MarbleDefaultInputHandler(marblePresenter)
            ,m_marbleQuick(marbleQuick)
        {
            setInertialEarthRotationEnabled(false); //Disabled by default, it's buggy. TODO - fix
        }

        bool acceptMouse() override
        {
            return true;
        }

        void pinch(QPointF center, qreal scale, Qt::GestureState state)
        {   //TODO - this whole thing should be moved to MarbleAbstractPresenter
            (void)handlePinch(center, scale, state);
        }

        void handleMouseButtonPressAndHold(const QPoint &position) override
        {
            m_marbleQuick->reverseGeocoding(position);
        }

    private Q_SLOTS:
        void showLmbMenu(int x, int y) override
        {
            m_marbleQuick->selectPlacemarkAt(x, y);
            emit m_marbleQuick->lmbMenuRequested(QPoint(x,y));
        }

        void showRmbMenu(int x, int y) override {
            emit m_marbleQuick->rmbMenuRequested(QPoint(x,y));
        }
        void openItemToolTip() override {}
        void setCursor(const QCursor &cursor) override
        {
            m_marbleQuick->setCursor(cursor);
        }

    private Q_SLOTS:
        void installPluginEventFilter(RenderPlugin *) override {}

    private:
        bool layersEventFilter(QObject *o, QEvent *e) override
        {
            return m_marbleQuick->layersEventFilter(o, e);
        }

        //empty - don't check. It would be invalid with quick items
        void checkReleasedMove(QMouseEvent *) override {}

        bool handleTouch(QTouchEvent *event) override
        {
            if (event->touchPoints().count() > 1)
            {   //not handling multi-touch at all, let PinchArea or MultiPointTouchArea take care of it
                return false;
            }

            if (event->touchPoints().count() == 1)
            {   //handle - but do not accept. I.e. pinchArea still needs to get this
                QTouchEvent::TouchPoint p = event->touchPoints().at(0);
                if (event->type() == QEvent::TouchBegin)
                {
                    QMouseEvent press(QMouseEvent::MouseButtonPress, p.pos(),
                                      Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
                    handleMouseEvent(&press);
                }
                else if (event->type() == QEvent::TouchUpdate)
                {
                    QMouseEvent move(QMouseEvent::MouseMove, p.pos(),
                                      Qt::NoButton, Qt::LeftButton, Qt::NoModifier);
                    handleMouseEvent(&move);
                }
                else if (event->type() == QEvent::TouchEnd)
                {
                    QMouseEvent release(QMouseEvent::MouseButtonRelease, p.pos(),
                                      Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
                    handleMouseEvent(&release);
                }
            }
            return false;
        }

        AbstractSelectionRubber *selectionRubber() override
        {
            return &m_selectionRubber;
        }

        MarbleQuickItem *m_marbleQuick;
        QuickItemSelectionRubber m_selectionRubber;
//        bool m_usePinchArea;
    };

    class MarbleQuickItemPrivate
    {
    public:
        explicit MarbleQuickItemPrivate(MarbleQuickItem *marble) :
            m_marble(marble),
            m_model(),
            m_map(&m_model),
            m_presenter(&m_map),
            m_positionVisible(false),
            m_currentPosition(marble),
            m_inputHandler(&m_presenter, marble),
            m_placemarkDelegate(nullptr),
            m_placemarkItem(nullptr),
            m_placemark(nullptr),
            m_reverseGeocoding(&m_model),
            m_showScaleBar(false),
            m_enabledRelationTypes(GeoDataRelation::RouteFerry |
                            GeoDataRelation::RouteTrain |
                            GeoDataRelation::RouteSubway |
                            GeoDataRelation::RouteTram |
                            GeoDataRelation::RouteBus |
                            GeoDataRelation::RouteTrolleyBus |
                            GeoDataRelation::RouteHiking),
            m_showPublicTransport(false),
            m_showOutdoorActivities(false),
            m_heading(0.0),
            m_hoverEnabled(false),
            m_invertColorEnabled(false)
        {
            m_currentPosition.setName(QObject::tr("Current Location"));
            m_relationTypeConverter["road"] = GeoDataRelation::RouteRoad;
            m_relationTypeConverter["detour"] = GeoDataRelation::RouteDetour;
            m_relationTypeConverter["ferry"] = GeoDataRelation::RouteFerry;
            m_relationTypeConverter["train"] = GeoDataRelation::RouteTrain;
            m_relationTypeConverter["subway"] = GeoDataRelation::RouteSubway;
            m_relationTypeConverter["tram"] = GeoDataRelation::RouteTram;
            m_relationTypeConverter["bus"] = GeoDataRelation::RouteBus;
            m_relationTypeConverter["trolley-bus"] = GeoDataRelation::RouteTrolleyBus;
            m_relationTypeConverter["bicycle"] = GeoDataRelation::RouteBicycle;
            m_relationTypeConverter["mountainbike"] = GeoDataRelation::RouteMountainbike;
            m_relationTypeConverter["foot"] = GeoDataRelation::RouteFoot;
            m_relationTypeConverter["hiking"] = GeoDataRelation::RouteHiking;
            m_relationTypeConverter["horse"] = GeoDataRelation::RouteHorse;
            m_relationTypeConverter["inline-skates"] = GeoDataRelation::RouteInlineSkates;
            m_relationTypeConverter["downhill"] = GeoDataRelation::RouteSkiDownhill;
            m_relationTypeConverter["ski-nordic"] = GeoDataRelation::RouteSkiNordic;
            m_relationTypeConverter["skitour"] = GeoDataRelation::RouteSkitour;
            m_relationTypeConverter["sled"] = GeoDataRelation::RouteSled;
        }

        void updateVisibleRoutes();
        void changeBlending(bool enabled, const QString &blendingName);
        void changeStyleBuilder(bool invert);

    private:
        MarbleQuickItem *m_marble;
        friend class MarbleQuickItem;
        MarbleModel m_model;
        MarbleMap m_map;
        Marble::MapTheme m_mapTheme;
        MarbleAbstractPresenter m_presenter;
        bool m_positionVisible;
        Placemark m_currentPosition;

        MarbleQuickInputHandler m_inputHandler;
        QQmlComponent* m_placemarkDelegate;
        QQuickItem* m_placemarkItem;
        Placemark* m_placemark;
        ReverseGeocodingRunnerManager m_reverseGeocoding;

        bool m_showScaleBar;
        QMap<QString, GeoDataRelation::RelationType> m_relationTypeConverter;
        GeoDataRelation::RelationTypes m_enabledRelationTypes;
        bool m_showPublicTransport;
        bool m_showOutdoorActivities;
        qreal m_heading;
        bool m_hoverEnabled;
        bool m_invertColorEnabled;
    };

    MarbleQuickItem::MarbleQuickItem(QQuickItem *parent) : QQuickPaintedItem(parent)
      ,d(new MarbleQuickItemPrivate(this))
    {
        setRenderTarget(QQuickPaintedItem::FramebufferObject);
        setOpaquePainting(true);
        qRegisterMetaType<Placemark*>("Placemark*");
        d->m_map.setMapQualityForViewContext(NormalQuality, Animation);

        for (AbstractFloatItem *item: d->m_map.floatItems()) {
            if (item->nameId() == QLatin1String("license")) {
                item->setPosition(QPointF(5.0, -10.0));
            } else {
                item->hide();
            }
        }

        d->m_model.positionTracking()->setTrackVisible(false);
        d->m_mapTheme.setMap(this);

        connect(&d->m_map, SIGNAL(repaintNeeded(QRegion)), this, SLOT(update()));
        connect(this, &MarbleQuickItem::widthChanged, this, &MarbleQuickItem::resizeMap);
        connect(this, &MarbleQuickItem::heightChanged, this, &MarbleQuickItem::resizeMap);
        connect(&d->m_map, &MarbleMap::visibleLatLonAltBoxChanged, this, &MarbleQuickItem::updatePositionVisibility);
        connect(&d->m_map, &MarbleMap::radiusChanged, this, &MarbleQuickItem::radiusChanged);
        connect(&d->m_map, &MarbleMap::radiusChanged, this, &MarbleQuickItem::zoomChanged);
        connect(&d->m_reverseGeocoding, SIGNAL(reverseGeocodingFinished(GeoDataCoordinates,GeoDataPlacemark)),
                this, SLOT(handleReverseGeocoding(GeoDataCoordinates,GeoDataPlacemark)));
        connect(&d->m_map, &MarbleMap::visibleLatLonAltBoxChanged, this, &MarbleQuickItem::handleVisibleLatLonAltBoxChanged);
        connect(d->m_map.model(), &MarbleModel::workOfflineChanged, this, &MarbleQuickItem::workOfflineChanged);

        setAcceptedMouseButtons(Qt::AllButtons);
        installEventFilter(&d->m_inputHandler);
    }

    void MarbleQuickItem::resizeMap()
    {

        d->m_map.setSize(qMax(100, int(width())), qMax(100, int(height())));
        update();
        updatePositionVisibility();
    }

    void MarbleQuickItem::positionDataStatusChanged(PositionProviderStatus status)
    {
        bool const positionAvailable = status == PositionProviderStatusAvailable;
        emit positionAvailableChanged(positionAvailable);
        updatePositionVisibility();
    }

    void MarbleQuickItem::positionChanged(const GeoDataCoordinates &, GeoDataAccuracy)
    {
       updatePositionVisibility();
    }

    void MarbleQuickItem::updatePositionVisibility()
    {
        updatePlacemarks();
        bool isVisible = false;
        if ( positionAvailable() ) {
            qreal x, y;
            bool globeHidesPoint;
            bool const valid = d->m_map.viewport()->screenCoordinates(d->m_model.positionTracking()->currentLocation(), x, y, globeHidesPoint);
            isVisible = valid && !globeHidesPoint;
        }

        if ( isVisible != d->m_positionVisible ) {
            d->m_positionVisible = isVisible;
            emit positionVisibleChanged( isVisible );
        }
    }

    void MarbleQuickItem::updateCurrentPosition(const GeoDataCoordinates &coordinates)
    {
        d->m_currentPosition.placemark().setCoordinate(coordinates);
        emit currentPositionChanged(&d->m_currentPosition);
    }

    void MarbleQuickItem::updatePlacemarks()
    {
        if (!d->m_placemarkDelegate || !d->m_placemark) {
            return;
        }

        if (!d->m_placemarkItem) {
            QQmlContext * context = new QQmlContext(qmlContext(d->m_placemarkDelegate));
            QObject * component = d->m_placemarkDelegate->create(context);
            d->m_placemarkItem = qobject_cast<QQuickItem*>( component );
            if (d->m_placemarkItem) {
                d->m_placemarkItem->setParentItem( this );
                d->m_placemarkItem->setProperty("placemark", QVariant::fromValue(d->m_placemark));
            } else {
                delete component;
                return;
            }
        }

        qreal x = 0;
        qreal y = 0;
        const bool visible = d->m_map.viewport()->screenCoordinates(d->m_placemark->placemark().coordinate(), x, y);
        d->m_placemarkItem->setVisible(visible);
        if (visible) {
            d->m_placemarkItem->setProperty("xPos", QVariant(x));
            d->m_placemarkItem->setProperty("yPos", QVariant(y));
        }
    }

    void MarbleQuickItem::handleReverseGeocoding(const GeoDataCoordinates &coordinates, const GeoDataPlacemark &placemark)
    {
        if (d->m_placemark && d->m_placemark->placemark().coordinate() == coordinates) {
            d->m_placemark->setGeoDataPlacemark(placemark);
            updatePlacemarks();
        }
    }

    void MarbleQuickItem::handleVisibleLatLonAltBoxChanged(const GeoDataLatLonAltBox &latLonAltBox)
    {
        Q_UNUSED(latLonAltBox)

        if (d->m_heading != d->m_map.heading()) {
            d->m_heading = d->m_map.heading();
            emit headingChanged(d->m_heading);
        }
        emit visibleLatLonAltBoxChanged();
        emit geoItemUpdateRequested();
    }

    void MarbleQuickItem::paint(QPainter *painter)
    {   //TODO - much to be done here still, i.e paint !enabled version
        QPaintDevice * paintDevice = painter->device();
        QRect rect = contentsBoundingRect().toRect();

        painter->end();
        {
            GeoPainter geoPainter(paintDevice, d->m_map.viewport(), d->m_map.mapQuality());

            double scale = 1.0;
            // For HighDPI displays take QT_SCALE_FACTOR into account:
            QQuickWindow * window = this->window();
            if (window) {
                QScreen * screen = window->screen();
                scale = screen != nullptr ? screen->devicePixelRatio() : 1.0;
                if (scale != 1) {
                    geoPainter.scale(scale, scale);
                }
            }

            d->m_map.paint(geoPainter, rect);
        }
        painter->begin(paintDevice);
    }

    void MarbleQuickItem::classBegin()
    {
    }

    void MarbleQuickItem::componentComplete()
    {
    }

    void Marble::MarbleQuickItem::MarbleQuickItem::hoverMoveEvent(QHoverEvent *event) {
        if (d->m_hoverEnabled) {
            emit hoverPositionChanged(event->pos());
        }
        QQuickItem::hoverMoveEvent(event);
    }

    int MarbleQuickItem::mapWidth() const
    {
        return d->m_map.width();
    }

    int MarbleQuickItem::mapHeight() const
    {
        return d->m_map.height();
    }

    bool MarbleQuickItem::showFrameRate() const
    {
        return d->m_map.showFrameRate();
    }

    MarbleQuickItem::Projection MarbleQuickItem::projection() const
    {
        return Projection(d->m_map.projection());
    }

    QString MarbleQuickItem::mapThemeId() const
    {
        return d->m_map.mapThemeId();
    }

    Marble::MapTheme *MarbleQuickItem::mapTheme() const
    {
        return &d->m_mapTheme;
    }

    bool MarbleQuickItem::showAtmosphere() const
    {
        return d->m_map.showAtmosphere();
    }

    bool MarbleQuickItem::showCompass() const
    {
        return d->m_map.showCompass();
    }

    bool MarbleQuickItem::showClouds() const
    {
        return d->m_map.showClouds();
    }

    bool MarbleQuickItem::showCrosshairs() const
    {
        return d->m_map.showCrosshairs();
    }

    bool MarbleQuickItem::showGrid() const
    {
        return d->m_map.showGrid();
    }

    bool MarbleQuickItem::showOverviewMap() const
    {
        return d->m_map.showOverviewMap();
    }

    bool MarbleQuickItem::showOtherPlaces() const
    {
        return d->m_map.showOtherPlaces();
    }

    bool MarbleQuickItem::showScaleBar() const
    {
        return d->m_showScaleBar;
    }

    bool MarbleQuickItem::showBackground() const
    {
        return d->m_map.showBackground();
    }

    bool MarbleQuickItem::showPositionMarker() const
    {
        QList<RenderPlugin *> plugins = d->m_map.renderPlugins();
        for (const RenderPlugin * plugin: plugins) {
            if (plugin->nameId() == QLatin1String("positionMarker")) {
                return plugin->visible();
            }
        }
        return false;
    }

    bool MarbleQuickItem::showPublicTransport() const
    {
        return d->m_showPublicTransport;
    }

    bool MarbleQuickItem::showOutdoorActivities() const
    {
        return d->m_showOutdoorActivities;
    }

    QString MarbleQuickItem::positionProvider() const
    {
        if ( d->m_model.positionTracking()->positionProviderPlugin() ) {
            return d->m_model.positionTracking()->positionProviderPlugin()->nameId();
        }

        return QString();
    }

    MarbleModel* MarbleQuickItem::model()
    {
        return &d->m_model;
    }

    const MarbleModel* MarbleQuickItem::model() const
    {
        return &d->m_model;
    }

    MarbleMap* MarbleQuickItem::map()
    {
        return &d->m_map;
    }

    const MarbleMap* MarbleQuickItem::map() const
    {
        return &d->m_map;
    }

    bool MarbleQuickItem::inertialGlobeRotation() const
    {
        return d->m_inputHandler.inertialEarthRotationEnabled();
    }

    bool MarbleQuickItem::animationViewContext() const
    {
        return d->m_map.viewContext() == Animation;
    }

    bool MarbleQuickItem::animationsEnabled() const
    {
        return d->m_presenter.animationsEnabled();
    }

    QQmlComponent *MarbleQuickItem::placemarkDelegate() const
    {
        return d->m_placemarkDelegate;
    }

    void MarbleQuickItem::reverseGeocoding(const QPoint &point)
    {
        qreal lon, lat;
        d->m_map.viewport()->geoCoordinates(point.x(), point.y(), lon, lat);
        auto const coordinates = GeoDataCoordinates(lon, lat, 0.0, GeoDataCoordinates::Degree);
        delete d->m_placemarkItem;
        d->m_placemarkItem = nullptr;
        delete d->m_placemark;
        d->m_placemark = new Placemark(this);
        d->m_placemark->placemark().setCoordinate(coordinates);
        d->m_reverseGeocoding.reverseGeocoding(coordinates);
    }

    bool MarbleQuickItem::hoverEnabled() const
    {
        return d->m_hoverEnabled;
    }

    void MarbleQuickItem::moveUp()
    {
        d->m_presenter.moveByStep( 0, -1, Marble::Linear );
    }

    void MarbleQuickItem::moveDown()
    {
        d->m_presenter.moveByStep( 0, 1, Marble::Linear );
    }

    void MarbleQuickItem::moveLeft()
    {
        d->m_presenter.moveByStep( -1, 0, Marble::Linear );
    }

    void MarbleQuickItem::moveRight()
    {
        d->m_presenter.moveByStep( 1, 0, Marble::Linear );
    }

    qreal MarbleQuickItem::speed() const
    {
        return d->m_model.positionTracking()->speed();
    }

    qreal MarbleQuickItem::angle() const
    {
        bool routeExists = d->m_model.routingManager()->routingModel()->route().distance() != 0.0;
        bool onRoute = !d->m_model.routingManager()->routingModel()->deviatedFromRoute();
        if ( routeExists && onRoute) {
            GeoDataCoordinates curPoint = d->m_model.positionTracking()->positionProviderPlugin()->position();
            return d->m_model.routingManager()->routingModel()->route().currentSegment().projectedDirection(curPoint);
        } else {
            return d->m_model.positionTracking()->direction();
        }
    }

    bool MarbleQuickItem::positionAvailable() const
    {
        return d->m_model.positionTracking()->status() == PositionProviderStatusAvailable;
    }

    bool MarbleQuickItem::positionVisible() const
    {
        return d->m_positionVisible;
    }

    qreal MarbleQuickItem::distanceFromPointToCurrentLocation(const QPoint & position) const
    {
        if ( positionAvailable() ) {
            qreal lon1;
            qreal lat1;
            d->m_map.viewport()->geoCoordinates(position.x(), position.y(), lon1, lat1, GeoDataCoordinates::Radian );

            GeoDataCoordinates currentCoordinates = d->m_model.positionTracking()->currentLocation();
            qreal lon2 = currentCoordinates.longitude();
            qreal lat2 = currentCoordinates.latitude();

            return distanceSphere(lon1, lat1, lon2, lat2) * d->m_model.planetRadius();
        }
        return 0;
    }

    qreal MarbleQuickItem::angleFromPointToCurrentLocation( const QPoint & position ) const
    {
        if ( positionAvailable() ) {
            qreal x, y;
            PositionTracking const * positionTracking = d->m_model.positionTracking();
            map()->viewport()->screenCoordinates( positionTracking->currentLocation(), x, y );
            return atan2( y-position.y(), x-position.x() ) * RAD2DEG;
        }
        return 0;
    }

    Placemark * MarbleQuickItem::currentPosition() const
    {
        return &d->m_currentPosition;
    }

    QPointF MarbleQuickItem::screenCoordinatesFromCoordinate(Coordinate * coordinate) const
    {
        qreal x, y;
        bool globeHidesPoint;
        bool const valid = d->m_map.viewport()->screenCoordinates(coordinate->coordinates(), x, y, globeHidesPoint);
        bool isVisible = valid && !globeHidesPoint;
        return isVisible ? QPointF(x, y) : QPointF();
    }

    QPointF MarbleQuickItem::screenCoordinatesFromGeoDataCoordinates(const GeoDataCoordinates & coordinates) const
    {
        qreal x, y;
        bool globeHidesPoint;
        d->m_map.viewport()->screenCoordinates(coordinates, x, y, globeHidesPoint);
        return !globeHidesPoint ? QPointF(x, y) : QPointF();
    }

    bool MarbleQuickItem::screenCoordinatesFromGeoDataLineString(const GeoDataLineString &lineString, QVector<QPolygonF *> &polygons) const
    {
        return d->m_map.viewport()->screenCoordinates(lineString, polygons);
    }

    bool MarbleQuickItem::screenCoordinatesToCoordinate(const QPoint & point, Coordinate * coordinate)
    {
        GeoDataCoordinates geoDataCoordinates;
        bool success = screenCoordinatesToGeoDataCoordinates(point, geoDataCoordinates);
        if (!qobject_cast<Coordinate*>(coordinate)){
            Coordinate * tmp(coordinate);
            coordinate = new Coordinate(geoDataCoordinates.longitude(), geoDataCoordinates.latitude(), 0, nullptr);
            QQmlEngine::setObjectOwnership(coordinate, QQmlEngine::JavaScriptOwnership);
            delete tmp;
        }
        else {
            coordinate->setLongitude(geoDataCoordinates.longitude());
            coordinate->setLatitude(geoDataCoordinates.latitude());
        }

        return success;
    }

    bool MarbleQuickItem::screenCoordinatesToGeoDataCoordinates(const QPoint & point, GeoDataCoordinates & coordinates)
    {
        qreal lon = 0.0 , lat = 0.0;
        bool const valid = d->m_map.viewport()->geoCoordinates(point.x(), point.y(), lon, lat);
        coordinates.setLongitude(lon);
        coordinates.setLatitude(lat);
        return valid;
    }

    void MarbleQuickItem::setRadius(int radius)
    {
        d->m_map.setRadius(radius);
    }

    void MarbleQuickItem::setHeading(qreal heading)
    {
        if (qFuzzyCompare(d->m_heading, heading))
            return;

        d->m_map.setHeading(heading);
        d->m_heading = heading;

        emit headingChanged(d->m_heading);
    }

    void MarbleQuickItem::setHoverEnabled(bool hoverEnabled)
    {
        if (d->m_hoverEnabled == hoverEnabled)
            return;

        d->m_hoverEnabled = hoverEnabled;

        setAcceptHoverEvents(hoverEnabled);
        setFlag(ItemAcceptsInputMethod, hoverEnabled);

        emit hoverEnabledChanged(d->m_hoverEnabled);
    }

    void MarbleQuickItem::setZoom(int newZoom, FlyToMode mode)
    {
        d->m_presenter.setZoom(newZoom, mode);
    }

    void MarbleQuickItem::setZoomToMaximumLevel()
    {
        d->m_presenter.setZoom(d->m_map.maximumZoom());
    }

    void MarbleQuickItem::centerOn(const GeoDataPlacemark& placemark, bool animated)
    {
        d->m_presenter.centerOn(placemark, animated);
    }

    void MarbleQuickItem::centerOn(const GeoDataLatLonBox& box, bool animated)
    {
        d->m_presenter.centerOn(box, animated);
    }

    void MarbleQuickItem::centerOn(const GeoDataCoordinates &coordinate)
    {
        GeoDataLookAt target = d->m_presenter.lookAt();
        target.setCoordinates(coordinate);
        d->m_presenter.flyTo(target, Automatic);
    }

    void MarbleQuickItem::centerOn(qreal longitude, qreal latitude)
    {
        d->m_presenter.centerOn(longitude, latitude);
    }

    void MarbleQuickItem::centerOnCoordinates(qreal longitude, qreal latitude) {
        centerOn(longitude, latitude);
    }

    void MarbleQuickItem::centerOnCurrentPosition()
    {
        GeoDataCoordinates coordinates = d->m_model.positionTracking()->currentLocation();
        if ( coordinates == GeoDataCoordinates() ) {
            return;
        }

        d->m_presenter.centerOn(coordinates, true);
        if (d->m_presenter.zoom() < 3000) {
            d->m_presenter.setZoom(3500);
        }
    }

    void MarbleQuickItem::selectPlacemarkAt(int x, int y)
    {
        auto features = d->m_map.whichFeatureAt(QPoint(x, y));
        QVector<GeoDataPlacemark const *> placemarks;
        for(auto feature: features) {
            if (const auto placemark = geodata_cast<GeoDataPlacemark>(feature)) {
                placemarks << placemark;
            }
        }

        for(auto placemark: placemarks) {
            if (d->m_placemark && placemark->coordinate() == d->m_placemark->placemark().coordinate()) {
                d->m_placemark->deleteLater();
                d->m_placemark = nullptr;
            } else {
                if (d->m_placemark) {
                    d->m_placemark->deleteLater();
                }
                d->m_placemark = new Placemark(this);
                d->m_placemark->setGeoDataPlacemark(*placemark);
            }
            delete d->m_placemarkItem;
            d->m_placemarkItem = nullptr;
            updatePlacemarks();
            return;
        }

        if (d->m_placemark) {
            d->m_placemark->deleteLater();
            d->m_placemark = nullptr;
            delete d->m_placemarkItem;
            d->m_placemarkItem = nullptr;
            updatePlacemarks();
        }
    }

    void MarbleQuickItem::goHome()
    {
        d->m_presenter.goHome();
    }

    void MarbleQuickItem::zoomIn(FlyToMode mode)
    {
        d->m_presenter.zoomIn(mode);
    }

    void MarbleQuickItem::zoomOut(FlyToMode mode)
    {
        d->m_presenter.zoomOut(mode);
    }

    void MarbleQuickItem::handlePinchStarted(const QPointF &point)
    {
        pinch(point, 1, Qt::GestureStarted);
    }

    void MarbleQuickItem::handlePinchFinished(const QPointF &point)
    {
        pinch(point, 1, Qt::GestureFinished);
    }

    void MarbleQuickItem::handlePinchUpdated(const QPointF &point, qreal scale)
    {
        scale = sqrt(sqrt(scale));
        scale = qBound(static_cast<qreal>(0.5), scale, static_cast<qreal>(2.0));
        pinch(point, scale, Qt::GestureUpdated);
    }

    void MarbleQuickItem::setMapWidth(int mapWidth)
    {
        if (d->m_map.width() == mapWidth) {
            return;
        }

        d->m_map.setSize(mapWidth, mapHeight());
        emit mapWidthChanged(mapWidth);
    }

    void MarbleQuickItem::setMapHeight(int mapHeight)
    {
        if (this->mapHeight() == mapHeight) {
            return;
        }

        d->m_map.setSize(mapWidth(), mapHeight);
        emit mapHeightChanged(mapHeight);
    }

    void MarbleQuickItem::setShowFrameRate(bool showFrameRate)
    {
        if (this->showFrameRate() == showFrameRate) {
            return;
        }

        d->m_map.setShowFrameRate(showFrameRate);
        emit showFrameRateChanged(showFrameRate);
    }

    void MarbleQuickItem::setProjection(Projection projection)
    {
        if (this->projection() == projection) {
            return;
        }

        d->m_map.setProjection(Marble::Projection(projection));
        emit projectionChanged(projection);
    }

    void MarbleQuickItem::setMapThemeId(const QString& mapThemeId)
    {
        if (this->mapThemeId() == mapThemeId) {
            return;
        }

        bool invertColor = invertColorEnabled();

        bool const showCompass = d->m_map.showCompass();
        bool const showOverviewMap = d->m_map.showOverviewMap();
        bool const showOtherPlaces = d->m_map.showOtherPlaces();
        bool const showGrid = d->m_map.showGrid();

        d->m_map.setMapThemeId(mapThemeId);

        // Map themes are allowed to change properties. Enforce ours.
        d->m_map.setShowCompass(showCompass);
        d->m_map.setShowOverviewMap(showOverviewMap);
        d->m_map.setShowOtherPlaces(showOtherPlaces);
        d->m_map.setShowGrid(showGrid);
        d->m_map.setShowScaleBar(d->m_showScaleBar);

        emit mapThemeIdChanged(mapThemeId);

        setInvertColorEnabled(invertColor);
    }

    void MarbleQuickItem::setShowAtmosphere(bool showAtmosphere)
    {
        if (this->showAtmosphere() == showAtmosphere) {
            return;
        }

        d->m_map.setShowAtmosphere(showAtmosphere);
        emit showAtmosphereChanged(showAtmosphere);
    }

    void MarbleQuickItem::setShowCompass(bool showCompass)
    {
        if (this->showCompass() == showCompass) {
            return;
        }

        d->m_map.setShowCompass(showCompass);
        emit showCompassChanged(showCompass);
    }

    void MarbleQuickItem::setShowClouds(bool showClouds)
    {
        if (this->showClouds() == showClouds) {
            return;
        }

        d->m_map.setShowClouds(showClouds);
        emit showCloudsChanged(showClouds);
    }

    void MarbleQuickItem::setShowCrosshairs(bool showCrosshairs)
    {
        if (this->showCrosshairs() == showCrosshairs) {
            return;
        }

        d->m_map.setShowCrosshairs(showCrosshairs);
        emit showCrosshairsChanged(showCrosshairs);
    }

    void MarbleQuickItem::setShowGrid(bool showGrid)
    {
        if (this->showGrid() == showGrid) {
            return;
        }

        d->m_map.setShowGrid(showGrid);
        emit showGridChanged(showGrid);
    }

    void MarbleQuickItem::setShowOverviewMap(bool showOverviewMap)
    {
        if (this->showOverviewMap() == showOverviewMap) {
            return;
        }

        d->m_map.setShowOverviewMap(showOverviewMap);
        emit showOverviewMapChanged(showOverviewMap);
    }

    void MarbleQuickItem::setShowOtherPlaces(bool showOtherPlaces)
    {
        if (this->showOtherPlaces() == showOtherPlaces) {
            return;
        }

        d->m_map.setShowOtherPlaces(showOtherPlaces);
        emit showOtherPlacesChanged(showOtherPlaces);
    }

    void MarbleQuickItem::setShowScaleBar(bool showScaleBar)
    {
        if (d->m_showScaleBar == showScaleBar) {
            return;
        }

        d->m_showScaleBar = showScaleBar;
        d->m_map.setShowScaleBar(d->m_showScaleBar);
        emit showScaleBarChanged(showScaleBar);
    }

    void MarbleQuickItem::setShowBackground(bool showBackground)
    {
        if (this->showBackground() == showBackground) {
            return;
        }

        d->m_map.setShowBackground(showBackground);
        emit showBackgroundChanged(showBackground);
    }

    void MarbleQuickItem::setShowPositionMarker(bool showPositionMarker)
    {
        if (this->showPositionMarker() == showPositionMarker) {
            return;
        }

        QList<RenderPlugin *> plugins = d->m_map.renderPlugins();
        for ( RenderPlugin * plugin: plugins ) {
            if (plugin->nameId() == QLatin1String("positionMarker")) {
                plugin->setVisible(showPositionMarker);
                break;
            }
        }

        emit showPositionMarkerChanged(showPositionMarker);
    }

    void MarbleQuickItem::setShowPublicTransport(bool enabled)
    {
        if (d->m_showPublicTransport != enabled) {
            d->m_showPublicTransport = enabled;
            d->updateVisibleRoutes();
            emit showPublicTransportChanged(enabled);
        }
    }

    void MarbleQuickItem::setShowOutdoorActivities(bool showOutdoorActivities)
    {
        if (d->m_showOutdoorActivities != showOutdoorActivities) {
            d->m_showOutdoorActivities = showOutdoorActivities;
            d->updateVisibleRoutes();
            emit showOutdoorActivitiesChanged(showOutdoorActivities);
        }
    }

    void MarbleQuickItem::setPositionProvider(const QString &positionProvider)
    {
        QString name;
        if ( d->m_model.positionTracking()->positionProviderPlugin() ) {
            name = d->m_model.positionTracking()->positionProviderPlugin()->nameId();
            if ( name == positionProvider ) {
                return;
            }
        }

        if ( positionProvider.isEmpty() ) {
            d->m_model.positionTracking()->setPositionProviderPlugin( nullptr );
            return;
        }

        QList<const PositionProviderPlugin*> plugins = d->m_model.pluginManager()->positionProviderPlugins();
        for (const PositionProviderPlugin* plugin: plugins) {
            if ( plugin->nameId() == positionProvider) {
                PositionProviderPlugin * newPlugin = plugin->newInstance();
                d->m_model.positionTracking()->setPositionProviderPlugin(newPlugin);
                connect(newPlugin, SIGNAL(statusChanged(PositionProviderStatus)), this, SLOT(positionDataStatusChanged(PositionProviderStatus)));
                connect(newPlugin, SIGNAL(positionChanged(GeoDataCoordinates,GeoDataAccuracy)), this, SLOT(updateCurrentPosition(GeoDataCoordinates)));
                connect(newPlugin, SIGNAL(positionChanged(GeoDataCoordinates,GeoDataAccuracy)), this, SIGNAL(speedChanged()));
                connect(newPlugin, SIGNAL(positionChanged(GeoDataCoordinates,GeoDataAccuracy)), this, SIGNAL(angleChanged()));
                emit positionProviderChanged(positionProvider);
                break;
            }
        }
    }

    void MarbleQuickItem::setInertialGlobeRotation(bool inertialGlobeRotation)
    {
        if (inertialGlobeRotation == d->m_inputHandler.inertialEarthRotationEnabled()) {
            return;
        }

        d->m_inputHandler.setInertialEarthRotationEnabled(inertialGlobeRotation);
        emit inertialGlobeRotationChanged(inertialGlobeRotation);
    }

    void MarbleQuickItem::setAnimationViewContext(bool animationViewContext)
    {
        d->m_map.setViewContext(animationViewContext ? Animation : Still );

        emit inertialGlobeRotationChanged(animationViewContext);
    }

    void MarbleQuickItem::setAnimationsEnabled(bool animationsEnabled)
    {
        if (d->m_presenter.animationsEnabled() == animationsEnabled)
            return;

        d->m_presenter.setAnimationsEnabled(animationsEnabled);
        emit animationsEnabledChanged(d->m_presenter.animationsEnabled());
    }

    void MarbleQuickItem::setPluginSetting(const QString &pluginId, const QString &key, const QString &value)
    {
        for (RenderPlugin* plugin: d->m_map.renderPlugins()) {
            if (plugin->nameId() == pluginId) {
                plugin->setSetting(key, value);
            }
        }
    }

    void MarbleQuickItem::setPropertyEnabled(const QString &property, bool enabled)
    {
        d->m_map.setPropertyValue(property, enabled);
    }

    bool MarbleQuickItem::isPropertyEnabled(const QString &property) const
    {
        return d->m_map.propertyValue(property);
    }

    void MarbleQuickItem::setWorkOffline(bool enabled)
    {
        if (d->m_map.model()->workOffline() == enabled)
            return;

        else {
            d->m_map.model()->setWorkOffline(enabled);
        }
    }

    void MarbleQuickItem::setInvertColorEnabled(bool enabled, const QString &blendingName)
    {
        d->changeBlending(enabled, blendingName);

        d->changeStyleBuilder(enabled);

        if (d->m_invertColorEnabled == enabled)
            return;

        d->m_invertColorEnabled = enabled;

        emit invertColorEnabledChanged(d->m_invertColorEnabled);
    }

    bool MarbleQuickItem::invertColorEnabled()
    {
        return d->m_invertColorEnabled;
    }

    bool MarbleQuickItem::workOffline()
    {
        return d->m_map.model()->workOffline();
    }

    void MarbleQuickItem::setShowRuntimeTrace(bool showRuntimeTrace)
    {
        d->m_map.setShowRuntimeTrace(showRuntimeTrace);
        update();
    }

    void MarbleQuickItem::setShowDebugPolygons(bool showDebugPolygons)
    {
        d->m_map.setShowDebugPolygons(showDebugPolygons);
        update();
    }

    void MarbleQuickItem::setShowDebugPlacemarks(bool showDebugPlacemarks)
    {
        d->m_map.setShowDebugPlacemarks(showDebugPlacemarks);
        update();
    }

    void MarbleQuickItem::setShowDebugBatches(bool showDebugBatches)
    {
        d->m_map.setShowDebugBatchRender(showDebugBatches);
        update();
    }

    void MarbleQuickItem::setPlacemarkDelegate(QQmlComponent *placemarkDelegate)
    {
        if (d->m_placemarkDelegate == placemarkDelegate) {
            return;
        }

        delete d->m_placemarkItem;
        d->m_placemarkItem = nullptr;
        d->m_placemarkDelegate = placemarkDelegate;
        emit placemarkDelegateChanged(placemarkDelegate);
    }

    void MarbleQuickItem::loadSettings()
    {
        QSettings settings;
        settings.beginGroup(QStringLiteral("MarbleQuickItem"));
        double lon = settings.value(QStringLiteral("centerLon"), QVariant(0.0)).toDouble();
        double lat = settings.value(QStringLiteral("centerLat"), QVariant(0.0)).toDouble();
        if (lat == 0.0 && lon == 0.0) {
            centerOnCurrentPosition();
        } else {
            centerOn(lon, lat);
        }
        int const zoom = settings.value(QStringLiteral("zoom"), QVariant(0)).toInt();
        if (zoom > 0) {
            setZoom(zoom);
        }
        auto const defaultRelationTypes = QStringList() << "ferry" << "train" << "subway" << "tram" << "bus" << "trolley-bus" << "hiking";
        auto const visibleRelationTypes = settings.value(QStringLiteral("visibleRelationTypes"), defaultRelationTypes).toStringList();
        d->m_enabledRelationTypes = GeoDataRelation::UnknownType;
        for (auto const &route: visibleRelationTypes) {
            d->m_enabledRelationTypes |= d->m_relationTypeConverter.value(route, GeoDataRelation::UnknownType);
        }
        setShowPublicTransport(settings.value(QStringLiteral("showPublicTransport"), false).toBool());
        setShowOutdoorActivities(settings.value(QStringLiteral("showOutdoorActivities"), false).toBool());
        settings.endGroup();
        d->m_model.routingManager()->readSettings();
        d->m_model.bookmarkManager()->loadFile(QStringLiteral("bookmarks/bookmarks.kml"));
        d->m_model.bookmarkManager()->setShowBookmarks(true);
        d->updateVisibleRoutes();
    }

    void MarbleQuickItem::writeSettings()
    {
        QSettings settings;
        settings.beginGroup(QStringLiteral("MarbleQuickItem"));
        settings.setValue(QStringLiteral("centerLon"), QVariant(d->m_map.centerLongitude()));
        settings.setValue(QStringLiteral("centerLat"), QVariant(d->m_map.centerLatitude()));
        settings.setValue(QStringLiteral("zoom"), QVariant(zoom()));
        QStringList enabledRoutes;
        QMap<GeoDataRelation::RelationType, QString> relationConverter;
        for (auto iter = d->m_relationTypeConverter.cbegin(), end = d->m_relationTypeConverter.cend(); iter != end; ++iter) {
            relationConverter[iter.value()] = iter.key();
        }
        for (auto iter = relationConverter.cbegin(), end = relationConverter.cend(); iter != end; ++iter) {
            if (d->m_enabledRelationTypes & iter.key()) {
                enabledRoutes << iter.value();
            }
        }
        settings.setValue(QStringLiteral("visibleRelationTypes"), enabledRoutes);
        settings.setValue(QStringLiteral("showPublicTransport"), d->m_showPublicTransport);
        settings.setValue(QStringLiteral("showOutdoorActivities"), d->m_showOutdoorActivities);

        settings.endGroup();
        d->m_model.routingManager()->writeSettings();
    }

    void MarbleQuickItem::reloadTiles()
    {
        d->m_map.reload();
    }

    void MarbleQuickItem::highlightRouteRelation(qint64 osmId, bool enabled)
    {
        d->m_map.highlightRouteRelation(osmId, enabled);
    }

    void MarbleQuickItem::setRelationTypeVisible(const QString &relationType, bool visible)
    {
        auto const relation = d->m_relationTypeConverter.value(relationType, GeoDataRelation::UnknownType);
        if (visible) {
            d->m_enabledRelationTypes |= relation;
        } else {
            d->m_enabledRelationTypes &= ~relation;
        }
        d->updateVisibleRoutes();
    }

    bool MarbleQuickItem::isRelationTypeVisible(const QString &relationType) const
    {
        auto const relation = d->m_relationTypeConverter.value(relationType, GeoDataRelation::UnknownType);
        return d->m_enabledRelationTypes & relation;
    }

    QObject *MarbleQuickItem::getEventFilter() const
    {   //We would want to install the same event filter for abstract layer QuickItems such as PinchArea
        return &d->m_inputHandler;
    }

    void MarbleQuickItem::pinch(const QPointF& center, qreal scale, Qt::GestureState state)
    {
        d->m_inputHandler.pinch(center, scale, state);
    }

    MarbleInputHandler *MarbleQuickItem::inputHandler()
    {
        return &d->m_inputHandler;
    }

    int MarbleQuickItem::radius() const
    {
        return d->m_map.radius();
    }

    qreal MarbleQuickItem::heading() const
    {
        return d->m_map.heading();
    }


    int MarbleQuickItem::zoom() const
    {
        return d->m_presenter.logzoom();
    }

    int MarbleQuickItem::minimumZoom() const
    {
        return d->m_presenter.minimumZoom();
    }

    int MarbleQuickItem::maximumZoom() const
    {
        return d->m_presenter.maximumZoom();
    }

    bool MarbleQuickItem::layersEventFilter(QObject *, QEvent *)
    {   //Does nothing, but can be reimplemented in a subclass
        return false;
    }

    QuickItemSelectionRubber::QuickItemSelectionRubber() :
        m_visible(false)
    {
        // nothing to do
    }

    void MarbleQuickItemPrivate::updateVisibleRoutes()
    {
        GeoDataRelation::RelationTypes relationTypes = m_enabledRelationTypes;
        if (!m_showPublicTransport) {
            relationTypes &= ~GeoDataRelation::RouteTrain;
            relationTypes &= ~GeoDataRelation::RouteSubway;
            relationTypes &= ~GeoDataRelation::RouteTram;
            relationTypes &= ~GeoDataRelation::RouteBus;
            relationTypes &= ~GeoDataRelation::RouteTrolleyBus;
        }
        if (!m_showOutdoorActivities) {
            relationTypes &= ~GeoDataRelation::RouteBicycle;
            relationTypes &= ~GeoDataRelation::RouteMountainbike;
            relationTypes &= ~GeoDataRelation::RouteFoot;
            relationTypes &= ~GeoDataRelation::RouteHiking;
            relationTypes &= ~GeoDataRelation::RouteHorse;
            relationTypes &= ~GeoDataRelation::RouteInlineSkates;
            relationTypes &= ~GeoDataRelation::RouteSkiDownhill;
            relationTypes &= ~GeoDataRelation::RouteSkiNordic;
            relationTypes &= ~GeoDataRelation::RouteSkitour;
            relationTypes &= ~GeoDataRelation::RouteSled;
        }
        m_map.setVisibleRelationTypes(relationTypes);
    }

    void MarbleQuickItemPrivate::changeBlending(bool enabled, const QString &blendingName)
    {
        GeoSceneDocument * mapTheme = m_map.model()->mapTheme();
        if (mapTheme == nullptr) return;

        GeoSceneMap * map = mapTheme->map();
        if (map == nullptr) return;

        GeoSceneTextureTileDataset * textureDataset = nullptr;
        if (map->hasTextureLayers()) {
            for (auto layer : map->layers()) {
                for (auto dataset : layer->datasets()) {
                    if (dataset->nodeType() == GeoSceneTypes::GeoSceneTextureTileType) {
                        textureDataset = dynamic_cast<GeoSceneTextureTileDataset*>(dataset);
                        break;
                    }
                }
            }
            if (textureDataset == nullptr) return;
            if (enabled && textureDataset->blending().isEmpty()) {
                textureDataset->setBlending(blendingName);
                m_map.clearVolatileTileCache();
            }
            else if (!enabled && textureDataset->blending() == blendingName) {
                textureDataset->setBlending("");
                m_map.clearVolatileTileCache();
            }
        }
    }

    void MarbleQuickItemPrivate::changeStyleBuilder(bool invert)
    {
        GeoSceneDocument * mapTheme = m_map.model()->mapTheme();
        if (mapTheme == nullptr) return;

        GeoSceneMap * map = mapTheme->map();
        if (map == nullptr) return;

        if (map->hasVectorLayers()) {
            StyleBuilder * styleBuilder = const_cast<StyleBuilder*>(m_map.styleBuilder());

            if (invert) {
                styleBuilder->setStyleEffect(InvertedEffect);
            }
            else {
                styleBuilder->setStyleEffect(NoEffect);
            }
            styleBuilder->reset();
            // trigger groundlayer update
            emit m_map.model()->themeChanged(QString());
        }
    }
}

#include "moc_MarbleQuickItem.cpp"
