import nl.idgis.giclient.template.ParameterSource;
import nl.idgis.giclient.gis.GIS;
import nl.idgis.giclient.geoma.Point;
import nl.idgis.giclient.geoma.GMLFactory;
import nl.idgis.giclient.template.Parameter;
import nl.idgis.giclient.gis.CentreScale;
import nl.idgis.giclient.gis.SelectableLayer;
import nl.idgis.giclient.Ruler;
import nl.idgis.giclient.webserviceconnector.TransformConnector;
import nl.idgis.giclient.geoma.Geometry;
import nl.idgis.giclient.template.ViewerTransformListener;
import nl.idgis.giclient.gis.Layer;
import nl.idgis.giclient.gis.Feature;
import nl.idgis.giclient.webserviceconnector.wfsconnector.WFSConnector;
import nl.idgis.giclient.webserviceconnector.wfsconnector.FeatureType;
import nl.idgis.giclient.webserviceconnector.wfsconnector.Property;
import nl.idgis.giclient.filterencoding.ComplexFilter;
import nl.idgis.giclient.gis.Map;
import nl.idgis.giclient.gis.GILayer;
import nl.idgis.giclient.webserviceconnector.giconnector.GIConnector;

/**
 * @author copierrj
 */
class nl.idgis.giclient.template.Viewer implements ParameterSource {
	private var gis:GIS;
	
	public function Viewer(gis:GIS) {
		this.gis = gis;
	}
	
	private function getActiveSelectableLayers():Array {
		var activeLayer:Layer = gis.getActiveLayer();
		if(activeLayer != null) {
			return [activeLayer];
		} else {		
			var retval:Array = new Array();
			var layers:Array = gis.getZoomVisibleLayers();
			for(var i:Number = 0; i < layers.length; i++) {				
				if(Layer(layers[i]).isVisible() && layers[i] instanceof SelectableLayer) {
					retval.push(layers[i]);
				}
			}
			return retval;
		}
	}
	
	private function createLayerTree(doc:XML, layer:Layer) : XMLNode {
		var layerNode:XMLNode = doc.createElement("Layer");
		
		var nameNode:XMLNode = doc.createElement("Name");
		nameNode.appendChild(doc.createTextNode(layer.getName()));
		layerNode.appendChild(nameNode);
		
		var titleNode:XMLNode = doc.createElement("Title");
		var title:String = layer.getTitle();
		if(title == null) {
			title = "";
		}
		titleNode.appendChild(doc.createTextNode(title));
		layerNode.appendChild(titleNode);
		
		var visibleNode:XMLNode = doc.createElement("Visible");
		visibleNode.appendChild(doc.createTextNode("" + layer.isVisible()));
		layerNode.appendChild(visibleNode);
		
		var zoomVisibleNode:XMLNode = doc.createElement("ZoomVisible");
		zoomVisibleNode.appendChild(doc.createTextNode("" + gis.isZoomVisibleLayer(layer)));
		layerNode.appendChild(zoomVisibleNode);
		
		if(layer instanceof SelectableLayer) {
			var sLayer:SelectableLayer = SelectableLayer(layer);
			
			var connector:GIConnector = GIConnector(sLayer.getMapConnector());			
			
			var featureTypeName:String = 
				connector.getFeatureTypeName(layer.getName());
			var featureTypeNameNode:XMLNode = doc.createElement("FeatureTypeName");
			featureTypeNameNode.appendChild(doc.createTextNode(featureTypeName));
			layerNode.appendChild(featureTypeNameNode);
			
			var url:String = WFSConnector(sLayer.getWfsConnector()).getURL();
			var urlNode:XMLNode = doc.createElement("Url");
			urlNode.appendChild(doc.createTextNode(url));
			layerNode.appendChild(urlNode);
		}
		
		var layers:Array = layer.getLayers();
		if(layers.length > 0) {
			var layersNode:XMLNode = doc.createElement("Layers");		
			for(var i:Number = 0; i < layers.length; i++) {
				layersNode.appendChild(createLayerTree(doc, Layer(layers[i])));
			}
			layerNode.appendChild(layersNode);
		}
		return layerNode;
	}
	
	public function getValue(parameter:Parameter) {		
		var name = parameter.getSourceName();
		
		if(name == "namespace") {
			var namespaces:Object = new Object();
			var layers:Array = getActiveSelectableLayers();
			if(layers.length == 0) {
				parameter.setValue(null);
				return;
			} 
			for(var i:Number = 0; i < layers.length; i++) {
				var sLayer:SelectableLayer = SelectableLayer(layers[i]);
					
				var ft:FeatureType = sLayer.getFeatureType();
				namespaces[ft.getTargetNamespacePrefix()] = ft.getTargetNamespace();
			}
			var retval:String = "";
			for(var prefix:String in namespaces) {
				if(retval.length != 0) {
					retval += ",";
				}
				
				retval += prefix + "=" + namespaces[prefix];
			}
			retval = "xmlns(" + retval + ")";
			parameter.setValue(retval);
		} else if(name == "filters") {
			var layers:Array = getActiveSelectableLayers();
			if(layers.length == 0) {
				parameter.setValue(null);
				return;
			} 
			var filters:String = "<Filters>";
			for(var i:Number = 0; i < layers.length; i++) {
				var sLayer:SelectableLayer = SelectableLayer(layers[i]);
				var filter:ComplexFilter = sLayer.getCurrentFilter();
				if(filter == null) {
					filters += "<NoFilter/>";
				}
				else {
					filters += filter.toXML().toString();
				}
			}
			filters += "</Filters>";
			parameter.setValue(filters);
		} else if(name == "featureTypes") {
			var featureTypes:String = "";
			var layers:Array = getActiveSelectableLayers();
			if(layers.length == 0) {
				parameter.setValue(null);
				return;
			} 
			for(var i:Number = 0; i < layers.length; i++) {
				var sLayer:SelectableLayer = SelectableLayer(layers[i]);
				if(featureTypes.length != 0) {
					featureTypes += ",";
				}	
				featureTypes += sLayer.getFeatureTypeName();
			}
			parameter.setValue(featureTypes);
		} else if(name == "geometryProperties") {
			var geometryProperties:String = "";
			var layers:Array = getActiveSelectableLayers();
			if(layers.length == 0) {
				parameter.setValue(null);
				return;
			} 
			for(var i:Number = 0; i < layers.length; i++) {
				var sLayer:SelectableLayer = SelectableLayer(layers[i]);
				if(geometryProperties.length != 0) {
					geometryProperties += ",";
				}					
				geometryProperties += Property(sLayer.getFeatureType().getGeometryProperties()[0]).getName();
			}
			parameter.setValue(geometryProperties);
	    } else if(name == "wfsUrls") {
			var wfsUrls:String = "";
			var layers:Array = getActiveSelectableLayers();
			if(layers.length == 0) {
				parameter.setValue(null);
				return;
			} 
			for(var i:Number = 0; i < layers.length; i++) {
				var sLayer:SelectableLayer = SelectableLayer(layers[i]);
				if(wfsUrls.length != 0) {
					wfsUrls += ",";
				}					
				wfsUrls += WFSConnector(sLayer.getWfsConnector()).getURL();
			}
			parameter.setValue(wfsUrls);
	    } else if(name == "buffer") {
	    	parameter.setValue(gis.getBuffer());
		} else if(name == "bufferedSelectionGeometry") {
			parameter.setValue(GMLFactory.createGMLNode(gis.getBufferedSelectionGeometry()).toString());
		} else if(name == "specialGeometries") {
			var geometries:Array = new Array();
			
			var selectionGeom:Geometry = gis.getSelectionGeometry();
			if(selectionGeom != null) {
				geometries.push(selectionGeom);
			}
			
			var bufferedSelectionGeom:Geometry = gis.getBufferedSelectionGeometry();
			if(bufferedSelectionGeom != null) {
				geometries.push(bufferedSelectionGeom);
			} 
			
			var measureFeature:Feature = gis.getMeasureFeature();
			if(measureFeature != null) {
				geometries.push(measureFeature);
			}
			
			parameter.setValue(geometries); 
		} else if(name == "selectionGeometry") {			
			parameter.setValue(GMLFactory.createGMLNode(gis.getSelectionGeometry()).toString());
		} else if(name == "currentEditLayerFeatures") {
			var sLayer:SelectableLayer = gis.getEditLayer();
			parameter.setValue(sLayer.getFeatures());
		} else if(name == "currentScale") {
			parameter.setValue(gis.getCurrentScale()); 
		} else if(name == "currentCentre") {
			var srs:String = String(parameter.getValue("srs"));
			var centreScale:CentreScale = gis.getCurrentCentreScale();			
			var point:Point = new Point(centreScale.getSRS(), centreScale.getCentreX(), centreScale.getCentreY());
			if(centreScale.getSRS() == srs) {
				parameter.setValue(point);
			} else {
				var transformConnector:TransformConnector = gis.getTransformConnector();
				var listener:ViewerTransformListener = new ViewerTransformListener(parameter);
				transformConnector.transform(point, point.getSRS(), srs, listener);
			}
		} else if(name == "currentSrs") {
			parameter.setValue(gis.getCurrentSrs());
		} else if(name == "zoomVisibleLayers") {
			var scaleStr:String = String(parameter.getValue("scale"));
			if(Number(scaleStr) != Number.NaN) {				
				parameter.setValue(gis.getZoomVisibleLayersForScale(Number(scaleStr)));
			} else {
				parameter.setValue(null);
			}				
		} else if(name == "isLayerVisible") {
			var layer:Layer = Layer(parameter.getValue("layer"));
			if(layer.isVisible()) {
				var visible:Boolean = true;
				var superLayers:Array = layer.getSuperLayers();
				for(var i:Number = 0; i < superLayers.length; i++) {
					var currentSuperLayer:Layer = Layer(superLayers[i]);
					if(!currentSuperLayer.isVisible()) {
						visible = false;
						break;
					}
				}
				parameter.setValue(visible);
			}
			else {
				parameter.setValue(false);
			}
		} else if(name == "visibleLayers") {
			var scaleStr:String = String(parameter.getValue("scale"));
			if(Number(scaleStr) != Number.NaN) {				
				parameter.setValue(gis.getVisibleLayersForScale(Number(scaleStr)));
			} else {
				parameter.setValue(null);
			}				
		} else if(name == "selectedIds") {			
			var layer:Layer = Layer(parameter.getValue("layer"));
			if(layer instanceof SelectableLayer) {
				var sLayer:SelectableLayer = SelectableLayer(layer);
				var selectedFeatures:Array = sLayer.getSelectedFeatures();
				var idStr:String = "";
				for(var i:Number = 0; i < selectedFeatures.length; i++) {
					if(i != 0) {
						idStr += ",";
					}
					
					idStr += Feature(selectedFeatures[i]).getID();
				}
				parameter.setValue(idStr);
			} else {
				parameter.setValue(null);
			}
		} else if(name == "layerTree") {
			var layerTree:XML = new XML();						
			var layersNode:XMLNode = layerTree.createElement("Layers");
			
			var map:Map = gis.getActiveMap();
			var layers:Array = map.getLayers();
			for(var i:Number = 0; i < layers.length; i++) {
				layersNode.appendChild(createLayerTree(layerTree, Layer(layers[i])));
			}
						
			layerTree.appendChild(layersNode);	
			parameter.setValue(layerTree.toString());
		} else {
			parameter.setValue(null);
		}
	}	
}