// making this a global variable so that it is accessible for
// debugging/inspecting in Firebug
var map = null;
var controls = null;
var geocoder = null;
var lonLatProj = null;
var roadProj = null;
var mapProj = null;
var marker;
var multipleMarkers;
var layerSwitch;


var lonlatOutput;
var adrOutput;


var dropdownControlId;
var lonlatControlId;

//Initiate a OpenLayers map
function initMap() {

    marker = new OpenLayers.Layer.Vector("Markers");
    marker.displayInLayerSwitcher = false;
    multipleMarkers = new OpenLayers.Layer.Markers("MultipleMarker");
    multipleMarkers.displayInLayerSwitcher = false;

    geocoder = new google.maps.Geocoder();
    lonLatProj = new OpenLayers.Projection(outputEPSG);
    roadProj = new OpenLayers.Projection(roadCordinateEPSG);
    mapProj = new OpenLayers.Projection(mapEPSG);


    /*OpenLayers.ProxyHost = "http://localhost:4624/openlayerproxy/?url=";*/
    OpenLayers.ProxyHost = getBaseUrl() + "Citizen/ProxyServer/?url="

    OpenLayers.Lang.setCode('gl');

    //maxExtent: 
    //Array(left - longitude, bottom - latitude, right - longitude, top - latitude)
    //var maxExtentBounds = new OpenLayers.Bounds(9.146217344779194, 60.762273941569475, 11.272903440952497, 58.70014746268997);
    //maxExtentBounds.transform(lonLatProj, mapProj);
    
    //var ddBounds = new OpenLayers.Bounds(initialBounds[0], initialBounds[1], initialBounds[2], initialBounds[3]);
    //ddBounds.transform(lonLatProj, mapProj);

    map = new OpenLayers.Map('map', {
        
        maxExtent: new OpenLayers.Bounds(-20037508.34,-20037508.34,20037508.34,20037508.34),
        projection: mapProj,
        tileSize: new OpenLayers.Size(512, 512),
        controls: [
                new OpenLayers.Control.Navigation(),
                new OpenLayers.Control.LayerSwitcher(),
                new OpenLayers.Control.PanZoomBar()
            ]
    });

    var gphy = new OpenLayers.Layer.Google(
                "Google Physical",
                { 'sphericalMercator': true,
                    'type': G_PHYSICAL_MAP,
                    'minZoomLevel': minZoomLevel,
                    'maxZoomLevel': maxZoomLevel,
                    'numZoomLevels': zoomLevels
                }
            );
            
            //'numZoomLevels': zoomLevels,
    var gmap = new OpenLayers.Layer.Google(
            "Google Streets", // the default
            {
            'sphericalMercator': true,
            'minZoomLevel': minZoomLevel,
            'maxZoomLevel': maxZoomLevel,
            'numZoomLevels': zoomLevels
            
            
        }
        );
    var ghyb = new OpenLayers.Layer.Google(
            "Google Hybrid",
            {
                'sphericalMercator': true,
                'type': G_HYBRID_MAP,
                'minZoomLevel': minZoomLevel,
                'maxZoomLevel': maxZoomLevel,
                'numZoomLevels': zoomLevels
            }
        );
    var gsat = new OpenLayers.Layer.Google(
            "Google Satellite",
            {
                'type': G_SATELLITE_MAP,
                'sphericalMercator': true,
                'minZoomLevel': minZoomLevel,
                'maxZoomLevel': maxZoomLevel,
                'numZoomLevels': zoomLevels
            }
     );

    map.addLayers([gmap, gphy, ghyb, gsat]);

    var ocenterPoint = new OpenLayers.LonLat(centerPoint[0], centerPoint[1]);
	ocenterPoint.transform(lonLatProj, mapProj);
	map.setCenter(ocenterPoint, initialZoom);
    
    
    //map.zoomToExtent(ddBounds);
}

function initPrintMap() {

    marker = new OpenLayers.Layer.Vector("Markers");
    marker.displayInLayerSwitcher = false;
    multipleMarkers = new OpenLayers.Layer.Markers("MultipleMarker");
    multipleMarkers.displayInLayerSwitcher = false;

    geocoder = new google.maps.Geocoder();
    lonLatProj = new OpenLayers.Projection(outputEPSG);
    roadProj = new OpenLayers.Projection(roadCordinateEPSG);
    mapProj = new OpenLayers.Projection(mapEPSG);

    OpenLayers.ProxyHost = getBaseUrl() + "Citizen/ProxyServer/?url="

    OpenLayers.Lang.setCode('gl');

    //maxExtent: 
    //Array(left - longitude, bottom - latitude, right - longitude, top - latitude)
    //var maxExtentBounds = new OpenLayers.Bounds(9.146217344779194, 60.762273941569475, 11.272903440952497, 58.70014746268997);
    //maxExtentBounds.transform(lonLatProj, mapProj);

    //var ddBounds = new OpenLayers.Bounds(initialBounds[0], initialBounds[1], initialBounds[2], initialBounds[3]);
    //ddBounds.transform(lonLatProj, mapProj);

    map = new OpenLayers.Map('map', {

        maxExtent: new OpenLayers.Bounds(-20037508.34, -20037508.34, 20037508.34, 20037508.34),
        projection: mapProj,
        tileSize: new OpenLayers.Size(512, 512),
        controls: [
                new OpenLayers.Control.LayerSwitcher()
            ]
    });

    var gphy = new OpenLayers.Layer.Google(
                "Google Physical",
                { 'sphericalMercator': true,
                    'type': G_PHYSICAL_MAP,
                    'minZoomLevel': minZoomLevel,
                    'maxZoomLevel': maxZoomLevel,
                    'numZoomLevels': zoomLevels
                }
            );

    //'numZoomLevels': zoomLevels,
    var gmap = new OpenLayers.Layer.Google(
            "Google Streets", // the default
            {
            'sphericalMercator': true,
            'minZoomLevel': minZoomLevel,
            'maxZoomLevel': maxZoomLevel,
            'numZoomLevels': zoomLevels


        }
        );
    var ghyb = new OpenLayers.Layer.Google(
            "Google Hybrid",
            {
                'sphericalMercator': true,
                'type': G_HYBRID_MAP,
                'minZoomLevel': minZoomLevel,
                'maxZoomLevel': maxZoomLevel,
                'numZoomLevels': zoomLevels
            }
        );
    var gsat = new OpenLayers.Layer.Google(
            "Google Satellite",
            {
                'type': G_SATELLITE_MAP,
                'sphericalMercator': true,
                'minZoomLevel': minZoomLevel,
                'maxZoomLevel': maxZoomLevel,
                'numZoomLevels': zoomLevels
            }
     );

    map.addLayers([gmap, gphy, ghyb, gsat]);

	var ocenterPoint = new OpenLayers.LonLat(centerPoint[0], centerPoint[1]);
	ocenterPoint.transform(lonLatProj, mapProj);
	map.setCenter(ocenterPoint, initialZoom);
    //map.zoomToExtent(ddBounds);
}

function addWMSLayers(normalLayers, routeFilter, endfunction) {
    if (normalLayers != "") {
        var multipleLayers = new OpenLayers.Layer.ArcGIS93Rest("FlereLag",
                                   WMSmultipleLayers,
                                   {
                                       layers: "show:" + normalLayers,
                                       transparent: true
                                   },
                                       {
                                           isBaseLayer: false,
                                           projection: new OpenLayers.Projection(wmsEPSG),
                                           buffer: 1
                                       });
        if (routeFilter == "" && endfunction != null)//if no routes, add completed event here
        {
            multipleLayers.events.register("loadend", multipleLayers, endfunction);
        }

        map.addLayer(multipleLayers);
    }

    if (routeFilter != "") {
        var roads = new OpenLayers.Layer.ArcGIS93Rest("Ruter",
                                   WMSroutes,
                                   {
                                       layers: "show:0",
                                       transparent: true
                                   },
                                       {
                                           isBaseLayer: false,
                                           projection: new OpenLayers.Projection(wmsEPSG),
                                           buffer: 1
                                       });

       if (endfunction != null)//if no routes, add completed event here
       {
           roads.events.register("loadend", roads, endfunction);
       }
        map.addLayer(roads);
    }
}


//Add click control to the map. LonLatControlID will receive the lon/lat and adrControlId will receive the adr
function addClickControl(lonlatId, roadDropDownId, OnMapClick) {
    dropdownControlId = roadDropDownId;
    lonlatControlId = lonlatId;

    OpenLayers.Control.Click = OpenLayers.Class(OpenLayers.Control, {
        defaultHandlerOptions: {
            'single': true
        },

        initialize: function(options) {
            this.handlerOptions = OpenLayers.Util.extend(
                        {}, this.defaultHandlerOptions
                    );
            OpenLayers.Control.prototype.initialize.apply(
                        this, arguments
                    );
            this.handler = new OpenLayers.Handler.Click(
                        this, {
                            'click': this.onClick
                        }, this.handlerOptions
                    );
        },

        onClick: function(evt) {
            var queryText = $("#JQueryText").val();
            $(dropdownControlId + ' option:first').text(queryText);
            $(dropdownControlId).val('');
            $(dropdownControlId).attr('disabled', 'disabled');
            //get coordinate
            var lonlat = map.getLonLatFromPixel(new OpenLayers.Pixel(evt.xy.x, evt.xy.y));

            //add marker before transformation
            addMarker(lonlat);



            //transform project lon lat to normal lon lat for google to work with it
            lonlat = lonlat.transform(map.getProjectionObject(), lonLatProj);
            $(lonlatControlId).val(lonlat);

            if (OnMapClick != null)
                OnMapClick(lonlat.lon, lonlat.lat);



            $.ajax(
                {
                    type: "GET",
                    url: getBaseUrl() + "Citizen/GetRoadID",
                    data: { lon: lonlat.lon, lat: lonlat.lat, epsgCode: lonLatProj.getCode() },
                    success: function(result) {
                        $(dropdownControlId).val(result);
                        $(dropdownControlId).attr('disabled', '');
                    }
                });
        }
    });

    var control = new OpenLayers.Control.Click({
        handlerOptions: {
            "single": true
        }
    });

    map.addControl(control);
    control.activate();
}


function focusOnCoordinate(coordinate) {
    var lonlatArray = coordinate.split(":");
    if (lonlatArray[0] != 0 && lonlatArray[1] != 0)
    {
        var bounds = new OpenLayers.Bounds(lonlatArray[0], lonlatArray[1], lonlatArray[2], lonlatArray[3]);
        bounds.transform(roadProj, map.getProjectionObject());
        map.zoomToExtent(bounds);
    }
}

function focusOnLonLat(lon, lat)
{
    if (lon != 0 && lat != 0) {
        var lonlat = new OpenLayers.LonLat(lon, lat);
        lonlat.transform(lonLatProj, map.getProjectionObject());
        map.moveTo(lonlat, defaultZoomLvl);
    }
    
}

//adds a marker based on longitude latitude in epsg:4326
function add4326Marker(lon, lat, memoId) {
    var lonlat = new OpenLayers.LonLat(lon, lat);
    lonlat.transform(lonLatProj, map.getProjectionObject());
    addMarker(lonlat, memoId);
}

//adds a marker based on longitude latitude in epsg:4326
function add4326MarkersToLayer(lonlats, sourceCaller) {
    $.each(lonlats, function(index, valueOfElement) {
        var lonlat = new OpenLayers.LonLat(valueOfElement.Longitude, valueOfElement.Latitude);
        lonlat.transform(lonLatProj, map.getProjectionObject());
        addMarkerToLayer(lonlat, multipleMarkers, valueOfElement.Id, valueOfElement.MemoTypeID, valueOfElement.MemoStatusID, sourceCaller);
    });
    map.addLayer(multipleMarkers);
}

function addMarker(lonlat, memoId) {
    marker.removeFeatures(marker.features);
    var url = "";
    if (memoId == 0 || memoId == null)
        url = getBaseUrl() + "Scripts/OpenLayers/img/marker-blue.png";
    else
        url = getBaseUrl() + 'Citizen/GetIcon?memoId=' + memoId;
    var feature = new OpenLayers.Feature.Vector(
            new OpenLayers.Geometry.Point(lonlat.lon, lonlat.lat),
            { some: 'data' },
            { externalGraphic: url, graphicHeight: 21, graphicWidth: 16 });
    marker.addFeatures(feature);
    map.addLayer(marker);
}


function addMarkerToLayer(lonlat, layer, memoId, memoTypeId, memoStatusId, sourceCaller) {
    var size = new OpenLayers.Size(25, 25);
    var offset = new OpenLayers.Pixel(-(size.w / 2), -size.h);
    var icon = new OpenLayers.Icon(getBaseUrl() + 'Citizen/GetIconExtended?memoTypeId=' + memoTypeId + '&memoStatusId=' + memoStatusId, size, offset);
    var marker = new OpenLayers.Marker(new OpenLayers.LonLat(lonlat.lon, lonlat.lat), icon);

    marker.events.register("click", marker, function() {

        //selectedTab is used in helpermethods.js in order to handle the clientside tab menu
        if (selectedTab != null) {
            selectedTab = 1;
        }
        
        $.ajax(
        {
            type: "GET",
            url: getBaseUrl() + sourceCaller + "/GetMemoHTMLInfo",
            data: { memoId: memoId },
            success: function(html) {
            var htmlText = html;
                var popup = new OpenLayers.Popup.FramedCloud("MarkerClick",
                       marker.lonlat,
                       new OpenLayers.Size(200, 80),
                       htmlText,
                       icon,
                       true);
                popup.autoSize = true;
                map.addPopup(popup, true);
            }
        });


    });


    layer.addMarker(marker);
}



function clearMarkers() {
    multipleMarkers.clearMarkers();
}

function removeLayers() {
    var i = 0;
    var layersCounter = 0;
    var myLayers = new Array();
    for (i = 0; i < map.layers.length; i++) {
        if (map.layers[i].isBaseLayer == false) {
            myLayers[layersCounter] = map.layers[i];
            layersCounter++;
        }
    }

    for (i = 0; i < myLayers.length; i++) {
        map.removeLayer(myLayers[i], false);
    }
}