/****************************************************************************
**
** 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 QtLocation 5.6
import QtPositioning 5.5
import QtLocation.Test 5.5

    /*

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

     */

Item {
    id: page
    x: 0; y: 0;
    width: 296
    height: 296
    Plugin { id: testPlugin; name : "qmlgeo.test.plugin"; allowExperimental: true }

    property variant mapDefaultCenter: QtPositioning.coordinate(20, 20)
    property variant preMapRectangleDefaultTopLeft: QtPositioning.coordinate(20, 20)
    property variant preMapRectangleDefaultBottomRight: QtPositioning.coordinate(10, 30)
    property variant preMapCircleDefaultCenter: QtPositioning.coordinate(10, 30)
    property variant preMapQuickItemDefaultCoordinate: QtPositioning.coordinate(35, 3)

    property variant preMapPolygonDefaultPath: [
        { latitude: 25, longitude: 5 },
        { latitude: 20, longitude: 10 },
        { latitude: 15, longitude: 6 }
    ]

    property variant preMapPolylineDefaultPath: [
        { latitude: 25, longitude: 15 },
        { latitude: 20, longitude: 19 },
        { latitude: 15, longitude: 16 }
    ]

    property variant preMapRouteDefaultPath: [
        { latitude: 25, longitude: 14 },
        { latitude: 20, longitude: 18 },
        { latitude: 15, longitude: 15 }
    ]

    property variant mapCircleTopLeft: QtPositioning.coordinate(0, 0)
    property variant mapCircleBottomRight: QtPositioning.coordinate(0, 0)
    property variant mapQuickItemTopLeft: QtPositioning.coordinate(0, 0)
    property variant mapQuickItemBottomRight: QtPositioning.coordinate(0, 0)
    property variant mapPolygonTopLeft: QtPositioning.coordinate(0, 0)
    property variant mapPolygonBottomRight: QtPositioning.coordinate(0, 0)
    property variant mapPolylineTopLeft: QtPositioning.coordinate(0, 0)
    property variant mapPolylineBottomRight: QtPositioning.coordinate(0, 0)
    property variant mapRouteTopLeft: QtPositioning.coordinate(0, 0)
    property variant mapRouteBottomRight: QtPositioning.coordinate(0, 0)
    property variant fitRect: QtPositioning.rectangle(QtPositioning.coordinate(80, 80),
                                                      QtPositioning.coordinate(78, 82))
    property variant fitEmptyRect: QtPositioning.rectangle(QtPositioning.coordinate(79, 79),-1, -1)
    property variant fitCircle: QtPositioning.circle(QtPositioning.coordinate(-50, -100), 1500)
    property variant fitInvalidShape: QtPositioning.shape()

    property variant fitCircleTopLeft: QtPositioning.coordinate(0, 0)
    property variant fitCircleBottomRight: QtPositioning.coordinate(0, 0)

    Map {
        id: map;
        x: 20; y: 20; width: 256; height: 256
        zoomLevel: 3
        center: mapDefaultCenter
        plugin: testPlugin;

        MapRectangle {
            id: preMapRect
            color: 'darkcyan'
            border.width: 0
            topLeft: preMapRectangleDefaultTopLeft
            bottomRight: preMapRectangleDefaultBottomRight
            MouseArea {
                id: preMapRectMa
                anchors.fill: parent
                drag.target: parent
                SignalSpy { id: preMapRectClicked; target: parent; signalName: "clicked" }
                SignalSpy { id: preMapRectActiveChanged; target: parent.drag; signalName: "activeChanged" }
            }
            SignalSpy {id: preMapRectTopLeftChanged; target: parent; signalName: "topLeftChanged" }
            SignalSpy {id: preMapRectBottomRightChanged; target: parent; signalName: "bottomRightChanged" }
            SignalSpy {id: preMapRectColorChanged; target: parent; signalName: "colorChanged"}
        }
        MapCircle {
            id: preMapCircle
            color: 'darkmagenta'
            border.width: 0
            center: preMapCircleDefaultCenter
            radius: 400000
            MouseArea {
                anchors.fill: parent
                drag.target: parent
                SignalSpy { id: preMapCircleClicked; target: parent; signalName: "clicked" }
                SignalSpy { id: preMapCircleActiveChanged; target: parent.drag; signalName: "activeChanged" }
            }
            SignalSpy {id: preMapCircleCenterChanged; target: parent; signalName: "centerChanged"}
            SignalSpy {id: preMapCircleColorChanged; target: parent; signalName: "colorChanged"}
            SignalSpy {id: preMapCircleRadiusChanged; target: parent; signalName: "radiusChanged"}
            SignalSpy {id: preMapCircleBorderColorChanged; target: parent.border; signalName: "colorChanged"}
            SignalSpy {id: preMapCircleBorderWidthChanged; target: parent.border; signalName: "widthChanged"}
        }
        MapQuickItem {
            id: preMapQuickItem
            MouseArea {
                anchors.fill: parent
                drag.target: parent
                SignalSpy { id: preMapQuickItemClicked; target: parent; signalName: "clicked" }
                SignalSpy { id: preMapQuickItemActiveChanged; target: parent.drag; signalName: "activeChanged" }
            }
            coordinate: preMapQuickItemDefaultCoordinate
            sourceItem: Rectangle {
                color: 'darkgreen'
                width: 20
                height: 20
            }
            SignalSpy { id: preMapQuickItemCoordinateChanged; target: parent; signalName: "coordinateChanged"}
            SignalSpy { id: preMapQuickItemAnchorPointChanged; target: parent; signalName: "anchorPointChanged"}
            SignalSpy { id: preMapQuickItemZoomLevelChanged; target: parent; signalName: "zoomLevelChanged"}
            SignalSpy { id: preMapQuickItemSourceItemChanged; target: parent; signalName: "sourceItemChanged"}
        }
        MapPolygon {
            id: preMapPolygon
            color: 'darkgrey'
            border.width: 0
            path: [
                { latitude: 25, longitude: 5 },
                { latitude: 20, longitude: 10 },
                { latitude: 15, longitude: 6 }
            ]
            MouseArea {
                anchors.fill: parent
                drag.target: parent
                SignalSpy { id: preMapPolygonClicked; target: parent; signalName: "clicked" }
            }
            SignalSpy {id: preMapPolygonPathChanged; target: parent; signalName: "pathChanged"}
            SignalSpy {id: preMapPolygonColorChanged; target: parent; signalName: "colorChanged"}
            SignalSpy {id: preMapPolygonBorderWidthChanged; target: parent.border; signalName: "widthChanged"}
            SignalSpy {id: preMapPolygonBorderColorChanged; target: parent.border; signalName: "colorChanged"}
        }
        MapPolyline {
            id: preMapPolyline
            line.color: 'darkred'
            path: [
                { latitude: 25, longitude: 15 },
                { latitude: 20, longitude: 19 },
                { latitude: 15, longitude: 16 }
            ]
            SignalSpy {id: preMapPolylineColorChanged; target: parent.line; signalName: "colorChanged"}
            SignalSpy {id: preMapPolylineWidthChanged; target: parent.line; signalName: "widthChanged"}
            SignalSpy {id: preMapPolylinePathChanged; target: parent; signalName: "pathChanged"}
        }
        MapRoute {
            id: preMapRoute
            line.color: 'yellow'
            // don't try this at home - route is not user instantiable
            route: Route {
                path: [
                    { latitude: 25, longitude: 14 },
                    { latitude: 20, longitude: 18 },
                    { latitude: 15, longitude: 15 }
                ]
            }
            SignalSpy {id: preMapRouteRouteChanged; target: parent; signalName: "routeChanged"}
            SignalSpy {id: preMapRouteLineWidthChanged; target: parent.line; signalName: "widthChanged"}
            SignalSpy {id: preMapRouteLineColorChanged; target: parent.line; signalName: "colorChanged"}
        }
    }

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

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

        function init()
        {
            preMapRect.topLeft.latitude = 20
            preMapRect.topLeft.longitude = 20
            preMapRect.bottomRight.latitude = 10
            preMapRect.bottomRight.longitude = 30
            preMapCircle.center.latitude = 10
            preMapCircle.center.longitude = 30
            preMapQuickItem.coordinate.latitude = 35
            preMapQuickItem.coordinate.longitude = 3
            var i
            for (i = 0; i < preMapPolygon.path.length; ++i) {
                preMapPolygon.path[i].latitude = preMapPolygonDefaultPath[i].latitude
                preMapPolygon.path[i].longitude = preMapPolygonDefaultPath[i].longitude
            }
            for (i = 0; i < preMapPolyline.path.length; ++i) {
                preMapPolyline.path[i].latitude = preMapPolylineDefaultPath[i].latitude
                preMapPolyline.path[i].longitude = preMapPolylineDefaultPath[i].longitude
            }
            for (i = 0; i < preMapRoute.route.path.length; ++i) {
                preMapRoute.route.path[i].latitude = preMapRouteDefaultPath[i].latitude
                preMapRoute.route.path[i].longitude = preMapRouteDefaultPath[i].longitude
            }
            // remove items
            map.clearMapItems()
            //clear_data()
            compare (map.mapItems.length, 0)
            // reset map
            map.center.latitude = 20
            map.center.longitude = 20
            map.zoomLevel = 3
            // re-add items and verify they are back (without needing to pan map etc.)
            map.addMapItem(preMapRect)
            map.addMapItem(preMapCircle)
            map.addMapItem(preMapQuickItem)
            map.addMapItem(preMapPolygon)
            map.addMapItem(preMapPolyline)
            map.addMapItem(preMapRoute)
            compare (map.mapItems.length, 6)
            calculate_bounds()
        }

        function test_visible_itmes()
        {
            // normal case - fit viewport to items which are all already visible
            verify_visibility_all_items()
            map.fitViewportToMapItems()
            visualInspectionPoint()
            verify_visibility_all_items()
        }

        function test_visible_zoom_in()
        {
            // zoom in (clipping also occurs)
            var z = map.zoomLevel
            for (var i = (z + 1); i < map.maximumZoomLevel; ++i ) {
                map.zoomLevel = i
                visualInspectionPoint()
                map.fitViewportToMapItems()
                visualInspectionPoint()
                verify_visibility_all_items()
            }
        }

        function test_visible_zoom_out()
        {
            // zoom out
            for (var i = (z - 1); i >= 0; --i ) {
                map.zoomLevel = i
                visualInspectionPoint()
                verify_visibility_all_items()
                map.fitViewportToMapItems()
                visualInspectionPoint()
                verify_visibility_all_items()
            }
        }

        function test_visible_map_move() {
            // move map so all items are out of screen
            // then fit viewport
            var xDir = 1
            var yDir = 0
            var xDirChange = -1
            var yDirChange = 1
            var dir = 0
            for (dir = 0; dir < 4; dir++) {
                verify_visibility_all_items()
                var i = 0
                var panX = map.width * xDir * 0.5
                var panY = map.height * yDir * 0.5
                map.pan(panX, panY)
                map.pan(panX, panY)
                visualInspectionPoint()
                // check all items are indeed not within screen bounds
                calculate_bounds()
                verify(!is_coord_on_screen(preMapRect.topLeft))
                verify(!is_coord_on_screen(preMapRect.bottomRight))
                verify(!is_coord_on_screen(mapCircleTopLeft))
                verify(!is_coord_on_screen(mapCircleBottomRight))
                verify(!is_coord_on_screen(mapPolygonTopLeft))
                verify(!is_coord_on_screen(mapPolygonBottomRight))
                verify(!is_coord_on_screen(mapQuickItemTopLeft))
                verify(!is_coord_on_screen(mapQuickItemBottomRight))
                verify(!is_coord_on_screen(mapPolylineTopLeft))
                verify(!is_coord_on_screen(mapPolylineBottomRight))
                verify(!is_coord_on_screen(mapRouteTopLeft))
                verify(!is_coord_on_screen(mapRouteBottomRight))
                // fit viewport and verify that all items are visible again
                map.fitViewportToMapItems()
                visualInspectionPoint()
                verify_visibility_all_items()
                if (dir == 2)
                    xDirChange *= -1
                if (dir == 1)
                    yDirChange *= -1
                xDir += xDirChange
                yDir += yDirChange
            }
        }

        function test_fit_to_geoshape() {
            visualInspectionPoint()
            calculate_fit_circle_bounds()
            //None should be visible
            verify(!is_coord_on_screen(fitCircleTopLeft))
            verify(!is_coord_on_screen(fitCircleBottomRight))
            verify(!is_coord_on_screen(fitRect.topLeft))
            verify(!is_coord_on_screen(fitRect.bottomRight))

            map.visibleRegion = fitRect
            visualInspectionPoint()
            calculate_fit_circle_bounds()
            //Rectangle should be visible, not circle
            verify(!is_coord_on_screen(fitCircleTopLeft))
            verify(!is_coord_on_screen(fitCircleBottomRight))
            verify(is_coord_on_screen(fitRect.topLeft))
            verify(is_coord_on_screen(fitRect.bottomRight))

            map.visibleRegion = fitCircle
            visualInspectionPoint()
            calculate_fit_circle_bounds()
            //Circle should be visible, not rectangle
            verify(is_coord_on_screen(fitCircleTopLeft))
            verify(is_coord_on_screen(fitCircleBottomRight))
            verify(!is_coord_on_screen(fitRect.topLeft))
            verify(!is_coord_on_screen(fitRect.bottomRight))

            map.visibleRegion = fitInvalidShape
            visualInspectionPoint()
            calculate_fit_circle_bounds()
            //Invalid shape, map should be in the same position as before
            verify(is_coord_on_screen(fitCircleTopLeft))
            verify(is_coord_on_screen(fitCircleBottomRight))
            verify(!is_coord_on_screen(fitRect.topLeft))
            verify(!is_coord_on_screen(fitRect.bottomRight))

            map.visibleRegion = fitEmptyRect
            visualInspectionPoint()
            calculate_fit_circle_bounds()
            //Empty shape, map should change centerlocation, empty rect visible
            verify(!is_coord_on_screen(fitCircleTopLeft))
            verify(!is_coord_on_screen(fitCircleBottomRight))
            verify(is_coord_on_screen(fitEmptyRect.topLeft))
            verify(is_coord_on_screen(fitEmptyRect.bottomRight))

            // Test if this can be reset
            map.visibleRegion = fitRect
            verify(is_coord_on_screen(fitRect.topLeft))
            verify(is_coord_on_screen(fitRect.bottomRight))
            // move map
            map.center = QtPositioning.coordinate(0,0)
            verify(!is_coord_on_screen(fitRect.topLeft))
            verify(!is_coord_on_screen(fitRect.bottomRight))
            // recheck
            map.visibleRegion = fitRect
            verify(is_coord_on_screen(fitRect.topLeft))
            verify(is_coord_on_screen(fitRect.bottomRight))
            //zoom map
            map.zoomLevel++
            verify(!is_coord_on_screen(fitRect.topLeft))
            verify(!is_coord_on_screen(fitRect.bottomRight))
            // recheck
            map.visibleRegion = fitRect
            verify(is_coord_on_screen(fitRect.topLeft))
            verify(is_coord_on_screen(fitRect.bottomRight))
        }

        // checks that circles belongs to the view port
        function circle_in_viewport(center, radius, visible)
        {
            for (var i = 0; i < 128; ++i) {
                var azimuth = 360.0 * i / 128.0;
                var coord = center.atDistanceAndAzimuth(radius,azimuth)
                if (coord.isValid)
                    verify(is_coord_on_screen(coord) === visible, visible ?
                               "circle not visible" : "circle visible")
            }
        }

        function test_fit_circle_to_viewport(data)
        {
            verify(!is_coord_on_screen(data.center))
            circle_in_viewport(data.center, data.radius, false)
            map.visibleRegion = QtPositioning.circle(data.center, data.radius)
            circle_in_viewport(data.center, data.radius, true)
        }

        function test_fit_circle_to_viewport_data()
        {
            return [
                        { tag: "circle 1", center:
                            QtPositioning.coordinate(70,70), radius: 10 },
                        { tag: "circle 2", center:
                            QtPositioning.coordinate(80,30), radius: 2000000 },
                        { tag: "circle 3", center:
                            QtPositioning.coordinate(-82,30), radius: 2000000 },
                        { tag: "circle 4", center:
                            QtPositioning.coordinate(60,179), radius: 20000 },
                        { tag: "circle 5", center:
                            QtPositioning.coordinate(60,-179), radius: 20000 },
                    ]
        }

        function test_fit_rectangle_to_viewport(data)
        {
            verify(!is_coord_on_screen(data.topLeft),"rectangle visible")
            verify(!is_coord_on_screen(data.bottomRight),"rectangle visible")
            map.visibleRegion = QtPositioning.rectangle(data.topLeft,data.bottomRight)
            verify(is_coord_on_screen(data.topLeft),"rectangle not visible")
            verify(is_coord_on_screen(data.bottomRight),"rectangle not visible")
        }

        function test_fit_rectangle_to_viewport_data()
        {
            return [
                        { tag: "rectangle 1",
                            topLeft: QtPositioning.coordinate(80, 80),
                            bottomRight: QtPositioning.coordinate(78, 82) },
                        { tag: "rectangle 2",
                            topLeft: QtPositioning.coordinate(30,-130),
                            bottomRight: QtPositioning.coordinate(0,-100)}
                    ]
        }

        /*function test_ad_visible_items_move() {
            // move different individual items out of screen
            // then fit viewport
            var xDir = 1
            var yDir = 0
            var xDirChange = -1
            var yDirChange = 1
            var dir = 0
            var move = 50
            for (dir = 0; dir < 4; dir++) {
                // move rect out of screen
                reset()
                verify_visibility_all_items()
                preMapRect.topLeft.longitude += move * xDir
                preMapRect.topLeft.latitude += move * yDir
                preMapRect.bottomRight.longitude += move * xDir
                preMapRect.bottomRight.latitude += move * yDir
                calculate_bounds()
                verify(!is_coord_on_screen(preMapRect.topLeft))
                verify(!is_coord_on_screen(preMapRect.bottomRight))
                map.fitViewportToMapItems()
                visualInspectionPoint()
                verify_visibility_all_items()

                // move circle out of screen
                reset()
                verify_visibility_all_items()
                preMapCircle.center.longitude += move * xDir
                preMapCircle.center.latitude += move * yDir
                calculate_bounds()
                verify(!is_coord_on_screen(mapCircleTopLeft))
                verify(!is_coord_on_screen(mapCircleBottomRight))
                map.fitViewportToMapItems()
                visualInspectionPoint()
                verify_visibility_all_items()

                // move quick item out of screen
                reset()
                verify_visibility_all_items()
                preMapQuickItem.coordinate.longitude += move * xDir
                preMapQuickItem.coordinate.latitude += move * yDir
                calculate_bounds()
                verify(!is_coord_on_screen(mapQuickItemTopLeft))
                verify(!is_coord_on_screen(mapQuickItemBottomRight))
                map.fitViewportToMapItems()
                visualInspectionPoint()
                verify_visibility_all_items()

                // move map polygon out of screen
                reset()
                verify_visibility_all_items()
                var i
                for (i = 0; i < preMapPolygonDefaultPath.length; ++i) {
                    preMapPolygon.path[i].longitude += move * xDir
                    preMapPolygon.path[i].latitude += move * yDir
                }
                calculate_bounds()
                verify(!is_coord_on_screen(mapPolygonTopLeft))
                verify(!is_coord_on_screen(mapPolygonBottomRight))
                map.fitViewportToMapItems()
                visualInspectionPoint()
                verify_visibility_all_items()
               if (dir == 2)
                    xDirChange *= -1
                if (dir == 1)
                    yDirChange *= -1
                xDir += xDirChange
                yDir += yDirChange
            }
        }*/

        function clear_data() {
            preMapRectClicked.clear()
            preMapCircleClicked.clear()
            preMapQuickItemClicked.clear()
            preMapPolygonClicked.clear()
            preMapCircleCenterChanged.clear()
            preMapCircleColorChanged.clear()
            preMapCircleRadiusChanged.clear()
            preMapCircleBorderColorChanged.clear()
            preMapCircleBorderWidthChanged.clear()
            preMapRectTopLeftChanged.clear()
            preMapRectBottomRightChanged.clear()
            preMapRectColorChanged.clear()
            preMapPolylineColorChanged.clear()
            preMapPolylineWidthChanged.clear()
            preMapPolylinePathChanged.clear()
            preMapPolygonPathChanged.clear()
            preMapPolygonColorChanged.clear()
            preMapPolygonBorderColorChanged.clear()
            preMapPolygonBorderWidthChanged.clear()
            preMapRouteRouteChanged.clear()
            preMapRouteLineColorChanged.clear()
            preMapRouteLineWidthChanged.clear()
            preMapQuickItemCoordinateChanged.clear()
            preMapQuickItemAnchorPointChanged.clear()
            preMapQuickItemZoomLevelChanged.clear()
            preMapQuickItemSourceItemChanged.clear()
        }

        function calculate_fit_circle_bounds() {
            var circleDiagonal = Math.sqrt(2 * fitCircle.radius * fitCircle.radius)
            fitCircleTopLeft = fitCircle.center.atDistanceAndAzimuth(circleDiagonal,-45)
            fitCircleBottomRight = fitCircle.center.atDistanceAndAzimuth(circleDiagonal,135)
        }

        function calculate_bounds(){
            var circleDiagonal = Math.sqrt(2 * preMapCircle.radius * preMapCircle.radius)
            var itemTopLeft = preMapCircle.center.atDistanceAndAzimuth(circleDiagonal,-45)
            var itemBottomRight = preMapCircle.center.atDistanceAndAzimuth(circleDiagonal,135)

            mapCircleTopLeft = itemTopLeft;
            mapCircleBottomRight = itemBottomRight;

            itemTopLeft = preMapQuickItem.coordinate
            var preMapQuickItemScreenPosition = map.fromCoordinate(preMapQuickItem.coordinate)
            preMapQuickItemScreenPosition.x += preMapQuickItem.sourceItem.width
            preMapQuickItemScreenPosition.y += preMapQuickItem.sourceItem.height
            itemBottomRight = map.toCoordinate(preMapQuickItemScreenPosition)

            mapQuickItemTopLeft = itemTopLeft;
            mapQuickItemBottomRight = itemBottomRight;

             var bounds = min_max_bounds_from_list(preMapPolygon.path)
             mapPolygonTopLeft = bounds.topLeft;
             mapPolygonBottomRight = bounds.bottomRight;

             bounds = min_max_bounds_from_list(preMapPolyline.path)
             mapPolylineTopLeft = bounds.topLeft;
             mapPolylineBottomRight = bounds.bottomRight;

             bounds = min_max_bounds_from_list(preMapRoute.route.path)
             mapRouteTopLeft = bounds.topLeft;
             mapRouteBottomRight = bounds.bottomRight;
        }

        function min_max_bounds_from_list(coorindates){
            var i = 0
            var point = map.fromCoordinate(coorindates[0])
            var minX = point.x
            var minY = point.y
            var maxX = point.x
            var maxY = point.y

            for (i=1; i < coorindates.length; ++i) {
                point = map.fromCoordinate(coorindates[i])
                if (point.x < minX)
                    minX = point.x
                if (point.x > maxX)
                    maxX = point.x
                if (point.y < minY)
                    minY = point.y
                if (point.y > maxY)
                    maxY = point.y
            }
            point.x = minX
            point.y = minY
            var itemTopLeft = map.toCoordinate(point)
            point.x = maxX
            point.y = maxY
            var itemBottomRight = map.toCoordinate(point)

            return QtPositioning.rectangle(itemTopLeft, itemBottomRight);
        }

        function verify_visibility_all_items(){
            calculate_bounds()
            verify(is_coord_on_screen(preMapRect.topLeft))
            verify(is_coord_on_screen(preMapRect.bottomRight))
            verify(is_coord_on_screen(mapCircleTopLeft))
            verify(is_coord_on_screen(mapCircleBottomRight))
            verify(is_coord_on_screen(mapPolygonTopLeft))
            verify(is_coord_on_screen(mapPolygonBottomRight))
            verify(is_coord_on_screen(mapQuickItemTopLeft))
            verify(is_coord_on_screen(mapQuickItemBottomRight))
            verify(is_coord_on_screen(mapPolylineTopLeft))
            verify(is_coord_on_screen(mapPolylineBottomRight))
            verify(is_coord_on_screen(mapRouteTopLeft))
            verify(is_coord_on_screen(mapRouteBottomRight))
        }


        function is_coord_on_screen(coord) {
            return is_point_on_screen(map.fromCoordinate(coord))
        }

        function is_point_on_screen(point) {
            if (point.x >= 0 && point.x <= (map.x + map.width)
                    && point.y >=0 && point.y <= (map.y + map.height) )
                return true;
            else
                return false;
        }

        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)
            }
        }
    }
}