// Click funtion onMapExplode uitgebreid met handleGWLayer
// Tijdelijk totdat LIC gebruik maakt van rik.js versie 1.8
OpenLayers.Control.Click.prototype.onMapExplode = function(){
    if (this.activator == true) {
        this.activator = false;
        this.features = [];
        for (var i = 0, len = this.activeLayers.length ; i < len ; i++) {
            var layer = this.activeLayers[i];
            if (layer.CLASS_NAME == "OpenLayers.Layer.GW") {
                var evt = {
                    xy: this.map.getViewPortPxFromLonLat(this.lonlat),
                    type: "click"
                };
                this.handleGWLayer(layer, evt);
            }
        }
        
        this.beforeGetFeatures();
        this.getFeatures();
    }
};

// Tijdelijk totdat LIC gebruik maakt van rik.js versie 1.8
// Zorgt dat er geen request wordt gemaakt als er alleen features op de kaart staan.
OpenLayers.Control.Click.prototype.getFeatures = function(e){
    var maxDistance = this.map.getResolution() * this.pixelTolerance; //Dit hoeft niet gebruikt te worden door de bron
    
    // Alleen de lagen opvragen waarvan nog geen informatie bekend is;
    // de GW laag heeft de info al in de feature zitten als data.
    var layersExGW = [];
    for (var i = 0, len = this.activeLayers.length ; i < len ; i++) {
        if (this.activeLayers[i].CLASS_NAME != "OpenLayers.Layer.GW") {
            layersExGW.push(this.activeLayers[i]);
        }
    }
    
    var themaList = layersExGW.pluck('layercode');
    this.requestId = new Date().getTime();

    // controleren of de themaList leeg is; want dan hoeft geen request uitgezet te worden naar de backend! [PL 02-06-2009]
    if (themaList.length > 0) {
        var url = this.url;
        url += "?themalist=" + themaList.join(); 
        url += "&maxdistance=" + maxDistance;
        url += "&x=" + this.lonlat.lon;
        url += "&y=" + this.lonlat.lat;        
        url += "&requestId=" + this.requestId;
        
        var requestUrl = "";
        //requestUrl += encodeURIComponent(url);
        requestUrl = url;
                    
        new OpenLayers.Ajax.Request(requestUrl, {
            method: 'get',
            onSuccess: this.processResponse.bind(this),
            onFailure: this.loadingFailure.bind(this)
        });                    
     } else if (this.activeLayers.length > 0) {
        // Alleen GW layers in de activeLayers, dus terug naar de server is niet nodig (data komt uit features)
        this.events.triggerEvent('getFeaturesCompleted');
     }        
};

function InitKaart(contentId, width, height){
    var proxyLocation = "/javascriptproxy/Proxy.ashx";
    RikConfig.proxyLocation = proxyLocation;
    RikConfig.useProxy = true;
    Gwr.Rik.updateProxyHost();            

    // Opvragen van de mapConfig

//    AANPASSING 15-12: vanwege gebruik andere mapconfig.js
//    var mapconfig = getMapConfig();
    var mapconfig = rikMapConfig ;
    mapconfig.KaartSettings.KaartBreedte = (width?width:324);
    mapconfig.KaartSettings.KaartHoogte = (height?height:290);
    mapconfig.KaartSettings.KaartBreedteMax = 800;//width < 200 ? 200 : width;
    mapconfig.KaartSettings.KaartHoogteMax = 600;//height < 200 ? 200 : height;
    mapconfig.KaartSettings.LocatieZoekenBeschikbaar = false;
    mapconfig.KaartSettings.LegendaBeschikbaar = false;

// Override van welke kaartlaag default zichtbaar is.
//  0 = straatlaag
//  1 = luchtfotolaag
    mapconfig.KaartSettings.KaartlaagSettings[0].IsZichtbaar = false;
    mapconfig.KaartSettings.KaartlaagSettings[1].IsZichtbaar = true;

    if (mapconfig) {
        deKaart = new Gwr.Rik.KaartControl('Kaart', mapconfig);
        
        OpenLayers.Feature.Vector.style['default']['strokeWidth'] = '2';

        var options = {
            layerid: "CPR." + contentId,
            category: "CPR",
            layercode: "CPR." + contentId,
            layername: "CPR." + contentId,
            useBBox: true,
            expiresIn: 10,
            maxAge: 10,
            subTypes: [],
            minScale: 500000,
            maxScale: 0,
            visibility: true,
            volgorde: 1,
            alpha: false,
            isBaseLayer: false,
            type: null,
            tileOrigin: null,
            titel: "CPR." + contentId,
            useBBox: false,
            // TODO: hier een correcte icon url invullen:
            legendaIcon: "http://tile.gis.rotterdam.nl/gw2images/legend/rdam.vzg.2709.gif",

            kaartLaag: {
                CacheTijd: 15,
                Code: "CPR." + contentId,
                Id: 1,
                KaartType: "GWGML",
                KaartUrl: "http://intra.gis.rotterdam.nl/lic.locaties/GW.ashx",
                // TODO: hier een correcte icon url invullen:
                LegendaIcon: "http://tile.gis.rotterdam.nl/gw2images/legend/rdam.vzg.2709.gif",
                Klassen: [],
                InformatieBeschikbaar: true,
                RequestFeaturesPerBBox: false


            },
            labelsBeschikbaar: false
        };
        vlayer = new OpenLayers.Layer.GW("CPR." + contentId, "http://intra.gis.rotterdam.nl/lic.locaties/GW.ashx", options);
        deKaart.map.map.addLayer(vlayer);
        vlayer.featureManager.events.on({ 'loadend': loadEnd });
        
        for (var i = 0, len = deKaart.map.map.controls.length ; i < len ; i++) {
            var control = deKaart.map.map.controls[i];
            if (control.CLASS_NAME == "OpenLayers.Control.Click") {
                control.features = [];
            }
        }

    } else {
        alert("Fout bij laden van de kaart");
    }
}

function loadEnd() {
    var maxExtent = null;
    if (vlayer.featureManager) {
        // Zoom in zodat alle features zichtbaar zijn
        if (vlayer.featureManager.points) {
            for (var i = 0, len = vlayer.featureManager.points.length ; i < len ; i++) {
                maxExtent = extendExtent(maxExtent, vlayer.featureManager.points[i].geometry);
            }
        }

        if (vlayer.featureManager.lines) {
            for (var i = 0, len = vlayer.featureManager.lines.length ; i < len ; i++) {
                maxExtent = extendExtent(maxExtent, vlayer.featureManager.lines[i].geometry);
            }
        }

        if (vlayer.featureManager.polygons) {
            for (var i = 0, len = vlayer.featureManager.polygons.length ; i < len ; i++) {
                maxExtent = extendExtent(maxExtent, vlayer.featureManager.polygons[i].geometry);
            }
        }
    }

    if (maxExtent) {
        vlayer.featureManager.events.un({ 'loadend': loadEnd });
        
        // Als er slechts 1 feature is, dan uitzoomen totdat er minstens een ruimte van 200x200m zichtbaar is.
        var zoomBox = 200;
        if (maxExtent.top - maxExtent.bottom < zoomBox) {
            maxExtent.top += (zoomBox / 2);
            maxExtent.bottom -= (zoomBox / 2);
        }
        
        
        if (maxExtent.right - maxExtent.left < zoomBox) {
            maxExtent.right += (zoomBox / 2);
            maxExtent.left -= (zoomBox / 2);
        }
        
        deKaart.map.map.zoomToExtent(maxExtent);
    }
}

function extendExtent(extent, geometry) {
    var newExtent;
    if ((extent == null) || (extent == undefined)) {
        newExtent = geometry.getBounds();
    } else {
        extent.extend(geometry.getBounds());
        newExtent = extent;
    }
    
    return newExtent;
}