/*
  Zoekfunctionaliteit voor watertoets
*/

/*
  Initialiseer de zoeklaag voor waterschappen
*/

var WS_FIELDS = {
  _WSOID: "OBJECTID",
  _WSID: "CBS_CODE",
  _WSNAAM: "NAAM",
  _WSDEELNEMER: "DEELNEMERWATERTOETS",
  _WSDEELNEMERSHP: "DEELNEMERW"  // afgekorte naam in shapefile
};

var CM_FIELDS = {
  _CMOID : "OBJECTID",
  _CMNAAM : "OMSCHRIJVI",
  _DEELNEMER: "DEELNEMER"
};

var ZP_FIELDS = {
  _ZPOID : "OBJECTID",
  _ZPCODE : "PC4"
};

var LM_FIELDS = {
  _LMOID : "OBJECTID",
  _LMLAYERNAME : "Title",
  _LMDESCRIPT : "Descrip",
  _LMWSID : "WSID",
  _LMLAYERTYPE : "WSTYPEID"
}

var WT_MSG = {
  INFOGEENDEELNEMER : "De watertoets van dit waterschap kunt u niet met deze website uitvoeren. Klik op een gebied van een deelnemende waterschap of gebruik het zoekvenster om te zoeken."
, INFODEELNEMER : "Naam: ${"+WS_FIELDS._WSNAAM+"}<br/>CBS Code: ${"+WS_FIELDS._WSID+"}<br/>Deelnemer watertoets<br/>Klik om in te zoomen op dit gebied."
, LADEN : "Laden waterschappen"
, GELADEN : "Waterschappen geladen"
, SLUITEN : "Sluit het venster"
, ZOEKHELP : "Gebruik het zoekvenster om de locatie te zoeken waar uw plangebied getoetst moet worden. "   
              + "U kunt ook het zoekventser sluiten en met de navigatie knoppen naar de lokatie navigeren."
, HELPGEMEENTE : "Kies eerst een waterschap, vervolgens kun u een gemeente kiezen die (gedeeltelijk) in dit waterschap ligt."
, HELPKAART : "Klik op de knop om dit venster te sluiten en te zoeken op de kaart."
, HELPWATERSCHAP : "Selecteer 1 van de deelnemende waterschappen. Zoek vervolgens op gemeente of sluit het venster en zoek verder op de kaart."
, HELPGEOCODE : "Zoek op plaats, straat en huisnummer. Klik vervolgens op de zoek knop."
, HELPPCGEOCODE : "Zoek op postcode en huisnummer. Klik vervolgens op de zoek knop."
, HELPTEKENEN : "Na het klikken op het potloodje hiernaast kunt U beginnen met het intekenen van een plangebied. Klik de hoekpunten achtereenvolgens op de kaart. Vermijdt kruisende lijnen!"
, HELPUPLOADEN : "U kunt een plangebied uploaden. Klik op de knop en volg de instructies."
, ERRORUPLOAD : "Er is een fout opgetreden bij het uploaden. \nControleer of de shapefile en zipfile aan de eisen voldoen (zie uploadscherm) \nen probeer het dan nog een keer."
, HELPADRES : "Geef het adres, bv: straatnaam 38a, zwolle "
, HELPWISSEN : "Verwijder het ingetekende plangebied"  
, HELPZOOMWS : "Zoek naar het opgegeven waterschap"            
, HELPZOOMCM : "Zoek naar de opgegeven gemeente"
, GROOTSTWSGEENDEELNEMER : "Het grootste deel van het plangebied ligt in een waterschap dat niet mee doet met De Digitale Watertoets!"
, NIETTEKENEN : "U bent niet ver genoeg ingezoomd om te mogen tekenen. U moet inzoomen tot schaalniveau 1:50.000."
};

var MAPBUTTONS_MSG = {
	PANNEN : "Pannen", 
	TEKENENWISSEN: "Verwijder het ingetekende plangebied", 
	ZOEKEN: "Gebruik deze knop om de locatie voor het plangebied te zoeken.",
	INTEKENEN: "Met behulp van deze knop kunt u een plangebied intekenen.",
	UPLOADEN: "Gebruik deze knop om uw digitale plangebied in te laden. Na het inladen wordt direct naar het plangebied ingezoomd.",
	TOETSEN: "Gebruik deze knop om het plangebied te toetsen aan de kaartlagen.",
	ZOOMIN: "Klik om in te zoomen",
	ZOOMOUT: "Klik om uit te zoomen",
	ZOOMPLAN: "Zoom in op plangebied",
	ZOOMEXTEND:	"Klik om naar heel Nederland te zoomen"
};

var DISCLAIMERTEXT = "Copyright Topografische Dienst";

/*
 * Initialisatie zoekfuctionaliteit.
 * Functie wordt geactiveerd door de dojo.onLoad in watertoets_common.js
 */
function initSearchFunctionality() {
  if(AquaWT.map.loaded) {
    console.log("Watertoets: map loaded");
    disableControls();
    laadGemeentes();
    laadWaterschappen();
        
    if (loadGisData) {
      enableControls();
      
      // Als er een plangebied is zoom daar naartoe
      if (!jsonToPlanArea()) {
        // Anders: zoom naar hoogste level
        AquaWT.map.setLevel(0);
      }
    }
  }
  
  msgBox.initMsgBox();
}


var waterschapDropdown;
var fitExtent = false;

var sortfield;
function sortValues(a,b) {
  var a0 = a[sortfield];
  var b0 = b[sortfield];
  var res = a0 == b0 ? 0 : (a0 < b0 ? -1 : 1); 
  return(res); 
}

function taskResultToDataStore(results)
{
  //Create items array to be added to store's data
  var items = [];
  var numberOfFeatures = results.features.length;
  for (var i = 0; i < numberOfFeatures; i++) {
    items.push(results.features[i].attributes);  //append each attribute list as item in store
  }
  
  // Sorteer de lijst
  items.sort(sortValues);

  //Create data object to be used in store
  var data = {
    identifier: "OBJECTID",  //This field needs to have unique values
    items: items
  };
  return new dojo.data.ItemFileReadStore({ data:data });
}

function zoomToFeature(results)
{
  if(results.features.length <= 0)
  {
    return;
  }
  var feature = results.features[0];
  zoomToGeometry(feature.geometry);
}

function zoomToGeometry(geometry)
{
  var extent = geometry.getExtent();
  AquaWT.map.setExtent(extent,fitExtent);

  toggleMapOnly(true);
}

function populateWaterschapDropdown(results) {
  sortfield = 'NAAM';
  var waterschapStore = taskResultToDataStore(results);
  
  waterschapDropdown = new dijit.form.FilteringSelect({
      id: "waterschapOID",
      name: "waterschapOID",
      store: waterschapStore,
      searchAttr: "NAAM"
  }, "waterschapInput");
}

function laadWaterschappen() {
  //build query
  console.log('Laad waterschappen');
  var queryTask = new esri.tasks.QueryTask(achtergrondLayerUrl + "/" + INDEX_WS);
  dojo.connect(queryTask, "onComplete", populateWaterschapDropdown);
  
  //build query filter
  var query = new esri.tasks.Query();
  query.returnGeometry = false;
  query.outFields = ["NAAM","OBJECTID"];
  query.where = WS_FIELDS._WSDEELNEMER + ' > 0';
  queryTask.execute(query);
}


function zoomToWaterschap()
{
  var objectId = waterschapDropdown.getValue();
  if (objectId == null || objectId == "") {
    alert("Geen waterschap geselecteerd");
    return;
  }
  
  var queryTask = new esri.tasks.QueryTask(achtergrondLayerUrl + "/" + INDEX_WS);
  fitExtent = true;
  dojo.connect(queryTask, "onComplete", zoomToFeature);
  //build query filter
  var query = new esri.tasks.Query();
  query.returnGeometry = true;
  query.outFields = ["OBJECTID"];
  query.where = WS_FIELDS._WSOID+'='+ objectId;
  queryTask.execute(query);
}



var gemeenteDropdown;

function populateGemeenteDropdown(results) {
  sortfield = "OMSCHRIJVI";
  var gemeenteStore = taskResultToDataStore(results);
  
  gemeenteDropdown = new dijit.form.FilteringSelect({
      id: "gemeenteOID",
      name: "gemeenteOID",
      store: gemeenteStore,
      searchAttr: "OMSCHRIJVI"
  }, "gemeenteInput");
}

function laadGemeentes() {
  //build query
  console.log('Laad gemeentes');
  var queryTask = new esri.tasks.QueryTask(achtergrondLayerUrl + "/" + INDEX_CM);
  dojo.connect(queryTask, "onComplete", populateGemeenteDropdown);
  
  //build query filter
  var query = new esri.tasks.Query();
  query.returnGeometry = false;
  query.outFields = ["OMSCHRIJVI","OBJECTID"];
  query.where = 'DEELNEMER=1';
  queryTask.execute(query);
}

function isGemeenteInDeelnemendeWaterschap(results){
  if (results.features.length <= 0) {
    return;
  }
  
  // Gemeente feature
  var feature = results.features[0];
  zoomToGeometryInDeelnemendeWaterschap(feature.geometry, true);
}

var isInWaterschap = true;
function zoomToGeometryInDeelnemendeWaterschap(geometry, zoomTo) {
  var queryTask = new esri.tasks.QueryTask(achtergrondLayerUrl + "/" + INDEX_WS);
  isInWaterschap = true;
  
  dojo.connect(queryTask, "onComplete", function(wsresults){
      if(wsresults.features.length > 0)
      {
        // Minimaal 1 waterschap gevonden: Zoom naar de geometry als zoomTo is true
        if (zoomTo) {
          zoomToGeometry(geometry);
        }
      }
      else {
        isInWaterschap = false;
        alert("Deze lokatie ligt in een waterschap dat niet meedoet met De Digitale Watertoets.");
      }
      dojo.publish(GEOMETRYINWATERSCHAP);
    }
  );

  // build query filter
  // Bepaal of de geometrie in een waterschap ligt dat meedoet (DEELNEMER==1)
  var query = new esri.tasks.Query();
  query.returnGeometry = false;
  query.outFields = ["OBJECTID"];
  query.geometry = geometry; 
  query.where = WS_FIELDS._WSDEELNEMER +'=1';
  queryTask.execute(query);
}

/*
 * onClick voor de zoek knop
 */
function zoomToGemeente()
{
  var objectId = gemeenteDropdown.getValue();
  if(objectId == null || objectId == "") {
    alert("Geen gemeente geselecteerd");
    return;
  }
  
  var queryTask = new esri.tasks.QueryTask(achtergrondLayerUrl + "/" + INDEX_CM);
  fitExtent = true;
  dojo.connect(queryTask, "onComplete", isGemeenteInDeelnemendeWaterschap);
  //build query filter
  var query = new esri.tasks.Query();
  query.returnGeometry = true;
  query.outFields = ["OBJECTID"];
  query.where = 'OBJECTID='+ objectId;
  queryTask.execute(query);
}



/*
 *  SearchLayer is de base class voor de zoekfuncties.
 */
dojo.declare("SearchLayer",null, {
	/* private variables */
  _queryTask: null,
  _outFields: null,
  _infoWindow: null,
  _query: null,
  _highlightSymbol: null,
  _symbol: null,
  _map: null,
	_featureSet: null,
	_name: null,

  /* Handle variabelen voor events */
  _onClickHandle: null,
  _onMouseOut: null,
  _onMouseOver: null,
  _onMapClickHandle: null,
  _onMapMouseOverHandle: null,
  _onMapExtentChangeHandle: null,
  _taskCompleted : false,
  _exeConnect: null,
  _enableInfoWindow: false,
  
  constructor : function() {
    // Highlight symbol;
    var outLineColor = new dojo.Color([255,0,0]);
    var outLineWidth = 3;
    var fillColor = new dojo.Color([125,125,200,0.5]);
    var outline = new esri.symbol.SimpleLineSymbol(esri.symbol.SimpleLineSymbol.STYLE_SOLID, outLineColor, outLineWidth);
    this._highlightSymbol = new esri.symbol.SimpleFillSymbol(esri.symbol.SimpleFillSymbol.STYLE_SOLID, outline, fillColor);

    // Symbol
    var symOutLineFillColor = new dojo.Color([255,255,255,0.35]);
    var symOutLineWidth = 1;
    var symOutLine = new esri.symbol.SimpleLineSymbol(esri.symbol.SimpleLineSymbol.STYLE_SOLID, symOutLineFillColor, symOutLineWidth);
    var symFillColor = new dojo.Color([125,200,225,0.5]);
    this._symbol = new esri.symbol.SimpleFillSymbol(esri.symbol.SimpleFillSymbol.STYLE_SOLID, symOutLine, symFillColor);
//    this.mouseClickHandler = dojo.hitch(this,this.mouseClickHandler);  
  },
	
	destroy : function() {
    this.disableEventHandlers();
	  this._queryTask = null;
	  this._outFields = null;
	  this._infoWindow = null;
	  this._query = null;
	  this._highlightSymbol = null;
	  this._symbol = null;
	  this._featureSet = null;
  },

  /*
   * Zoek met behulp van geselecteerde geometry
   * Te implementeren door afgeleide klasses.
   */ 
  searchClicked : function(geometry) {
    this.clearGraphics();
  },

  /*
   * Zoek met behulp van zoekveld 
   */
  searchByField : function(field, value) {
		if (this._featureSet === null) {
			console.log("Geen featureSet");
		  return;
	  }
		var il=this._featureSet.features.length;
    
    if(il === 0) {
      alert(value + " niet gevonden");
      return false;
    };

    for (var i = 0; i < il; i++) {
      var graphic = this._featureSet.features[i];
      if(graphic.attributes[field] == value) {
        this._map.setExtent(graphic.geometry.getExtent(),true);
				
				// Zoek op de geselecteerde geometrie
        this.searchClicked(graphic.geometry);
      }
    }

    return true;
  },
  
  /*
   * Maak een lijst van de resultaten.
   * Te implementeren door afgeleide klasses
   */
  listResults : dojo.hitch(this, function(results) {
    console.log("Watertoets: showGraphics " + this._name + " " + this._featureSet.features.length);
	}),

  showGraphics : function() {
    console.log("Watertoets: showGraphics " + this._name);
    this._map.graphics.disableMouseEvents();
    this.clearGraphics();
    
		if (this._featureSet === null) {
			console.log("Geen featureSet");
		  return;
	  }

    // Verwerk de featureSet 
    var il=this._featureSet.features.length;
    console.log("Watertoets: aantal gevonden: " + il);
    //setProgressBar(il);
    for (var i=0; i<il; i++) {
      //setProgressBar(il+i+1);
      //Get the current feature from the featureSet.
      //Feature is a graphic
      var graphic = this._featureSet.features[i];
      graphic.setSymbol(this._symbol);
      graphic.setInfoTemplate(this._infoWindow);

      //Add graphic to the map graphics layer.
      this._map.graphics.add(graphic);
    }
    
    this.setMouseEventhandlers();
  },		

  clearGraphics : function() {
    this._map.graphics.clear();
  },

  setSearchGeometry : function(geometry) {
    this._query.geometry = geometry;
  },

  setSearchWhere : function(whereClause) {
    this._query.where = whereClause;
  },

  mouseClickHandler : function(evt) {
      console.log("Watertoets: SearchLayer.onclick " + this._name);
  },
  
  mouseOverHandler : function(evt) {
    if(this._enableInfoWindow) {
      var content = evt.graphic.getContent();
      this._map.infoWindow.setContent(content);
      var title = evt.graphic.getTitle();
      this._map.infoWindow.setTitle(title);
      this._map.infoWindow.show(evt.screenPoint, this._map.getInfoWindowAnchor(evt.screenPoint));
    }
    evt.graphic.setSymbol(this._highlightSymbol);
  },

  mouseOutHandler : function(evt) {
    this._map.infoWindow.hide();
    evt.graphic.setSymbol(this._symbol);
  },

  mapClickHandler : function(evt) {
  },

  mapMouseOverHandler : function(evt) {
  },

  mapExtentChangeHandler : function(evt) {
    this._map.infoWindow.hide();
    msgBox.setMessage("");
  },
  
  setMouseEventhandlers  : function() {
    console.log("Watertoets: setMouseEventhandlers " + this._name);
    
    this._onMouseOver = dojo.connect(this._map.graphics, "onMouseOver",this,this.mouseOverHandler); 

    this._onMouseOut = dojo.connect(this._map.graphics, "onMouseOut",this, this.mouseOutHandler); 
    
    this._onClickHandle = dojo.connect(this._map.graphics, "onClick",this, this.mouseClickHandler);
    
    this._onMapClickHandle = dojo.connect(this._map, "onClick", this, this.mapClickHandler);

    this._onMapMouseOverHandle = dojo.connect(this._map, "onMouseOver", this, this.mapMouseOverHandler);

    this._onMapExtentChangeHandle = dojo.connect(this._map, "onExtentChange", this, this.mapExtentChangeHandler);

    this._map.graphics.enableMouseEvents();
  },

  /*
   * Event handlers voor de queryTask  
   */
  completeTask : function() {
    this._taskCompleted = false;

    console.log(this._queryTask.url);
    // Luister naar QueryTask onComplete event
    this._exeConnect = dojo.connect(this._queryTask, "onComplete", dojo.hitch(this,function(featureSet) {
      this.listResults(featureSet);
      this._taskCompleted = true;
      dojo.publish("queryTaskCompleted",[this._wsid]);
      console.log('queryTaskCompleted');
    }))
  },

  /*
   * Geef de eventhandlers vrij! Doe je dit niet dan blijven deze actief en krijg je hele bijzondere effecten...
   */	
  disableEventHandlers : function() {
    console.log("disableEventHandlers");
    this.disableHandle(this._onClickHandle);    
    this.disableHandle(this._onMouseOut);
    this.disableHandle(this._onMouseOver);
    this.disableHandle(this._onMapClickHandle);
    this.disableHandle(this._onMapMouseOverHandle);
    this.disableHandle(this._onMapExtentChangeHandle);

    AquaWT.map.graphics.disableMouseEvents();
  },
  
  /*
   * Vrijgeven en null maken van handle
   */
  disableHandle : function(handle) {
    if(handle) dojo.disconnect(handle);
    handle = null;
  },

  /*
   * Sorteren van de feature op basis van een veldnaam.
   * (zou mogelijk moeten zijn met de sorteerfunctie van de datastore maar niet werkend kunnen krijgen.
   */
  sortList: function(results, sortFieldName) {
    var inputArray = new Array();
    for (var i = 0, il = results.features.length; i < il; i++) {
      var featureAttributes = results.features[i].attributes;
      inputArray[i] = new Array();
      inputArray[i]['nr'] = i;
      inputArray[i]['txt'] = featureAttributes[sortFieldName];
    }
    
    for (var i = inputArray.length - 1; i >= 0; i--) {
      for (var j = 0; j < i; j++) {
        if (inputArray[j + 1]['txt'] < inputArray[j]['txt']) {
          var tempValue = inputArray[j];
          inputArray[j] = inputArray[j + 1];
          inputArray[j + 1] = tempValue;
        }
      }
    }
    
    return inputArray;
  }
  
});



/*
 * Klasse voor het zoeken op waterschap
 */
dojo.declare("SearchWatership",SearchLayer, {
  /* Handle variabelen voor events */
  _onClickHandle: null,
  _onMouseOut: null,
  _onMouseOver: null,

  _identifyTask: null,
  _identifyParams: null,
  
  constructor : function(map,layerUrl) {
		this._name = "SearchWatership";
    this._map = map;
    this._enableInfoWindow = true;
    
    console.log("queryTaskUrl: " + layerUrl);
    this._queryTask = new esri.tasks.QueryTask(layerUrl);
    this._outFields = [WS_FIELDS._WSOID,WS_FIELDS._WSID,WS_FIELDS._WSNAAM,WS_FIELDS._WSDEELNEMER];

    this._infoWindow = new esri.InfoTemplate();
    this._infoWindow.setTitle("Waterschap info");
    this._infoWindow.setContent(WT_MSG.INFODEELNEMER);

    // Set up query waterschap. Haal alle deelnemende waterschappen op.
    this._query = new esri.tasks.Query();
    this._query.outFields = this._outFields;
    this._query.returnGeometry = true;
    this._query.where = WS_FIELDS._WSDEELNEMER + ' > 0';

    // gebruik hitch om 'this' binnnen de functie te benaderen.
    this.showGraphics = dojo.hitch(this,this.showGraphics);
    this.searchByField = dojo.hitch(this,this.searchByField);
  },

  /*
   * Voer de query uit.
   */
  execute : function()  {
    console.log("Watertoets: queryTaskZoekWaterschap.execute");

    this._queryTask.execute(this._query);
    this.completeTask();
  },

  /*
   * Geef de resultaatlijst als  
   */
  listResults : function(results) {
    console.log("Watertoets: queryTaskZoekWaterschap.listResults");
    msgBox.setMessage(WT_MSG.LADEN);
    
    this._featureSet = results;
		
    var selectElement = dijit.byId("searchWSValues");
		var options = new dojo.data.ItemFileWriteStore({data: {identifier: 'wsid', items:[]}});

    var sortedResultsList = this.sortList(results,WS_FIELDS._WSNAAM);
    var sl = sortedResultsList.length;

    options.newItem({wsid: -1, name: 'Selecteer waterschap'});
		for (var i=0; i < sortedResultsList.length; i++) {
      var featureAttributes = results.features[sortedResultsList[i]['nr']].attributes;
      options.newItem({wsid: featureAttributes[WS_FIELDS._WSOID], name: featureAttributes[WS_FIELDS._WSNAAM]});
    }
    
    selectElement.store = options;
    this.showGraphics();
    
    console.log("Watertoets: queryTaskZoekWaterschap.listResults: " + this._featureSet.features.length);
    msgBox.setMessage(WT_MSG.GELADEN);
    
    return true;
  },

  resetListResults : function() {
    console.log("Watertoets: queryTaskZoekWaterschap.resetListResults");

    var selectElement = dijit.byId("searchWSValues");
    var options = new dojo.data.ItemFileWriteStore({data: {identifier: 'wsid', items:[]}});
    options.newItem({wsid: -1, name: 'Selecteer waterschap'});
        
    selectElement.store = options;

    // Maak textbox leeg
    selectElement.textbox.value = "";
  },

  mouseClickHandler : function(evt) {
      console.log("Watertoets: onclick " + this._name);
      this._map.setExtent(evt.graphic.geometry.getExtent(),true);   
      this.searchClicked(evt.graphic.geometry);
  },
  

  /*
   * Zoek objecten binnen de geselecteerde geometry
   * Wordt aangerepen vanuit searchByField
   */
  searchClicked : function(geometry) {
    console.log("Watertoets: searchClicked " + this._name);

    // Zoek gemeentes die door waterschap geometry overlapt worden.
    searchCommunityByGeometry(geometry);
  },
	
  mapClickHandler : function(evt) {
    console.log("Watertoets: mapClickHandler " + this._name);
    this._identifyTask = new esri.tasks.IdentifyTask(achtergrondLayerUrl);
  
    this._identifyParams = new esri.tasks.IdentifyParameters();
    this._identifyParams.tolerance = 3;
    this._identifyParams.returnGeometry = true;
    this._identifyParams.layerIds = [INDEX_WS];
    this._identifyParams.layerOption = esri.tasks.IdentifyParameters.LAYER_OPTION_ALL;
    
    this._identifyParams.geometry = evt.mapPoint;
    this._identifyParams.mapExtent = this._map.extent;
    
    this._identifyTask.execute(this._identifyParams, dojo.hitch(this, function(idResults) {
      console.log("Watertoets: mapClickHandler:: identifyTask.execute " + this._name);
      var idResult = idResults[0];
      if(idResult.feature.attributes[WS_FIELDS._WSDEELNEMER] == 0) {
        this._map.infoWindow.setContent(WT_MSG.INFOGEENDEELNEMER);
        this._map.infoWindow.show(evt.screenPoint, this._map.getInfoWindowAnchor(evt.screenPoint));
      }
      else {
        //this._map.setExtent(idResult.feature.geometry.getExtent());
      } 
    }));

  },

  mapMouseOverHandler : function(evt) {
    //this._map.infoWindow.setContent("Deze waterschap doet niet mee aan deze digitale watertoets.");
    //this._map.infoWindow.show(evt.screenPoint, this._map.getInfoWindowAnchor(evt.screenPoint));
  } 

});

/*
 * Bepaal de waterschap waarin het grootste deel van het plangebied ligt.
 */
dojo.declare("BepaalWaterschap",SearchLayer, {
  /* Handle variabelen voor events */
  _wsid : -1,
  _waterschap : null,
  _wsids: null,

  constructor : function(map,serviceUrl) {
    this._name = "BepaalWaterschap";
    this._map = map;

    this._queryTask = new esri.tasks.Geoprocessor(serviceUrl);
    console.log("Uitvoeren geoprocessing task: " + serviceUrl);
  },

  /*
   * Set de waterschapid en de naam van de waterschap
   */
  setWsID : function(wsid,waterschap,wsids) {
    this._wsid = wsid;
    this._waterschap = waterschap;
    this._wsids = wsids;
    
    // Set de globale variablen
    // Deze worden gebruikt in watertoets_tekenplan.js
    // TODO: Refactoren
    currentWaterschapId = wsid;
    currentWaterschap = this._waterschap;
    
    currentWaterschappen = "";
    
    // Schrijf alle ids weg als een ";" separated string
    var wsl = wsids.length;
    for(var i=0;i < wsl; i++) {
      var id = wsids[i];
      if (id !== wsid) {
        currentWaterschappen += wsids[i] + (i < wsl-1 ? ";" : "");
      }
    }
  },


  getWsId : function() {
    console.log("get wsid");
    return this._wsid;
  },

  getWaterschap : function() {
    console.log("get waterschap");
    return this._waterschap;
  },
  
  /*
   * Bepaal met de geoprocessing tool GPWatertoets.bepaalWaterschap de intersected areas van waterschappen
   * waarin het plangebied is getekend. 
   */
  execute : function(graphic) {
    var planGebied = [];
    planGebied.push(graphic);

    var subscriber = dojo.subscribe("esri.Error", function(error) {
      hideProgressBar();
      alert("Er is een fout opgetreden bij het bepalen van de waterschap.");
      dojo.unsubscribe(subscriber);
    });
  
    var featureSet = new esri.tasks.FeatureSet();
    featureSet.features = planGebied;
    var params = { "Feature_Set" : featureSet};
    this._queryTask.execute(params, dojo.hitch(this,this.bepaalGrootsteWS),this.onError);
  },
  
  /*
   * Bepaal de grootste area 
   */
  bepaalGrootsteWS :  function(results,messages) {
    var features = results[0].value.features;
    var fl = features.length;
    
    console.log("Aantal gp features " + fl + " - "+ messages.length);
    
    function findId(id,list) {
      for(var la=0;la < list.length; la++) {
        if(id === list[la]) return true;
      }
      return false;
    }

    var maxArea = 0;
    var wsid = -1;
    var wsids = [];
    var waterschap = null;
    for (var i = 0 ; i < fl; i++) {
      var feature = features[i];
      var area = feature.attributes['F_AREA'];
      var currwsid = feature.attributes[WS_FIELDS._WSID];
      
      if(area > maxArea) {
        maxArea = area;
        wsid = currwsid;
        waterschap = feature.attributes;//{WSID : feature.attributes[WS_FIELDS._WSID], WSNAAM : feature.attributes[WS_FIELDS._WSNAAM], WSDEELNEMER : feature.attributes[WS_FIELDS._WSDEELNEMERSHP]};
      }
      if (!findId(currwsid,wsids)) {
        wsids.push(currwsid);
      }

      console.log("feature " + feature.attributes[WS_FIELDS._WSID] + ' - '+ feature.attributes['F_AREA']);
    }
    
    console.log('Gevonden waterschap: ' + wsid);
    this.setWsID(wsid,waterschap,wsids);

    // Als plangebied in meer dan 1 waterschap ligt dan signaal naar andere waterschappen.
    console.log('Aantal waterschappen: ' + wsids.length);
    
    dojo.publish(LARGEST_INTERSECTED_WATERBOARD);
  },
  
  onError : function(error) {
    console.debug("Fout bij het bepalen van waterschap: " + error);
    dojo.publish(ERROR_INTERSECTED_WATERBOARD);
  }

});

//************************************************************************************************************
// Bepaal in welke gemeente het grootste deel van het plangebied valt
dojo.declare("BepaalGemeente",SearchLayer, {
  /* Handle variabelen voor events */
  _exeConnect: null,
  _cmid : -1,
  _gemeente : null,

  constructor : function(map,serviceUrl) {
    this._name = "BepaalGemeente";
    this._map = map;

    this._queryTask = new esri.tasks.Geoprocessor(serviceUrl);
  },

  /*
   * Set de gemeentenaam.
   */
  setGemeente : function(gemeente) {
    this._gemeente = gemeente;

    // Set global currentGemeenteNaam
    // watertoets_tekenplan.js
    // TODO: refactoren
    currentGemeenteNaam = gemeente;
    console.log("Gemeentenaam: " + currentGemeenteNaam);
    setGemeenteNaam();
  },

  /*
   * Getter gemeentenaam
   */
  getGemeente : function() {
    console.log("get gemeente");
    return this._gemeente;
  },

  /*
   * Bepaal met de geoprocessing tool GPWatertoets.bepaalGemeente de intersected areas van gemeentes
   * waarin het plangebied is getekend. 
   */
  execute : function(graphic) {
    var planGebied = [];
    planGebied.push(graphic);
    
    console.log("Uitvoeren geoprocessing task bepaalGemeente");

    var featureSet = new esri.tasks.FeatureSet();
    featureSet.features = planGebied;
    var params = { "Feature_Set" : featureSet};
    this._queryTask.execute(params, dojo.hitch(this,this.bepaalGrootsteCM),dojo.hitch(this,this.onError));
  },
  
  /*
   * Bepaal van de intersected areas de grootste
   */
  bepaalGrootsteCM :  function(results,messages) {
    var features = results[0].value.features;
    var fl = features.length;
    
    console.log("Aantal gp features bepaalGemeente " + fl + " - "+ messages.length);
    
    function findGemeente(id,list) {
      for(var la=0;la < list.length; la++) {
        if(id === list[la]) return true;
      }
      return false;
    }

    var maxArea = 0;
    var gemeentes = [];
    var gemeente = null;
    for (var i = 0 ; i < fl; i++) {
      var feature = features[i];
      var area = feature.attributes['F_AREA'];
      
      if(area > maxArea) {
        maxArea = area;
        gemeente = feature.attributes[CM_FIELDS._CMNAAM];
        if (!findGemeente(gemeente,gemeentes)) {
          gemeentes.push(gemeente);
        }
      }
      console.log("feature " + feature.attributes[CM_FIELDS._CMNAAM] + ' - '+ feature.attributes['F_AREA']);
    }
    
    console.log('Gevonden gemeente: ' + gemeente);
    this.setGemeente(gemeente);
    
    this.logMessages(messages);
    
    // Publiceer 
    dojo.publish(LARGEST_INTERSECTED_COMMUNITY);
  },
  
  onError : function(error) {
    console.debug("Fout bij het bepalen van Gemeente: " + error);
    dojo.publish(ERROR_INTERSECTED_COMMUNITY);
  },
  
  logMessages : function (messages) {
    for(var i = 0; i < messages.length ; i++) {
      console.log(messages[i].type + ' - ' +  messages[i].description);
    }
  }
  
  
});


/*
  Class: SearchCommunity
  Zoeken op gemeentelaag. 
*/
dojo.declare("SearchCommunity",SearchLayer, {
  /* Handle variabelen voor events */
  _onClickHandle: null,
  _onMouseOut: null,
  _onMouseOver: null,

  _exeConnect: null,
  _onExtentChangeHandle: null,
  
  constructor : function(map,layerUrl) {
		this._name = "SearchCommunity";
    this._map = map;
    this._queryTask = new esri.tasks.QueryTask(layerUrl);

    // Welke attributen moeten opgehaald worden?
    this._outFields = [ CM_FIELDS._CMOID, CM_FIELDS._CMNAAM];
    this._infoWindow = new esri.InfoTemplate();
    this._infoWindow.setTitle("Gemeente info");
    this._infoWindow.setContent("Gemeente: ${"+ CM_FIELDS._CMNAAM + "}");

    // Set up query waterschap. Haal alle gemeentes binnen de waterschap op.
    this._query = new esri.tasks.Query();
    this._query.outFields = this._outFields;
    this._query.returnGeometry = true;
    this._query.where = CM_FIELDS._CMOID + ' > 0';
    this._query.spatialRelationship = esri.tasks.Query.SPATIAL_REL_INTERSECTS;
    
    // Highlight symbol;
    var outLineColor = new dojo.Color([0,255,0]);
    var outLineWidth = 3;
    var fillColor = new dojo.Color([125,125,125,0.5]);
    var outline = new esri.symbol.SimpleLineSymbol(esri.symbol.SimpleLineSymbol.STYLE_SOLID, outLineColor, outLineWidth);
    this._highlightSymbol = new esri.symbol.SimpleFillSymbol(esri.symbol.SimpleFillSymbol.STYLE_SOLID, outline, fillColor);

  },
  
  execute : function()  {
    disableEventHandlers();
    console.log("Watertoets: queryTaskZoekGemeente.execute");
    if((this._query.where === null || this._query.where === "") && this._query.geometry === null) {
      console.log("Watertoets::SearchCommunity: geen whereClause en geometry geset.");
      return;
    }
    if(this._exeConnect) dojo.disconnect(this._exeConnect);
    // Voer query uit.
    this._queryTask.execute(this._query);
    this.completeTask();
  },

  disableEventHandlers : function() {
    console.log("disableEventHandlers " + this._name);
    this.disableHandle(this._onExtentChangeHandle);

    this.inherited(arguments);
  },


  mouseClickHandler : function(evt) {
    console.log("Watertoets: onclick " + this._name);
    this._onExtentChangeHandle = 
      dojo.connect(AquaWT.map, "onExtentChange", this, 
        function() {
          console.log("Watertoets: onclick cleargraphics" + this._name);
          disableEventHandlers();
          this.clearGraphics();
        }
      );

    this.searchClicked(evt.graphic.geometry);
  },

  searchClicked : function(geometry) {
    this._map.setExtent(geometry.getExtent(),true);
  },
	
  listResults : function(results) {
    console.log("Watertoets: queryTaskZoekGemeente.listResults");
    this._featureSet = results;

    var selectElement = dijit.byId("searchCmValues");
    var options = new dojo.data.ItemFileWriteStore({data: {identifier: CM_FIELDS._CMOID , items:[]}});

    var sortedResultList = this.sortList(results, CM_FIELDS._CMNAAM );
    for (var i=0; i<sortedResultList.length; i++) {
      var featureAttributes = results.features[sortedResultList[i]['nr']].attributes;
      options.newItem({OBJECTID: featureAttributes[CM_FIELDS._CMOID], name: featureAttributes[CM_FIELDS._CMNAAM]});
    }
        
    selectElement.store = options;
    this.showGraphics();

		// Maak textbox leeg
		selectElement.textbox.value = "";
  },



  resetListResults : function() {
    console.log("Watertoets: queryTaskZoekGemeente.resetListResults");

    var selectElement = dijit.byId("searchCmValues");
    var options = new dojo.data.ItemFileWriteStore({data: {identifier: CM_FIELDS._CMOID, items:[]}});
    options.newItem({OBJECTID: -1, name: 'Selecteer gemeente'});
        
    selectElement.store = options;

    // Maak textbox leeg
    selectElement.textbox.value = "";
    selectElement.setValue(-1);
  }

});

//*************************************************************************************************************
// Zoekfunctie doe gebruikt maakt van de kadaster service
//
dojo.declare("SearchGeocode",null, {
  _zoekString : null,
  
  constructor : function(zoekString) {
    AquaWT.map.graphics.clear();
    this._zoekString = zoekString;
  },
  
  /*
   * Zoek het adres met behulp van de kadaster service 
   */
  searchCoords : function() {
    dojo.xhrPost({
       url: kadasterUrl,
       content: this._zoekString,
       load: dojo.hitch(this,this.onGeocodeSucces),
       error: this.onGeocodeError
    });
   },


  onGeocodeSucces : function(data) {
    console.debug(data);
    var results = data.split('|');

    // Geef een foutmelding wanneer coords[3] gevuld is.
    if (results[3] !== "") {
      alert(results[3]);
      activateDiv('searchDiv');
      return;
    }

    // Wanneer coords[2] True is moeten de coordinaten geprojecteerd worden.
    if(results[2] === "True") {
      this.googleResultsSucces(results[4]);  
    }
    else {
      this.kadasterResultsSucces(results);  
    }
  },

  /*
   * Afhandeling van de response van de geocodeer functie.
   */   
  googleResultsSucces : function(data) {
    console.debug(data);

    var jsonResults = dojo.fromJson(data);

    if(jsonResults.Placemark.length == 0) {
      alert('Er zijn geen resultaten!');
      activateDiv('searchDiv');
      return;
    }

    if (jsonResults.Placemark.length == 1) {
      var coords = jsonResults.Placemark[0].Point.coordinates;
      this.zoomToProjectedCoords(coords,true);
      return;
    }
    
    if(jsonResults.Placemark.length > 1 && jsonResults.Placemark.length < 5) {
      this.showResults(jsonResults.Placemark);
      activateDiv('searchResultsDiv');
      return;
    }
    else {
      alert('Er zijn teveel resultaten. Wees specifieker (lees de aanwijzingen).');
      activateDiv('searchDiv');
      return;
    } 
  },


  kadasterResultsSucces : function(data) {
    console.debug(data);

    var x = data[0] * 1.0;
    var y = data[1] * 1.0;
    var center = new esri.geometry.Point(x,y,AquaWT.map.spatialReference);
    this.zoomToArea(center);
  },

  // Wanneer de aanroep naar de kadaster servivce fout gaat
  onGeocodeError : function(data, error) {
    console.log(data);
    console.log(error);
    toggleMapOnly(false);
    activateDiv('searchDiv');
  },

  zoomToProjectedCoords : function(coords, zoom, g) {  
      var center = new esri.geometry.Point(coords[0],coords[1],new esri.SpatialReference({ wkid: 4803 }));

      var pointList = [];
      var graphic = new esri.Graphic();
      graphic.geometry = center;
      pointList.push(graphic);

      // Doe de herprojectie met de GeometryService
      var geometryServiceTask = new esri.tasks.GeometryService(geometryServiceUrl);
      geometryServiceTask.project(pointList, AquaWT.map.spatialReference,
        dojo.hitch(this, function(graphics) {
            console.debug("Aantal geprojecteerd punten: " + graphics.length);
            projectedCenter = graphics[0].geometry;
            
            if (zoom) 
              this.zoomToArea(projectedCenter);
          } 
        ));
   },
   
   zoomToJsonArea : function(json) {
     var center = dojo.fromJson(json);
     this.zoomToProjectedCoords(center,true);
     //this.zoomToArea(center);
     
   },
   
   /*
    * Zoom naar het gevonden adres
    */
  zoomToArea : function(projectedCenter) {
        console.log("Inzoomen op zoekgebied");
        console.debug("Projected "+ projectedCenter.x + "," + projectedCenter.y);
        
        var BORDER = 1000.0; // meter
        var extent = new esri.geometry.Extent();
        extent.xmin = projectedCenter.x - BORDER; 
        extent.ymin = projectedCenter.y - BORDER; 
        extent.xmax = projectedCenter.x + BORDER; 
        extent.ymax = projectedCenter.y + BORDER; 
        extent.setSpatialReference(AquaWT.map.spatialReference);
        
        zoomToGeometryInDeelnemendeWaterschap(extent,true);
    
        console.debug("Inzoomen klaar");
    },
    
    showResults : function(candidates) {
        var candidate;
        var attributes;
        var prjCoords;
        var symbol = new esri.symbol.SimpleMarkerSymbol();
        var infoTemplate = new esri.InfoTemplate("Lokatie", "Adres: ${address}<br />");

        symbol.setStyle(esri.symbol.SimpleMarkerSymbol.STYLE_DIAMOND);
        symbol.setColor(new dojo.Color([255,0,0,0.75]));

        var points =  new esri.geometry.Multipoint(AquaWT.map.spatialReference);

        var divje = dojo.byId('searchResultsList');
        divje.innerHTML = "";
        
        for (var i=0, il=candidates.length; i<il; i++) {
          candidate = candidates[i];
          attributes = { address: candidate.address };
          
          var spanner = document.createElement("a");
          //spanner.className = 'searchLink';
          //spanner.appendChild(document.createTextNode(attributes.address));
          spanner.innerHTML = attributes.address;

          (dojo.hitch(this, function(){
             var coords = dojo.toJson(candidate.Point.coordinates);
            
            dojo.connect(spanner, "onclick", this, function(evt){
                this.zoomToJsonArea(coords);
            });
          }))();
          
          divje.appendChild(spanner);
          divje.appendChild(document.createElement("BR"));
        }
    }
        
});

/*
 * onClick event van de kadaster zoek knop (opgenomen in searchDiv)
 */
function searchGeocode() {
  // Haal de values uit de text input elements

  var zoektekst = dojo.byId('txtSearch').value;
  if(zoektekst.length === 0) {
    alert('Vul een plaats, straat en huisnummer en/of postcode in!');
    activateDiv('searchDiv');
    return;
  }

  // Maak object voor de SearchGeocode 
  var content = {
    "zoeklokatie" : zoektekst,
    "plaatsnaam" : "",
    "straatnaam" : "",
    "postcode" : "",
    "huisnummer" : "",
    "huisnummertoevoeging" : "",
    "searchEngine" : "Google"
  }
  
  // Aanroep geocode functie
  var geocode = new SearchGeocode(content);
  geocode.searchCoords();
}

function searchPcGeocode() {
  var postcode = dojo.byId('txtPC').value;
  var huisnummer = dojo.byId('txtHnr').value;
  //var huisnummertoevoeging = dojo.byId('txtHnrAdd').value;

  // Controleer de input.
  // Postcode + huisnummer 
  if((postcode.length === 0 || huisnummer.length === 0))
  {
    alert('Vul postcode en huisnummer in.');
    activateDiv('searchDiv');
    return;
  }

  // Maak object voor de SearchGeocode 
  var content = {
    "zoeklokatie" : "",
    "plaatsnaam" : "",
    "straatnaam" : "",
    "postcode" : postcode,
    "huisnummer" : huisnummer,
    "huisnummertoevoeging" : "",
    "searchEngine" : "Kadaster"
  }
  
  // Aanroep geocode functie
  var geocode = new SearchGeocode(content);
  geocode.searchCoords();
}


//
// Einde kadaster zoek functionaliteit
//*******************************************************************************************************/

function disableEventHandlers() {
  if(AquaWT.searchWS) AquaWT.searchWS.disableEventHandlers();
  if(AquaWT.searchCM) AquaWT.searchCM.disableEventHandlers();
  if(AquaWT.searchPC) AquaWT.searchPC.disableEventHandlers();
}

function zoekWaterschappen() {
  msgBox.setMessage("Laden waterschappen");

  AquaWT.searchPC = new SearchZipCode(AquaWT.map, achtergrondLayerUrl + "/" + INDEX_ZP);
  AquaWT.searchCM = new SearchCommunity(AquaWT.map, achtergrondLayerUrl + "/" + INDEX_CM);
  
  AquaWT.searchWS = new SearchWatership(AquaWT.map, achtergrondLayerUrl + "/" + INDEX_WS);
  AquaWT.searchWS.execute();
  
}

function showWaterschappen() {
	disableEventHandlers();
  toggleMapOnly(true);
  if(AquaWT.searchWS) AquaWT.searchWS.showGraphics();
}

function zoekGemeente() {
  if (!AquaWT.searchCM) {
    AquaWT.searchCM = new SearchCommunity(AquaWT.map, achtergrondLayerUrl + "/" + INDEX_CM);
  }
  AquaWT.searchCM.execute();
}

function showGemeentes() {
	disableEventHandlers();
  toggleMapOnly(true);
  if(AquaWT.searchCM) AquaWT.searchCM.showGraphics();
}

function zoekPostcode() {
  if (!AquaWT.searchPC) {
    AquaWT.searchPC = new SearchZipCode(AquaWT.map, achtergrondLayerUrl + "/" + INDEX_ZP);
  }
  AquaWT.searchPC.execute();
}


function showPostcode() {
  //showToolBar();
  disableEventHandlers();
  if(AquaWT.searchPC) AquaWT.searchPC.showGraphics();
}


function clearSearch() {
  disableEventHandlers();
  AquaWT.map.graphics.clear();
  doAnimation(ANIM.SEARCH_OUT);
}

function zoekOpKaart(){
  toggleMapOnly(true);
  zoomAll();
}

/*
 * Zoek waterschap: onchange van de searchWSValues selectbox 
 */
function searchWatershipById(oid) {
  console.log("Watertoets: Zoek waterschap by id "+oid);
  if(oid === -1) return;
  //toggleMapOnly(true);
	AquaWT.map.graphics.clear();
  if(AquaWT.searchWS) AquaWT.searchWS.searchByField(WS_FIELDS._WSOID,oid);
}

function searchWatershipByGeometry(geometry) {
  console.log("Watertoets: Zoek waterschap op geometry");
  if (AquaWT.searchWS) {
    AquaWT.searchWS.setSearchGeometry(geometry);
    AquaWT.searchWS.execute();
  }
}

/*
 * Zoek gemeente: onchange van de searchCmValues selectbox 
 */
function searchCommunityById(oid) {
  console.log("Watertoets: Zoek gemeente " + oid);
  if(oid === -1) return;
  toggleMapOnly(true);
  AquaWT.map.graphics.clear();
  if(AquaWT.searchCM) AquaWT.searchCM.searchByField(CM_FIELDS._CMOID,oid);
}




/*
 * Zoek gemeente: onchange van de searchCmValues selectbox 
 */
function searchZipcodeById(oid) {
  console.log("Watertoets: Zoek postcode " + oid);
  toggleMapOnly(true);
  AquaWT.map.graphics.clear();
  if(AquaWT.searchPC) AquaWT.searchPC.searchByField(ZP_FIELDS._ZPOID,oid);
}

function searchZipcodeByName() {
  var name = dojo.byId('postcode').value;
  if (name.length != 4) {
    alert('Voer een geldige postcode in');
    return;
  }  

  console.log("Watertoets: Zoek postcode " + name);
  AquaWT.map.graphics.clear();
  if (AquaWT.searchPC) {
    AquaWT.searchPC.setSearchWhere(name);
    if(AquaWT.searchPC.execute()) {
        toggleMapOnly(true);
    } 
  }

}





function searchCommunityByGeometry(geometry) {
  console.log("Watertoets: Zoek gemeente");
  if (!AquaWT.searchCM) {
    AquaWT.searchCM = new SearchCommunity(AquaWT.map, achtergrondLayerUrl + "/" + INDEX_CM);
  }
	AquaWT.searchCM.setSearchGeometry(geometry);
	AquaWT.searchCM.execute();
		
	var el=dijit.byId("searchCmValues");
	el.attr('disabled',false);
}


function locateLKI() {
  alert("Nog niet geimplementeerd.");
}

function showHelp() {
  alert('Hier komt help');
}

//alert("Watertoets: watertoets_zoeken loaded");
console.log("Watertoets: watertoets_zoeken loaded");

/* EOF */