{
    "Keys": ["osmscoutoffline"],
    "Provider": "osmscoutoffline",
    "Version": 100,
    "Experimental": false,
    "Features": [
        "OfflineMappingFeature",
        "OnlineRoutingFeature"
    ]
}

#ifndef QGEOSERVICEPROVIDERFACTORYOSMSCOUTOFFLINE_H
#define QGEOSERVICEPROVIDERFACTORYOSMSCOUTOFFLINE_H
#include <QObject>
#include <QGeoServiceProviderFactory>
class QGeoServiceProviderFactoryOsmScoutOffline : public QObject, public QGeoServiceProviderFactory
{
    Q_OBJECT
    Q_INTERFACES(QGeoServiceProviderFactory)
    Q_PLUGIN_METADATA(IID "org.qt-project.qt.geoservice.serviceproviderfactory/5.0"
                      FILE "../osmscoutoffline_plugin.json")
public:
    QGeoRoutingManagerEngine *createRoutingManagerEngine(const QVariantMap &parameters,
                                                         QGeoServiceProvider::Error *error,
                                                         QString *errorString) const;
    QGeoMappingManagerEngine *createMappingManagerEngine(const QVariantMap &parameters,
                                                         QGeoServiceProvider::Error *error,
                                                         QString *errorString) const;
};
#endif // QGEOSERVICEPROVIDERFACTORYOSMSCOUTOFFLINE_H

#include "qgeoserviceproviderfactoryosmscoutoffline.h"
#include "qgeoroutingmanagerengineosmscoutoffline.h"
#include "qgeotiledmappingmanagerengineosmscoutoffline.h"
QGeoRoutingManagerEngine *QGeoServiceProviderFactoryOsmScoutOffline::createRoutingManagerEngine(
        const QVariantMap &parameters, QGeoServiceProvider::Error *error,
        QString *errorString) const
{
    return new QGeoRoutingManagerEngineOsmScoutOffline(parameters, error, errorString);
}
QGeoMappingManagerEngine *QGeoServiceProviderFactoryOsmScoutOffline::createMappingManagerEngine(
        const QVariantMap &parameters, QGeoServiceProvider::Error *error,
        QString *errorString) const
{
    return new QGeoTiledMappingManagerEngineOsmScoutOffline(parameters, error, errorString);
}

QGeoTiledMappingManagerEngineOsmScoutOffline::QGeoTiledMappingManagerEngineOsmScoutOffline(
        const QVariantMap &parameters, QGeoServiceProvider::Error *error, QString *errorString)
{
    QGeoCameraCapabilities cameraCaps;
    cameraCaps.setMinimumZoomLevel(0.0);
    cameraCaps.setMaximumZoomLevel(19.0);
    setCameraCapabilities(cameraCaps);
    setTileSize(QSize(256, 256));
    QList<QGeoMapType> mapTypes;
    mapTypes << QGeoMapType(QGeoMapType::StreetMap, tr("Street Map"), tr("OSM Street Map"), false, false, 1);
    setSupportedMapTypes(mapTypes);
    QGeoTileFetcherOsmScoutOffline *tileFetcher = new QGeoTileFetcherOsmScoutOffline(this);
    tileFetcher->setParams(parameters);
    setTileFetcher(tileFetcher);
    *error = QGeoServiceProvider::NoError;
    errorString->clear();
}

QGeoTiledMapReply *QGeoTileFetcherOsmScoutOffline::getTileImage(const QGeoTileSpec &spec)
{
    QUrlQuery query;
    for (QString &key : m_params.keys())
        query.addQueryItem(key, m_params[key].toString());
    query.addQueryItem(QStringLiteral("x"), QString::number(spec.x()));
    query.addQueryItem(QStringLiteral("y"), QString::number(spec.y()));
    query.addQueryItem(QStringLiteral("z"), QString::number(spec.zoom()));
    QUrl url(QStringLiteral("http://localhost:8553/v1/tile"));
    url.setQuery(query);
    QNetworkRequest remoteRequest(url);
    QNetworkReply *reply = m_networkManager->get(remoteRequest);
    return new QGeoMapReplyOsmScoutOffline(reply, spec);
}

void QGeoMapReplyOsmScoutOffline::networkReplyFinished()
{
    if (!m_reply)
        return;
    if (m_reply->error() != QNetworkReply::NoError)
        return;
    setMapImageData(m_reply->readAll());
    setMapImageFormat("png");
    setFinished(true);
    m_reply->deleteLater();
    m_reply = 0;
}

QGeoRoutingManagerEngine *QGeoServiceProviderFactoryOsmScoutOffline::createRoutingManagerEngine(
        const QVariantMap &parameters, QGeoServiceProvider::Error *error, QString *errorString) const
{
    return new QGeoRoutingManagerEngineOsmScoutOffline(parameters, error, errorString);
}

QGeoRouteReply *QGeoRoutingManagerEngineOsmScoutOffline::calculateRoute(
        const QGeoRouteRequest &request)
{
   QGeoCoordinate start = request.waypoints()[0];
   QGeoCoordinate end = request.waypoints()[1];
   QString from = QStringLiteral("%1,%2").arg(QString::number(start.latitude()), QString::number(start.longitude()));
   QString to = QStringLiteral("%1,%2").arg(QString::number(end.latitude()), QString::number(end.longitude()));
   QUrlQuery query;
   query.addQueryItem(QStringLiteral("from"), from);
   query.addQueryItem(QStringLiteral("to"), to);
   query.addQueryItem(QStringLiteral("ratio"), QStringLiteral("1"));
   QUrl url(QStringLiteral("https://sightsafari.city/api/v1/routes/direct"));
   url.setQuery(query);
   QNetworkRequest remoteRequest(url);
   QNetworkReply *reply = mNetworkManager->get(remoteRequest);
   QGeoRouteReplyOsmScoutOffline routeReply = new QGeoRouteReplyOsmScoutOffline(reply, request, this);
   connect(routeReply, &QGeoRouteReplyOsmScoutOffline::finished,
           this, &QGeoRoutingManagerEngineOsmScoutOffline::replyFinished);
   connect(routeReply, static_cast<void(QGeoRouteReplyOsmScoutOffline::)
           (QGeoRouteReplyOsmScoutOffline::Error, const QString &)>(&QGeoRouteReplyOsmScoutOffline::error),
           this, &QGeoRoutingManagerEngineOsmScoutOffline::replyError);
   return routeReply;
}

void QGeoRoutingManagerEngineOsmScoutOffline::replyFinished()
{
    QGeoRouteReply *reply = qobject_cast<QGeoRouteReply *>(sender());
    if (reply)
        emit finished(reply);
}
void QGeoRoutingManagerEngineOsmScoutOffline::replyError(QGeoRouteReply::Error errorCode,
                                                         const QString &errorString)
{
    QGeoRouteReply *reply = qobject_cast<QGeoRouteReply *>(sender());
    if (reply)
        emit error(reply, errorCode, errorString);
}

QGeoRouteReplyOsmScoutOffline::QGeoRouteReplyOsmScoutOffline(QNetworkReply *reply,
                                                             const QGeoRouteRequest &request,
                                                             QObject parent)
    : QGeoRouteReply(request, parent)
{
   if (reply == nullptr) {
       setError(UnknownError, QStringLiteral("Null reply"));
       return;
   }
   connect(reply, &QNetworkReply::finished,
           this, &QGeoRouteReplyOsmScoutOffline::networkReplyFinished);
   connect(reply, static_cast<void(QNetworkReply::)(QNetworkReply::NetworkError)>(&QNetworkReply::error),
           this, &QGeoRouteReplyOsmScoutOffline::networkReplyError);
   connect(this, &QGeoRouteReplyOsmScoutOffline::destroyed,
           reply, &QNetworkReply::deleteLater);
}

void QGeoRouteReplyOsmScoutOffline::networkReplyFinished()
{
    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
    reply->deleteLater();
    if (reply->error() != QNetworkReply::NoError)
        return;
    QJsonDocument jsonDoc = QJsonDocument::fromJson(reply->readAll());
    QJsonObject jsonBody = jsonDoc.object().value(QStringLiteral("body")).toObject();
    QJsonArray jsonPath = jsonBody.value(QStringLiteral("latLonPoints")).toArray();
    QList<QGeoCoordinate> coords;
    for (QJsonValue value : jsonPath) {
        QJsonArray coord = value.toArray();
        coords.append(QGeoCoordinate(coord.at(0).toDouble(), coord.at(1).toDouble()));
    }
    QGeoRoute route;
    route.setPath(coords);
    route.setRequest(request());
    setRoutes({ route });
    setFinished(true);
}

Name: qtgeoservices_osmscoutoffline
Summary: QtGeoServices OSM Scout Offline with Sight Safary routing
Version: 0.5.0
Release: 1
Group: System/Libraries
URL: https://github.com/osanwe/qtgeoservices-osmscoutoffline
License: BSD-3-Clause
Sources:
- '%{name}-%{version}.tar.bz2'
Description: |
  QtGeoServices OSM Scout Offline with Sight Safary routing
Configure: none
Builder: qtc5
PkgConfigBR:
  - Qt5Core
  - Qt5Location
  - Qt5Positioning
  - Qt5Network
Files:
  - '%{_libdir}/qt5/plugins/geoservices/libqtgeoservices_osmscoutoffline.so'

import QtQuick 2.5
import QtLocation 5.0
import QtPositioning 5.0
import Sailfish.Silica 1.0
import "../views"

Page {
    id: page
   property bool mapFollowing: false
    property var mapGpsPosition: positionSource.position.coordinate
    property var mapCenterPosition: QtPositioning.coordinate(NaN, NaN)
    property var pressCoords: QtPositioning.coordinate(NaN, NaN)
    allowedOrientations: Orientation.Portrait
    Drawer {
        id: drawer
        anchors.fill: parent
        open: true
        backgroundSize: background.height
        background: Item {
            id: background
            // some code
        }
        Plugin {
            id: mapPlugin
            name: "osmscoutoffline"
        }
        PositionSource {
            id: positionSource
            updateInterval: 1000
            active: true
            preferredPositioningMethods: PositionSource.AllPositioningMethods
        }
        Map {
            id: map
            function initMapCenter() {
                var moscowCenterPos = QtPositioning.coordinate(55.751244, 37.618423)
                if (mapGpsPosition.isValid) {
                    map.center = mapGpsPosition
                    mapFollowing = true
                } else {
                    map.center = moscowCenterPos
                }
                map.zoomLevel = 15
            }
            function setMapCenterFromGps() {
                if (mapGpsPosition.isValid) {
                    map.zoomLevel = 17
                    map.center.latitude = mapGpsPosition.latitude
                    map.center.longitude = mapGpsPosition.longitude
                    mapFollowing = true
                }
            }
            anchors.fill: parent
            plugin: mapPlugin
            onCenterChanged: {
                mapCenterPosition = center
                if (mapFollowing && center !== mapGpsPosition)
                    mapFollowing = false
            }
            Component.onCompleted: map.initMapCenter()
            MapMarker {
                coordinate: mapGpsPosition
                visible: mapGpsPosition.isValid
                source: "../images/mylocation.svg"
            }
            Connections {
                target: page
                onMapGpsPositionChanged: {
                    if (mapFollowing)
                        map.setMapCenterFromGps()
                }
            }
        }
    }
}

BusyIndicator {
    id: routeLoadingIndicator
    anchors.centerIn: parent
    size: BusyIndicatorSize.Large
    color: Theme.rgba(Theme.darkPrimaryColor, Theme.opacityOverlay)
    running: false
}

MapRoute { id: mapRoute }
MapMarker {
    id: markerStart
    visible: false
    source: "../images/location.svg"
}
MapMarker {
    id: markerFinish
    visible: false
    source: "../images/location.svg"
}

RouteQuery { id: mapRouteQuery }
RouteModel {
    id: mapRouteModel
    plugin: mapPlugin
    query: mapRouteQuery
    autoUpdate: false
    onRoutesChanged: {
        routeLoadingIndicator.running = false
        mapRoute.path = mapRouteModel.get(0).path
    }
}

Item {
    id: background
    anchors.fill: parent
    height: column.implicitHeight + column.anchors.topMargin + column.anchors.bottomMargin
    Column {
        id: column
        anchors {
            fill: parent
            margins: Theme.paddingMedium
        }
        spacing: Theme.paddingMedium
        width: parent.width
        Label {
            text: qsTr("Route from:")
            font.bold: true
        }
        CoordField { id: startCoordField }
        Label {
            text: qsTr("Route to:")
            font.bold: true
        }
        CoordField { id: endCoordField }
        Row {
            anchors.horizontalCenter: parent.horizontalCenter
            spacing: Theme.paddingMedium
            Button {
                text: qsTr("My position")
                enabled: mapGpsPosition.isValid
                         && (mapGpsPosition.latitude !== mapCenterPosition.latitude
                             || mapGpsPosition.longitude !== mapCenterPosition.longitude)
               onClicked: map.setMapCenterFromGps()
            }
            Button {
                text: qsTr("Route")
                enabled: startCoordField.coordinate.isValid && endCoordField.coordinate.isValid
                onClicked: {
                    routeLoadingIndicator.running = true
                    mapRouteQuery.clearWaypoints()
                    mapRouteQuery.addWaypoint(startCoordField.coordinate)
                    mapRouteQuery.addWaypoint(endCoordField.coordinate)
                    mapRouteModel.update()
                }
            }
        }
    }
}

MapButton {
    anchors {
        bottom: parent.bottom
        right: parent.right
        bottomMargin: Theme.paddingLarge
        rightMargin: Theme.horizontalPageMargin
    }
    icon.source: "image://theme/icon-m-menu"
    highlighted: drawer.open
    onClicked: drawer.open ? drawer.hide() : drawer.show()
}

Column {
    anchors {
        right: parent.right
        verticalCenter: parent.verticalCenter
        rightMargin: Theme.horizontalPageMargin
    }
    spacing: Theme.paddingLarge
    MapButton {
        id: buttonZoomIn
        icon.source: "../images/zoom-plus.svg"
        enabled: map.zoomLevel < map.maximumZoomLevel
        onClicked: map.zoomLevel = Math.min(map.zoomLevel + 1.0, map.maximumZoomLevel)
    }
    MapButton {
        id: buttonZoomOut
        icon.source: "../images/zoom-minus.svg"
        enabled: map.zoomLevel > map.minimumZoomLevel
        onClicked: map.zoomLevel = Math.max(map.zoomLevel - 1.0, map.minimumZoomLevel)
    }
}

MouseArea {
    anchors.fill: parent
    z: -1
    onClicked: {
        if (choosePointDialog.visible) {
            choosePointDialog.visible = false
        } else {
            pressCoords = map.toCoordinate(Qt.point(mouse.x, mouse.y))
            choosePointDialog.visible = true
        }
    }
}
PointDialog { id: choosePointDialog }