/*
 *
 *  GTCampaignElementHandler - Handles the integration of the Ovi map into the campaign element toolkit, and
 *                             encapsulates general functions that control the apperance of the element.
 *
 *  The primary function of this class is to hancle the communication between the map component and the
 *  toolkit and the rest of the campaign element. Also, it encapsulates some general functions such as
 *  toggleCapaignElement() that shows/hides the expanded campaign element.
 *
 */
function GTCampaignElementHandlerClass() {
    var me = this;
    var mapPlayer = null;
    var currentGTMarkers = [];
    var showingMarkerObjects = [];
    var showingCraneObjects = [];
    var markerLayer = null;
    var craneLayer = null;
    var selectedLayer = null;
    var CONTAINER_ARROWS = 0;
    var CONTAINER_CRANE = 1;

    var selectedMarker = [];

    var MANUAL_GT = "MANUAL_GT";
    var DO_MARKER_ADJUSTMENTS = true;
    var GT_X_ADJ = -8;
    var GT_Y_ADJ = -19;
    var GT_BIG_X_ADJ = -15;
    var GT_BIG_Y_ADJ = -33;
    var CENTERMARKER_X_ADJ = -10;
    var CENTERMARKER_Y_ADJ = -10;

    var MAP_ICON_EXT;
    if ($.browser.msie && $.browser.version.substring(0,1) == 6) {
        MAP_ICON_EXT = ".gif";
    } else {
        MAP_ICON_EXT = ".png";
    }

    this.currentView = -1;

    this.adjustIconPositions = function() {
        if (!DO_MARKER_ADJUSTMENTS) return;

        var adjPixels = getAdjustmentForOnePixel(getAllMapObjects());
        if (adjPixels == null) {
            return;
        }
        gtToolkit.showError("adjustmentForOnePixel was " + adjPixels.dLat + ":" + adjPixels.dLon);

        if (showingMarkerObjects && showingMarkerObjects.length > 0) {
            for (var i = 0; i < showingMarkerObjects.length; i++) {
                //adjustMarkerPos(showingMarkerObjects[i], adjPixels.dLon * GT_X_ADJ, adjPixels.dLat * GT_Y_ADJ);
                adjustMarkerPosOrGeo(showingMarkerObjects[i], adjPixels.dLon * GT_X_ADJ, adjPixels.dLat * GT_Y_ADJ, GT_X_ADJ, GT_Y_ADJ);
            }
        }
        if (centeredMarker && centeredMarker.length > 0) {
            //adjustMarker(centeredMarker[0], CENTERMARKER_X_ADJ, CENTERMARKER_Y_ADJ);
            //adjustMarkerPos(centeredMarker[0], CENTERMARKER_X_ADJ * adjPixels.dLon, CENTERMARKER_Y_ADJ * adjPixels.dLat);
            adjustMarkerPosOrGeo(centeredMarker[0], CENTERMARKER_X_ADJ * adjPixels.dLon, CENTERMARKER_Y_ADJ * adjPixels.dLat, CENTERMARKER_X_ADJ, CENTERMARKER_Y_ADJ);
        }
        if (selectedMarker && selectedMarker.length > 0) {
            adjustMarkerPosOrGeo(selectedMarker[0],  GT_BIG_X_ADJ * adjPixels.dLon, GT_BIG_Y_ADJ * adjPixels.dLat, GT_BIG_X_ADJ, GT_BIG_Y_ADJ);
//            adjustMarkerPos(selectedMarker[0],  GT_BIG_X_ADJ * adjPixels.dLon, GT_BIG_Y_ADJ * adjPixels.dLat);
//            adjustMarker(selectedMarker[0],  GT_BIG_X_ADJ, GT_BIG_Y_ADJ);
        }
    }

    this.markerAdjustmentsEnabled = function(trueorfalse) {
        DO_MARKER_ADJUSTMENTS = trueorfalse;
    }
    this.isMarkerAdjustmentsEnabled = function() {
        return DO_MARKER_ADJUSTMENTS;
    }
    function getAllMapObjects() {
        return selectedMarker.concat(centeredMarker, showingMarkerObjects, showingCraneObjects);
    }

    function getAdjustmentForOnePixel(allMarkers) {
        for (var i = 0; i < allMarkers.length; i++) {
            var marker = allMarkers[i];
            var pos = marker['__originalPos']
            if (pos) {
                var xy = null;
                try {
                    xy = mapPlayer.map.geoToPixel(pos);
                } catch (error) { /* noop */ };
                if (xy) {
                    xy.x += 10;
                    xy.y += 10;
                    var newPos = mapPlayer.map.pixelToGeo(xy.x, xy.y);
                    return {dLat: (newPos.latitude - pos.latitude)/10.0, dLon: (newPos.longitude - pos.longitude)/10.0};
                }
            }
        }

        // If we got here there was no showing marker, so just take a pixel in the middle of the canvas and use that
        gtToolkit.showError("adjustmentForOnePixel was NOT FOUND");
        var pos = mapPlayer.map.pixelToGeo(145, 95);
        var newPos = mapPlayer.map.pixelToGeo(155, 105);
        return {dLat: (newPos.latitude - pos.latitude)/10.0, dLon: (newPos.longitude - pos.longitude)/10.0};
    }

    function adjustMarker(marker, dx, dy) {
        try {
            if (!marker.isVisible()) return;
            
            var pos;
            if (marker['__originalPos']) {
                pos = marker['__originalPos'];
            } else {
                gtToolkit.showError("No originalPos for item at " + marker.getPosition().latitude + ":" + marker.getPosition().longitude);
//                marker['__originalPos'] = pos = marker.getPosition();
            }
//            gtToolkit.showError("originalPos: " + pos.latitude + ":" + pos.longitude);
            var xy = mapPlayer.map.geoToPixel(pos);
            if (xy) {
                xy.x += dx;
                xy.y += dy;
                var newPos = mapPlayer.map.pixelToGeo(xy.x, xy.y);
                marker.setPosition(newPos);
//                gtToolkit.showError("delta newPos: " + (newPos.latitude - pos.latitude) + ":" + (newPos.longitude - pos.longitude));
            }
        } catch (error) {gtToolkit.showError(error);}
    }

    function adjustMarkerPosOrGeo(marker, dLon, dLat, dx, dy) {
        try {
            var pos;
            if (marker['__originalPos']) {
                pos = marker['__originalPos'];
            } else {
                gtToolkit.showError("No originalPos for item at " + marker.getPosition().latitude + ":" + marker.getPosition().longitude);
//                marker['__originalPos'] = pos = marker.getPosition();
                return;
            }
            var xy = null;
            var newPos = null
            try {
                xy = mapPlayer.map.geoToPixel(pos);
            } catch (error) { gtToolkit.showError("No geo:" + error.message)/* noop */ };
            if (xy) {
                xy.x += dx;
                xy.y += dy;
                newPos = mapPlayer.map.pixelToGeo(xy.x, xy.y);
            } else {
                newPos = {latitude: pos.latitude + dLat, longitude: pos.longitude + dLon};
            }
//            gtToolkit.showError("delta newPos: " + (newPos.latitude - pos.latitude) + ":" + (newPos.longitude - pos.longitude));
            marker.setPosition(newPos);
        } catch (error) {gtToolkit.showError(error);}
    }

    function adjustMarkerPos(marker, dLon, dLat) {
        try {
            var pos;
            if (marker['__originalPos']) {
                pos = marker['__originalPos'];
            } else {
                gtToolkit.showError("No originalPos for item at " + marker.getPosition().latitude + ":" + marker.getPosition().longitude);
//                marker['__originalPos'] = pos = marker.getPosition();
                return;
            }

            var newPos = {latitude: pos.latitude + dLat, longitude: pos.longitude + dLon};
            gtToolkit.showError("delta newPos: " + (newPos.latitude - pos.latitude) + ":" + (newPos.longitude - pos.longitude));
            marker.setPosition(newPos);
        } catch (error) {gtToolkit.showError(error);}
    }

    this.getMapPlayer = function() {
        return mapPlayer;
    }

    var callTrackingFunctions = function() {
        try {
            if (typeof farfarstat == "function") {
                gtToolkit.showError("Calling farfarstat()");
                _key = "59cc298757408af74b638ff4b4fbe441";
                farfarstat();
            }
            if (typeof re_ == "function") {
                gtToolkit.showError("Calling re_()");
                re_("94krx-23lj2skgh2");
            }
        } catch (err) {
            gtToolkit.showError("Error calling stats reporting functions: " + err);
        }
    }

    this.toggleCampaignElement = function() {
        if ($('#extended_campaign').is(':hidden')) {       
            $('.extended_flash').hide('');
            $('#player').hide();
            $('#gtdisclaimer').removeClass("gtdisclaimer-top");
            $('#gtdisclaimercontainer').addClass("gtdisclaimer-bottom");
            $('#gtdisclaimercontainer').removeClass("gtdisclaimer-top");
            $('#gtdisclaimer').addClass("gtdisclaimer-bottom");
            $('.gt_extended_campaign').slideToggle(300, function() {
                if (!$('#extended_campaign').is(':hidden')) {
                    $('.extended_flash').show();
                    $('#player').show();
                    if (mapPlayer == null) {
                        // Instantiate the map player
                        // TODO: For now, force use of the JS version.
                        var pfwpath = mapplayer_path + "/pfw/";
                        var dfwpath = mapplayer_path + "/dfw/";
                        var mapplayerpath = mapplayer_path + "/mapplayer/";
                        var internationalizationpath = mapplayer_path + "/i18n/";
                        gtToolkit.showError("Paths: " +pfwpath + " " + dfwpath +" " + mapplayerpath+ " " + internationalizationpath);
                        mapPlayer = new nokia.maps.mapplayer.MapPlayer(document.getElementById("player"),
                        {   "pfwPath":  pfwpath,
                            "dfwPath":      dfwpath,
                            "mapplayerPath":  mapplayerpath,
                            "internationalizationPath":   internationalizationpath,
                            forceJS: true,
                            "jsPlugin": "forced"
                        });
                        player = mapPlayer;
                        mapPlayer.addEventHandler(nokia.maps.pfw.Player.EVENT_INITIALIZATION_DONE, initializeMap);
                        eval(nokia.aduno.utils.getImportCode());
                    }
                    callTrackingFunctions();
                }
            });
        }
    }

    this.homeLocationChanged = function(newLocation) {
        if (mapPlayer == null) return;
        if (newLocation == null || newLocation['latitude'] == null) return;

        mapPlayer.map.moveTo({
            latitude: newLocation.latitude,
            longitude: newLocation.longitude,
            scale:2000
        });
        placeCenterMarker();
    }

    var lastSubsetIntervalBounds;
    this.showGoodThingSubset = function(subsetIntervalBounds) {
        gtToolkit.showError("Show GT subset");        
        if (me.currentView > 0) {
            // We are in crane mode, so ignore these
            gtToolkit.showError("Map ignoring SHOW_GOODTHING_SUBSET since in crane mode!");
            return;
        }
        
        lastSubsetIntervalBounds = subsetIntervalBounds;
        var markers = currentGTMarkers = gtItemsToMarkers(gtToolkit.getCurrentGoodThings());
        var startIncl = subsetIntervalBounds[0];
        var endExcl = subsetIntervalBounds[1];
        if (startIncl >= markers.length ||
            endExcl > markers.length ||
            startIncl > endExcl) {
            gtToolkit.showError('gtCampaignElementHandler.showGoodThingSubset: interval is out of bounds [' + startIncl + ';' + endExcl + '] [' + markers.length + ']');
            startIncl = collar(startIncl, 0, markers.length - 1);
            endExcl = collar(endExcl, startIncl, markers.length);
        }

        if (selectedLayer != null) {
            selectedLayer.removeLayer();
            selectedLayer = null;
        }
        if (markerLayer != null) {
            markerLayer.removeLayer();
        }
        markerLayer = mapPlayer.map.getLayer("markerLayer");
        showingMarkerObjects = markerLayer.addMapObjects(markers.slice(startIncl, endExcl));
        addOriginalPosToMapItems(showingMarkerObjects, markers.slice(startIncl, endExcl));
        me.showCranes() ;
       // mapPlayer.map.moveToPoints({points: showingMarkerObjects, centerPoint : {latitude: gtToolkit.getHomeLocation().latitude, longitude:gtToolkit.getHomeLocation().longitude}});
        mapPlayer.map.moveToPoints({points: showingMarkerObjects});
        var zscale = mapPlayer.map.getZoomScale();
        if (zscale > mapPlayer.map.getMaxZoomScale()/4) {
            mapPlayer.map.setZoomScale( mapPlayer.map.getMaxZoomScale()/4);
        }
        me.adjustIconPositions();
    }

    this.focusOnGoodThing = function(guid) {
        if (mapPlayer == null) return;

        if (selectedMarker && selectedMarker.length > 0) {
            var gt = selectedMarker[0]['__gtMarker'];
            if (gt && gt['guid'] && gt.guid == guid) {
                gtToolkit.showError("We are already focused on " + guid + "!");
                return;
            }
        }

        if (selectedLayer) {
            selectedLayer.removeLayer();
        }
//        resetOriginalIcons();
        unHideAllMarkers();

        for (var i = 0; i < currentGTMarkers.length; i++) {
            var gt = currentGTMarkers[i];
            if (gt.guid == guid) {
                if (typeof gt.zoomLevel != 'undefined' && gt.zoomLevel > 0) {
                    gt["scale"] = parseInt(gt.zoomLevel);
                } else {
                    gt["scale"] = 2000;
                }
                if (gt["scale"] > mapPlayer.map.getMaxZoomScale()) { gt["scale"] = mapPlayer.map.getMaxZoomScale(); }
                else if (gt["scale"] < mapPlayer.map.getMinZoomScale() ) {gt["scale"] = mapPlayer.map.getMinZoomScale();}

                var mapObj = mapObjectForGT(gt);
                if (mapObj != null) {
                    mapObj.hide();

                    var icon = mapObj.getIcon();
                    var newIcon = (icon.substring(0, icon.length - 4) + "_big" + MAP_ICON_EXT);

                    var newMarker = clone(gt);
                    newMarker.icon = newIcon;
                    newMarker.handler = function(goodThingsItem){
                        return function(aClickEvent) {
                            //Nokia.Maps.Events.fireGlobalEvent(Nokia.Maps.Events.GlobalRegistry.GOODTHINGS_ITEM_SELECTED, goodThingsItem, "map");
                            // no-op
                        }(goodThingsItem)
                    }
                    selectedLayer = mapPlayer.map.getLayer("selectedLayer");
                    selectedMarker = selectedLayer.addMapObjects([newMarker]);
                    addOriginalPosToMapItems(selectedMarker, [newMarker]);
                    this.adjustIconPositions();
                } else {
                    gtToolkit.showError(("No mapobj found for GT " + gt.title))
                }

                mapPlayer.map.moveTo(gt);

//                mapPlayer.showInfoBubble(gt);
                return;
            }
        }
    }

    function clone(obj){
        if(obj == null || typeof(obj) != 'object')
            return obj;

        var temp = new obj.constructor(); // changed (twice)

        for(var key in obj)
            temp[key] = clone(obj[key]);
        return temp;
    }

    function resetOriginalIcons() {
        for (var i = 0; i < showingMarkerObjects.length; i++) {
            var o = showingMarkerObjects[i];
            if (o['originalIcon']) {
                o.setIcon(o['originalIcon'])
                o['originalIcon'] = null
            }
        }
    }

    function unHideAllMarkers() {
        for (var i = 0; i < showingMarkerObjects.length; i++) {
            var o = showingMarkerObjects[i];
            if (!o.isVisible()) {
                o.show();
            }
        }
    }

    function addOriginalPosToMapItems(mapItems, mapMarkers) {
        for (var i = 0; i < mapItems.length; i++) {
            var o = mapItems[i];
            var pos = o.getPosition();
            o['__originalPos'] = clone(pos);
            o['__gtMarker'] = mapMarkers[i];
        }
    }

    function mapObjectForGT(gt) {
        var showingObjs = showingMarkerObjects;
        var res = null;
        for (var i = 0;i < showingObjs.length; i++) {
            var objData = showingObjs[i];
            var pos = objData['__originalPos'];
            if (pos == null) {
                pos = objData.getPosition();
            }
            if (Math.abs(gt.latitude - pos.latitude) < 0.00000001 &&
                Math.abs(gt.longitude - pos.longitude) < 0.00000001) {
                res = objData;
                break;
            }
        }

        return res;
    }

    this.showPositionOnMap = function(position) {
        if (mapPlayer == null) return;
        position["scale"] = 2000;
        mapPlayer.map.moveTo(position);
    }

    this.searchResultReceived = function(positions) {
        /*
        var addrsStr = "Received addresses:\n";
        for (var i = 0; i < positions.length; i++) {
            addrsStr += positions[i]["title"] + "\n";
        }
        addrsStr += "\n\n Automatically selecting the first one...";
        if (positions.length > 0) {
            alert(addrsStr);
            gtToolkit.setHomeLocation({
                longitude: parseFloat(positions[0].longitude),
                latitude:  parseFloat(positions[0].latitude),
                city: positions[0].city,
                countryName: positions[0].country,
                region: positions[0].district
            });
        } else {
            alert("No matching results found. Refine or re-phrase your search critereas.");
        }
       */
        // For now, set the home location to the first hit, if we have one.
    }

    this.containerViewChanged = function(containerid) {
        gtToolkit.showError("Container view change to " + containerid);
        me.currentView = containerid;
        if (containerid != CONTAINER_ARROWS) {
            var currCrane =  gtToolkit.getCurrentCraneId();
            me.highlightCrane(currCrane);
        } else {
            gtToolkit.receiveNewGoodThings(gtToolkit.getCurrentGoodThings());
        }
    }

    this.highlightCrane = function(craneid) {
        if (craneid == "London") {
            mapPlayer.map.moveTo({ latitude:  parseFloat(gtToolkit.getCraneLatLong('London')[0]), longitude:  parseFloat(gtToolkit.getCraneLatLong('London')[1])});
        }  else {
            mapPlayer.map.moveTo({ latitude:  parseFloat(gtToolkit.getCraneLatLong('Warsaw')[0]), longitude:  parseFloat(gtToolkit.getCraneLatLong('Warsaw')[1])});
        }
    }

     this.craneViewChanged = function(craneid) {
        gtToolkit.showError("Crane view change to " + craneid);
        me.highlightCrane(craneid);
    }

    this.delayedArrowsLoad = function() {
       gtToolkit.newGoodThingsReceived(gtToolkit.getCurrentGoodThings());     
    }

    this.craneLogUpdatetReceived = function(listOfGts) {
        if (me.currentView > 0) { // One of the crane views
            gtToolkit.showError("crane log update received");
            var markers = currentGTMarkers = gtItemsToMarkers(gtToolkit.getCurrentCraneLog());
            if (selectedLayer != null) {
                selectedLayer.removeLayer();
                selectedLayer = null;
            }
            if (markerLayer != null) {
                markerLayer.removeLayer();
            }
            markerLayer = mapPlayer.map.getLayer("markerLayer");
            showingMarkerObjects = markerLayer.addMapObjects(markers);
            addOriginalPosToMapItems(showingMarkerObjects, markers);
            // mapPlayer.map.moveToPoints({points:markers});
        } else {
            gtToolkit.showError("Ignoring craneLogUpdate since currentView = " +  me.currentView);
        }
    }

    this.showCranes = function(iconSize) {
        var markers = new Array();
        var icon =  image_path + "craneicon_small" + MAP_ICON_EXT;
        var iconSize = (player.map.getZoomScale() >= 10000 ? 0 : 1);
        if (gtToolkit.getCraneState('London') > -1) {
            markers.push({
                type: "marker",
                clickable: "true",
                latitude:  parseFloat(gtToolkit.getCraneLatLong('London')[0]),
                longitude:  parseFloat(gtToolkit.getCraneLatLong('London')[1]),
                icon: icon ,
                infoTitle: gtToolkit.getCopyResources()['SIGNPOST_LONDON'],
                infoDescription: "",
                guid: "londoncrane"
            });
        }
        if (gtToolkit.getCraneState('Warsaw') > -1) {
            markers.push({
                type: "marker",
                clickable: "true",
                latitude:  parseFloat(gtToolkit.getCraneLatLong('Warsaw')[0]),
                longitude:  parseFloat(gtToolkit.getCraneLatLong('Warsaw')[1]),
                icon: icon ,
                infoTitle: gtToolkit.getCopyResources()['SIGNPOST_WARSAW'],
                infoDescription: "",
                guid: "warsawcrane"
            });
        }
        if (craneLayer != null) {
            craneLayer.removeLayer();
        }
        craneLayer = mapPlayer.map.getLayer("craneLayer");
        showingCraneObjects = craneLayer.addMapObjects(markers);
        addOriginalPosToMapItems(showingCraneObjects, markers);
    }

    this.setCurrentContainerView = function(viewid) {
        gtToolkit.showError("Setting container view to " + viewid);
        me.currentView = viewid;
    }

    this.getCurrentContainerView = function() {
        return me.currentView;
    }
   
    ////////////////////////////////////////////////////////////////////////
    // Helper functions
    ////////////////////////////////////////////////////////////////////////

    // TODO: Make a correct translation of the category to the corresponding icon name
    function  categoryToIcon(category) {
        if (category == "0") { return "TOURIST_ATTRACTION"; }
        else if (category == "1") { return "TOURIST_ATTRACTION"; }
        else if (category == "2") { return "REST_AREA"; }
        else if (category == "3") { return "AMUSEMENT_PARK"; }
        else if (category == "4") { return "RESTAURANT"; }
        else {return "TOURIST_ATTRACTION"; }
    }
    function gtItemsToMarkers(gtItems) {
        var markers = [];
        for (var i = 0; i < gtItems.length; i++) {
            var gtItem = gtItems[i];
            var icon =  image_path + "gt_icon" + MAP_ICON_EXT;
            if (gtItems[i].guid.indexOf(MANUAL_GT) == 0 ) {
                icon =  image_path + "gt_icon_blue" + MAP_ICON_EXT;
            }
            markers.push({
                type: "marker",
                clickable: true,
                latitude: gtItem.latitude,
                longitude: gtItem.longitude,
                icon: icon ,
                category: gtItem.category,
                infoTitle: gtItem.title + (gtItem.author ? ' by ' + gtItem.author : ''),
                infoDescription: gtItem.description,
                guid: gtItem.guid,
                zoomLevel: gtItem.zoomLevel,
                hasOwnInfoBubble: true,
                handler: function(goodThingsItem){
                    return function(aClickEvent) {
                        //Nokia.Maps.Events.fireGlobalEvent(Nokia.Maps.Events.GlobalRegistry.GOODTHINGS_ITEM_SELECTED, goodThingsItem, "map");
                        // no-op
                    }(goodThingsItem)
                }
            });
        }
        return markers;
    }

    function collar(num, min, max) {
        return Math.min(Math.max(num, min), max);
    }

    var centerMarkerLayer = null;
    var centeredMarker = [];
    function placeCenterMarker() {
        if (centerMarkerLayer != null) {
            centerMarkerLayer.removeLayer();
        }
        centerMarkerLayer = mapPlayer.map.getLayer("centerMarkerLayer");

        var markers = [];

        markers.push({
            type: "marker",
            clickable: false,
            icon:  image_path + "you_dot" + MAP_ICON_EXT,
            infoTitle: gtToolkit.getCopyResources()['YOUR_CURRENT_LOCATION'],
            infoDescription: "",
            guid: "thisishome",
            hasOwnInfoBubble: true,
            handler: function(goodThingsItem){
                return function(aClickEvent) {
                    //Nokia.Maps.Events.fireGlobalEvent(Nokia.Maps.Events.GlobalRegistry.GOODTHINGS_ITEM_SELECTED, goodThingsItem, "map");
                    // no-op
                } (goodThingsItem)
            }
        });

        

        centeredMarker = centerMarkerLayer.addMapObjects(markers);
        addOriginalPosToMapItems(centeredMarker, markers);
    }
    // Callback function – a reference to it is passed to
// reverseGeoCode() – see below
    function revGeoCallBack (myLocation) {
        if(myLocation){
            alert(myLocation[0].ADDR_COUNTRY_CODE + ", "
                    + myLocation[0].ADDR_HOUSE_NUMBER + " "
                    + myLocation[0].ADDR_STREET_NAME + ", "
                    + myLocation[0].ADDR_CITY_NAME);
        }
        else {
            alert("nothing found");
        }
    }


    function initializeMap() {

        // Goto home location
        // Call to reverseGeoCode(), passing in geo-coordinates of
        // a location, reference to the callback function, and a
            // reference to the binding object
        me.homeLocationChanged(gtToolkit.getHomeLocation());

        // Handle mouse click on map for home relocation etc.
        player.map.addEventHandler(nokia.maps.pfw.MapModel.EVENT_MAPOBJECT_SELECTED, me.mapGTClicked);
        player.map.addEventHandler(nokia.maps.pfw.MapModel.EVENT_ZOOMSCALE, me.zoomScaleChangedHandler);
        player.map.addEventHandler(nokia.maps.pfw.MapModel.EVENT_MOVE_DONE, me.moveDoneHandler);
//        player.map.addEventHandler(nokia.maps.pfw.MapModel.EVENT_MAP_CLICKED, me.mapEventHandler);

        // Hide some of the unused spices on the map
        player.hideGUI(nokia.maps.mapplayer.MapPlayer.GUI_TOP_MENU);
        player.hideGUI(nokia.maps.mapplayer.MapPlayer.GUI_ORIENTATION_TILT_WHEEL);
        player.hideGUI(nokia.maps.mapplayer.MapPlayer.GUI_MINI_MAP);

        // Subscribe to change in elements to show on map
        gtToolkit.addListener(gtToolkit.HOME_LOCATION_CHANGED, me);
        gtToolkit.addListener(gtToolkit.SHOW_GOOD_THING_SUBSET, me);
        gtToolkit.addListener(gtToolkit.FOCUS_ON_GOOD_THING, me);
        //gtToolkit.addListener(gtToolkit.SEARCH_RESULT_RECEIVED, me);
        gtToolkit.addListener(gtToolkit.CRANE_LOG_UPDATE_RECEIVED, me);
        gtToolkit.addListener(gtToolkit.CONTAINER_VIEW_CHANGED, me);
        gtToolkit.addListener(gtToolkit.CRANE_VIEW_CHANGED, me);

        // Update the selection of visible goodthings
        var gts = gtToolkit.getCurrentGoodThings();
        if (gts.length > 0) {
            gtCampaignElementHandler.showGoodThingSubset([0,gts.length]);
        }
        // Extra CSS styling
        $(".nm_CombSlid").css("left", "1px");
        $(".nm_CombSlid").css("top", "100px");

        gtToolkit.setCampaignElemHandlerStarted();
        gtToolkit.showError("Map initialized");
    }

    this.mapEventHandler = function(event) {
        gtToolkit.showError("Map clicked");

//        var pos = mapPlayer.map.pixelToGeo(event.getData().x, event.getData().y);
//        pos.x = event.getData().x;
//        pos.y = event.getData().y;
//        if (pos.x && pos.y) {
//            gtToolkit.mapClicked(pos);
//        }
        event.preventDefault();
    }


    function objectSelectedEventHandler(event) {
        var idx =  event.getData().getId();
        gtToolkit.showError("Object selected: " + idx);
        var gts = gtToolkit.getCurrentGoodThings();
        var gt = gts[idx - 1];
        gtToolkit.showError("GT: " + gt.title);
        gtToolkit.focusOnGoodThing(gt.guid);

    }


    this.mapGTClicked = function(event) {
        var objData =  event.getData();
        if (objData && objData['__gtMarker']) {
            var gt = objData['__gtMarker'];
            gtToolkit.showError("GT: " + gt.infoTitle + "[" + gt.guid + "]");
            gtToolkit.focusOnGoodThing(gt.guid);
            if (me.currentView < 1) {
                gtToolkit.showError("Sending focusOnGoodThingArrow");
                gtToolkit.focusOnGoodThingArrow(gt.guid);
            }
            gtToolkit.showError("currentView is:" + me.currentView);

        } else {
            gtToolkit.showError("No GT found on click!");
        }
//
//
//        var idx =  event.getData().getId();
//        var gts = gtToolkit.getCurrentGoodThings();
//        var gt = null;
//        for (var i = 0; i < gts.length; i++) {
//            if (objData['__originalPos'] != null && Math.abs(gts[i].latitude - objData.__originalPos.latitude) < 0.00000001 &&
//                Math.abs(gts[i].longitude - objData.__originalPos.longitude) < 0.00000001) {
//                gt = gts[i];
//                break;
//            }
//        }
//        if (gt != null) {
//            gtToolkit.showError("GT: " + gt.title);
//            gtToolkit.focusOnGoodThing(gt.guid);
//            gtToolkit.focusOnGoodThingArrow(gt.guid);
////            event._isCancelable = true;
////            event.preventDefault();
//            return false;
//        }
//        gts = gtToolkit.getCurrentCraneLog();
//        gt = null;
//        for (var i = 0; i < gts.length; i++) {
//            if (objData['__originalPos'] != null && Math.abs(gts[i].latitude - objData.__originalPos.latitude) < 0.00000001 &&
//                Math.abs(gts[i].longitude - objData.__originalPos.longitude) < 0.00000001) {
//                gt = gts[i];
//                break;
//            }
//        }
//        if (gt != null) {
//            gtToolkit.showError("GT: " + gt.title);
//            gtToolkit.focusOnGoodThing(gt.guid);
////            event._isCancelable = true;
////            event.preventDefault();
//            return false;
//        }
    }
    this.zoomScaleChangedHandler = function(ev) {
        me.showCranes();
        me.adjustIconPositions();
     }

    this.moveDoneHandler = function(ev) {
//        me.adjustIconPositions();
     }
}

var gtCampaignElementHandler = new GTCampaignElementHandlerClass();

// For some strange reason the new mapplayer require a global player object (the mapplayer)
var player = null;