/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

import QtQuick 2.0
import QtTest 1.0
import QtPositioning 5.5
import QtLocation 5.6
import QtLocation.Test 5.6

Item {
    id: page
    x: 0; y: 0;
    width: 240
    height: 240
    Plugin { id: testPlugin
             name : "qmlgeo.test.plugin"
             allowExperimental: true
             parameters: [ PluginParameter { name: "finishRequestImmediately"; value: true}]
    }

    property variant mapDefaultCenter: QtPositioning.coordinate(20, 20)

    property variant datelineCoordinate: QtPositioning.coordinate(20, 180)
    property variant datelineCoordinateLeft: QtPositioning.coordinate(20, 170)
    property variant datelineCoordinateRight: QtPositioning.coordinate(20, -170)

    MapPolygon {
        id: extMapPolygon
        color: 'darkgrey'
        path: [
            { latitude: 25, longitude: 5 },
            { latitude: 20, longitude: 10 }
        ]
        MouseArea {
            anchors.fill: parent
            drag.target: parent
            SignalSpy { id: extMapPolygonClicked; target: parent; signalName: "clicked" }
        }
        SignalSpy {id: extMapPolygonPathChanged; target: parent; signalName: "pathChanged"}
        SignalSpy {id: extMapPolygonColorChanged; target: parent; signalName: "colorChanged"}
        SignalSpy {id: extMapPolygonBorderWidthChanged; target: parent.border; signalName: "widthChanged"}
        SignalSpy {id: extMapPolygonBorderColorChanged; target: parent.border; signalName: "colorChanged"}
    }

    property variant polyCoordinate: QtPositioning.coordinate(15, 6)

    MapPolygon {
        id: extMapPolygon0
        color: 'darkgrey'
    }

    MapPolyline {
        id: extMapPolyline0
    }

    MapPolyline {
        id: extMapPolyline
        path: [
            { latitude: 25, longitude: 5 },
            { latitude: 20, longitude: 10 }
        ]
        SignalSpy {id: extMapPolylineColorChanged; target: parent.line; signalName: "colorChanged"}
        SignalSpy {id: extMapPolylineWidthChanged; target: parent.line; signalName: "widthChanged"}
        SignalSpy {id: extMapPolylinePathChanged; target: parent; signalName: "pathChanged"}
    }

    MapRectangle {
        id: extMapRectDateline
        color: 'darkcyan'
        topLeft {
            latitude: 20
            longitude: 175
        }
        bottomRight {
            latitude: 10
            longitude: -175
        }
        MouseArea {
            anchors.fill: parent
            drag.target: parent
            preventStealing: true
        }
    }

    MapCircle {
        id: extMapCircleDateline
        color: 'darkmagenta'
        center {
            latitude: 20
            longitude: 180
        }
        radius: 400000
        MouseArea {
            anchors.fill: parent
            drag.target: parent
            preventStealing: true
        }
    }

    MapQuickItem {
        id: extMapQuickItemDateline
        MouseArea {
            anchors.fill: parent
            drag.target: parent
            preventStealing: true
        }
        coordinate {
            latitude: 20
            longitude: 175
        }
        sourceItem: Rectangle {
            color: 'darkgreen'
            width: 20
            height: 20
        }
    }

    MapPolygon {
        id: extMapPolygonDateline
        color: 'darkmagenta'
        path: [
            { latitude: 20, longitude: 175 },
            { latitude: 20, longitude: -175 },
            { latitude: 10, longitude: -175 },
            { latitude: 10, longitude: 175 }
        ]
        MouseArea {
            anchors.fill: parent
            drag.target: parent
            preventStealing: true
        }
    }

    MapPolyline {
        id: polylineForSetpath
        line.width: 3
        path: [
            { latitude: 20, longitude: 175 },
            { latitude: 20, longitude: -175 },
            { latitude: 10, longitude: -175 },
            { latitude: 10, longitude: 175 }
        ]
    }

    MapPolyline {
        id: extMapPolylineDateline
        line.width : 3
        path: [
            { latitude: 20, longitude: 175 },
            { latitude: 25, longitude: -175 }
        ]
        MouseArea {
            anchors.fill: parent
            drag.target: parent
        }
    }

    MapRoute {
        id: extMapRouteDateline
        line.color: 'yellow'
        route: Route {
            path: [
                { latitude: 25, longitude: 175 },
                { latitude: 20, longitude: -175 }
            ]
        }
    }

    MapRectangle {
        id: extMapRectEdge
        color: 'darkcyan'
        topLeft {
            latitude: 20
            longitude: -15
        }
        bottomRight {
            latitude: 10
            longitude: -5
        }
        MouseArea {
            anchors.fill: parent
            drag.target: parent
        }
    }

    MapCircle {
        id: extMapCircleEdge
        color: 'darkmagenta'
        center {
            latitude: 20
            longitude: -15
        }
        radius: 400000
        MouseArea {
            anchors.fill: parent
            drag.target: parent
        }
    }

    MapQuickItem {
        id: extMapQuickItemEdge
        MouseArea {
            anchors.fill: parent
            drag.target: parent
        }
        coordinate {
            latitude: 20
            longitude: -15
        }
        sourceItem: Rectangle {
            color: 'darkgreen'
            width: 20
            height: 20
        }
    }

    MapPolygon {
        id: extMapPolygonEdge
        color: 'darkmagenta'
        path: [
            { latitude: 20, longitude: -15 },
            { latitude: 20, longitude: -5 },
            { latitude: 10, longitude: -5 },
            { latitude: 10, longitude: -15 }
        ]
        MouseArea {
            anchors.fill: parent
            drag.target: parent
        }
    }

    MapPolyline {
        id: extMapPolylineEdge
        line.width : 3
        path: [
            { latitude: 20, longitude: -15 },
            { latitude: 25, longitude: -5 }
        ]
        MouseArea {
            anchors.fill: parent
            drag.target: parent
        }
    }

    MapRoute {
        id: extMapRouteEdge
        line.color: 'yellow'
        route: Route {
            path: [
                { latitude: 25, longitude: -15 },
                { latitude: 20, longitude: -5 }
            ]
        }
    }

    Map {
        id: map;
        x: 20; y: 20; width: 200; height: 200
        center: mapDefaultCenter
        plugin: testPlugin;
    }

    Text {id: progressText}

    TestCase {
        name: "MapItemDetails"
        when: windowShown && map.mapReady

    /*

     (0,0)   ---------------------------------------------------- (240,0)
             | no map                                           |
             |    (20,20)                                       |
     (0,20)  |    ------------------------------------------    | (240,20)
             |    |                                        |    |
             |    |  map                                   |    |
             |    |                                        |    |
             |    |                                        |    |
             |    |                                        |    |
             |    |                   (lat 20, lon 20)     |    |
             |    |                     x                  |    |
             |    |                                        |    |
             |    |                                        |    |
             |    |                                        |    |
             |    |                                        |    |
             |    |                                        |    |
             |    ------------------------------------------    |
             |                                                  |
     (0,240) ---------------------------------------------------- (240,240)

     */
        function initTestCase()
        {
            // sanity check that the coordinate conversion works
            var mapcenter = map.fromCoordinate(map.center)
            verify (fuzzy_compare(mapcenter.x, 100, 2))
            verify (fuzzy_compare(mapcenter.y, 100, 2))
        }

        function init()
        {
            map.clearMapItems()
            map.zoomLevel = 3
            extMapPolygon.border.width = 1.0
            extMapPolygonClicked.clear()
            extMapPolylineColorChanged.clear()
            extMapPolylineWidthChanged.clear()
            extMapPolylinePathChanged.clear()
            extMapPolygonPathChanged.clear()
            extMapPolygonColorChanged.clear()
            extMapPolygonBorderColorChanged.clear()
            extMapPolygonBorderWidthChanged.clear()
        }

        function test_polygon()
        {
            map.center = extMapPolygon.path[1]
            var point = map.fromCoordinate(extMapPolygon.path[1])
            map.addMapItem(extMapPolygon)
            verify(LocationTestHelper.waitForPolished(map))
            verify(extMapPolygon.path.length == 2)
            mouseClick(map, point.x - 5, point.y)
            compare(extMapPolygonClicked.count, 0)
            map.addMapItem(extMapPolygon0) // mustn't crash or ill-behave
            verify(extMapPolygon0.path.length == 0)
            extMapPolygon.addCoordinate(polyCoordinate)
            verify(extMapPolygon.path.length == 3)
            verify(LocationTestHelper.waitForPolished(map))
            mouseClick(map, point.x - 5, point.y)
            tryCompare(extMapPolygonClicked, "count", 1)

            extMapPolygon.path[0].latitude = 10
            verify(extMapPolygon.path[0].latitude, 10)
            extMapPolygon.path[0].latitude = polyCoordinate.latitude
            verify(extMapPolygon.path[0].latitude, 15)
            extMapPolygon.path[0].longitude = 2
            verify(extMapPolygon.path[0].longitude, 2)
            extMapPolygon.path[0].longitude = polyCoordinate.longitude
            verify(extMapPolygon.path[0].longitude, 6)

            extMapPolygon.removeCoordinate(polyCoordinate)
            verify(extMapPolygon.path.length == 2)
            extMapPolygon.removeCoordinate(extMapPolygon.path[1])
            verify(extMapPolygon.path.length == 1)
            extMapPolygon.removeCoordinate(extMapPolygon.path[0])
            verify(extMapPolygon.path.length == 0)
        }

        function test_polyline()
        {
            compare (extMapPolyline.line.width, 1.0)
            var point = map.fromCoordinate(extMapPolyline.path[1])
            map.addMapItem(extMapPolyline0) // mustn't crash or ill-behave
            verify(extMapPolyline0.path.length == 0)
            map.addMapItem(extMapPolyline)
            verify(extMapPolyline.path.length == 2)
            extMapPolyline.addCoordinate(polyCoordinate)
            verify(extMapPolyline.path.length == 3)
            extMapPolyline.addCoordinate(extMapPolyline.path[0])
            verify(extMapPolyline.path.length == 4)

            extMapPolyline.path[0].latitude = 10
            verify(extMapPolyline.path[0].latitude, 10)
            extMapPolyline.path[0].latitude = polyCoordinate.latitude
            verify(extMapPolyline.path[0].latitude, 15)
            extMapPolyline.path[0].longitude = 2
            verify(extMapPolyline.path[0].longitude, 2)
            extMapPolyline.path[0].longitude = polyCoordinate.longitude
            verify(extMapPolyline.path[0].longitude, 6)

            // TODO when line rendering is ready
            //mouseClick(map, point.x - 5, point.y)
            //compare(extMapPolylineClicked.count, 1)
            extMapPolyline.removeCoordinate(extMapPolyline.path[0])
            verify(extMapPolyline.path.length == 3)
            extMapPolyline.removeCoordinate(polyCoordinate)
            verify(extMapPolyline.path.length == 2)
            extMapPolyline.removeCoordinate(extMapPolyline.path[1])
            verify(extMapPolyline.path.length == 1)
            extMapPolyline.removeCoordinate(extMapPolyline.path[0])
            verify(extMapPolyline.path.length == 0)
        }

        function test_polyline_setpath()
        {
            compare (polylineForSetpath.line.width, 3.0)
            verify(polylineForSetpath.path.length == 4)
            compare(polylineForSetpath.path[0], QtPositioning.coordinate(20, 175))
            compare(polylineForSetpath.path[3], QtPositioning.coordinate(10, 175))


            var originalPath = QtPositioning.shapeToPath(polylineForSetpath.geoShape)

            var geoPath = QtPositioning.path([   { latitude: 20, longitude: -15 },
                                                 { latitude: 20, longitude: -5 },
                                                 { latitude: 10, longitude: -5 },
                                                 { latitude: 10, longitude: -15 },
                                                 { latitude: 10, longitude: -105 } ], 50)

            polylineForSetpath.setPath(geoPath)
            verify(polylineForSetpath.path.length == 5)
            compare(polylineForSetpath.path[0], QtPositioning.coordinate(20, -15))
            compare(polylineForSetpath.path[3], QtPositioning.coordinate(10, -15))

            polylineForSetpath.setPath(originalPath)
            verify(polylineForSetpath.path.length == 4)
            compare(polylineForSetpath.path[0], QtPositioning.coordinate(20, 175))
            compare(polylineForSetpath.path[3], QtPositioning.coordinate(10, 175))
        }

    /*

     (0,0)   ---------------------------------------------------- (600,0)
             | no map                                           |
             |    (20,20)                                       |
     (0,20)  |    ------------------------------------------    | (600,20)
             |    |                                        |    |
             |    |  map                                   |    |
             |    |                                        |    |
             |    |                                        |    |
             |    |                                        |    |
             |    |                   (lat 20, lon 180)    |    |
             |    |                     x                  |    |
             |    |                                        |    |
             |    |                                        |    |
             |    |                                        |    |
             |    |                                        |    |
             |    |                                        |    |
             |    ------------------------------------------    |
             |                                                  |
     (0,240) ---------------------------------------------------- (600,240)

     */
        function test_dateline() {
            map.center = datelineCoordinate
            map.zoomLevel = 2.2
            var inspectionTime = 0 // change this to inspect the behavior.

            // rectangle
            // item spanning across dateline
            map.addMapItem(extMapRectDateline)
            verify(extMapRectDateline.topLeft.longitude == 175)
            verify(extMapRectDateline.bottomRight.longitude == -175)
            var point = map.fromCoordinate(extMapRectDateline.topLeft)
            verify(point.x < map.width / 2.0)
            point = map.fromCoordinate(extMapRectDateline.bottomRight)
            verify(point.x > map.width / 2.0)
            // move item away from dataline by directly setting its coords
            extMapRectDateline.bottomRight.longitude = datelineCoordinateRight.longitude
            point = map.fromCoordinate(extMapRectDateline.bottomRight)
            verify(point.x > map.width / 2.0)
            // move item edge onto dateline
            extMapRectDateline.topLeft.longitude = datelineCoordinate.longitude
            point = map.fromCoordinate(extMapRectDateline.topLeft)
            compare(point.x, map.width / 2.0)
            // drag item back onto dateline
            verify(LocationTestHelper.waitForPolished(map))
            visualInspectionPoint(inspectionTime)
            mousePress(map, point.x + 5, point.y + 5)
            var i
            for (i=0; i < 20; i += 2) {
                wait(1)
                mouseMove(map, point.x + 5 - i, point.y + 5 )
            }
            mouseRelease(map, point.x + 5 - i, point.y + 5)
            verify(LocationTestHelper.waitForPolished(map))
            visualInspectionPoint(inspectionTime)
            point = map.fromCoordinate(extMapRectDateline.topLeft)
            verify(point.x < map.width / 2.0)
            point = map.fromCoordinate(extMapRectDateline.bottomRight)
            verify(point.x > map.width / 2.0)
            map.removeMapItem(extMapRectDateline)

            // circle
            map.addMapItem(extMapCircleDateline)
            verify(extMapCircleDateline.center.longitude === 180)
            map.center = datelineCoordinate
            point = map.fromCoordinate(extMapCircleDateline.center)
            compare(point.x, map.width / 2.0) // center of the screen
            visualInspectionPoint()
            extMapCircleDateline.center.longitude = datelineCoordinateRight.longitude // -170, moving the circle to the right
            point = map.fromCoordinate(extMapCircleDateline.center)
            verify(LocationTestHelper.waitForPolished(map))
            verify(point.x > map.width / 2.0)
            visualInspectionPoint(inspectionTime)
            mousePress(map, point.x, point.y)
            for (i=0; i < 50; i += 4) {
                wait(1)
                mouseMove(map, point.x - i, point.y)
            }
            mouseRelease(map, point.x - i, point.y)
            verify(LocationTestHelper.waitForPolished(map))
            visualInspectionPoint(inspectionTime)
            point = map.fromCoordinate(extMapCircleDateline.center)
            visualInspectionPoint()
            verify(point.x < map.width / 2.0)
            map.removeMapItem(extMapCircleDateline)

            // quickitem
            map.addMapItem(extMapQuickItemDateline)
            map.center = datelineCoordinate
            verify(extMapQuickItemDateline.coordinate.longitude === 175)
            point = map.fromCoordinate(extMapQuickItemDateline.coordinate)
            verify(point.x < map.width / 2.0)
            visualInspectionPoint()
            extMapQuickItemDateline.coordinate.longitude = datelineCoordinateRight.longitude
            point = map.fromCoordinate(extMapQuickItemDateline.coordinate)
            verify(point.x > map.width / 2.0)
            verify(LocationTestHelper.waitForPolished(map))
            visualInspectionPoint(inspectionTime)
            mousePress(map, point.x + 5, point.y + 5)
            for (i=0; i < 64; i += 5) {
                wait(1)
                mouseMove(map, point.x + 5 - i, point.y + 5 )
            }
            mouseRelease(map, point.x + 5 - i, point.y + 5)
            verify(LocationTestHelper.waitForPolished(map))
            visualInspectionPoint(inspectionTime)
            point = map.fromCoordinate(extMapQuickItemDateline.coordinate)
            visualInspectionPoint()
            verify(point.x < map.width / 2.0)
            map.removeMapItem(extMapQuickItemDateline)

            // polygon
            map.addMapItem(extMapPolygonDateline)
            map.center = datelineCoordinate
            verify(extMapPolygonDateline.path[0].longitude == 175)
            verify(extMapPolygonDateline.path[1].longitude == -175)
            verify(extMapPolygonDateline.path[2].longitude == -175)
            verify(extMapPolygonDateline.path[3].longitude == 175)
            point = map.fromCoordinate(extMapPolygonDateline.path[0])
            verify(point.x < map.width / 2.0)
            point = map.fromCoordinate(extMapPolygonDateline.path[1])
            verify(point.x > map.width / 2.0)
            point = map.fromCoordinate(extMapPolygonDateline.path[2])
            verify(point.x > map.width / 2.0)
            point = map.fromCoordinate(extMapPolygonDateline.path[3])
            verify(point.x < map.width / 2.0)
            extMapPolygonDateline.path[1].longitude = datelineCoordinateRight.longitude
            point = map.fromCoordinate(extMapPolygonDateline.path[1])
            verify(point.x > map.width / 2.0)
            extMapPolygonDateline.path[2].longitude = datelineCoordinateRight.longitude
            point = map.fromCoordinate(extMapPolygonDateline.path[2])
            verify(point.x > map.width / 2.0)
            var path = extMapPolygonDateline.path;
            path[0].longitude = datelineCoordinate.longitude;
            extMapPolygonDateline.path = path;
            point = map.fromCoordinate(extMapPolygonDateline.path[0])
            compare(point.x, map.width / 2.0)
            path = extMapPolygonDateline.path;
            path[3].longitude = datelineCoordinate.longitude;
            extMapPolygonDateline.path = path;
            point = map.fromCoordinate(extMapPolygonDateline.path[3])
            compare(point.x, map.width / 2.0)
            verify(LocationTestHelper.waitForPolished(map))
            visualInspectionPoint(inspectionTime)
            mousePress(map, point.x + 5, point.y - 5)
            for (i=0; i < 16; i += 2) {
                wait(1)
                mouseMove(map, point.x + 5 - i, point.y - 5 )
            }
            mouseRelease(map, point.x + 5 - i, point.y - 5)
            verify(LocationTestHelper.waitForPolished(map))
            visualInspectionPoint(inspectionTime)
            point = map.fromCoordinate(extMapPolygonDateline.path[0])
            verify(point.x < map.width / 2.0)
            point = map.fromCoordinate(extMapPolygonDateline.path[1])
            verify(point.x > map.width / 2.0)
            point = map.fromCoordinate(extMapPolygonDateline.path[2])
            verify(point.x > map.width / 2.0)
            point = map.fromCoordinate(extMapPolygonDateline.path[3])
            verify(point.x < map.width / 2.0)
            map.removeMapItem(extMapPolygonDateline)

            // polyline
            map.addMapItem(extMapPolylineDateline)
            map.center = datelineCoordinate
            verify(extMapPolylineDateline.path[0].longitude == 175)
            verify(extMapPolylineDateline.path[1].longitude == -175)
            point = map.fromCoordinate(extMapPolylineDateline.path[0])
            verify(point.x < map.width / 2.0)
            point = map.fromCoordinate(extMapPolylineDateline.path[1])
            verify(point.x > map.width / 2.0)
            extMapPolylineDateline.path[1].longitude = datelineCoordinateRight.longitude
            point = map.fromCoordinate(extMapPolylineDateline.path[1])
            verify(point.x > map.width / 2.0)
            var path = extMapPolygonDateline.path;
            path[0].longitude = datelineCoordinate.longitude;
            extMapPolylineDateline.path = path;
            point = map.fromCoordinate(extMapPolylineDateline.path[0])
            compare(point.x, map.width / 2.0)
            map.removeMapItem(extMapPolylineDateline)

            // map route
            // (does not support setting of path coords)
            map.addMapItem(extMapRouteDateline)
            verify(extMapRouteDateline.route.path[0].longitude == 175)
            verify(extMapRouteDateline.route.path[1].longitude == -175)
            point = map.fromCoordinate(extMapRouteDateline.route.path[0])
            verify(point.x < map.width / 2.0)
            point = map.fromCoordinate(extMapRouteDateline.route.path[1])
            verify(point.x > map.width / 2.0)
            map.removeMapItem(extMapRouteDateline)
        }

        function fuzzy_compare(val, ref, tol) {
            var tolerance = 2
            if (tol !== undefined)
                tolerance = tol
            if ((val >= ref - tolerance) && (val <= ref + tolerance))
                return true;
            console.log('map fuzzy cmp returns false for value, ref, tolerance: ' + val + ', ' + ref + ', ' + tolerance)
            return false;
        }
        // call to visualInspectionPoint testcase (for dev time visual inspection)
        function visualInspectionPoint(time) {
            var waitTime = 0 // 300
            if (time !== undefined)
                waitTime = time
            if (waitTime > 0) {
                console.log('halting for ' + waitTime + ' milliseconds')
                wait (waitTime)
            }
        }
    }
}