package forms.layer
{
	import core.AbstractModel;
	
	import data.DataSource;
	
	import flash.events.Event;
	
	import mx.collections.XMLListCollection;
	import mx.events.CollectionEvent;
	
	public class LayerModel extends AbstractModel
	{	
		namespace wfs = "http://www.opengis.net/wfs";
		namespace xsd = "http://www.w3.org/2001/XMLSchema";
		use namespace wfs;
		use namespace xsd;
		
		
		private var _serverLayers:XMLListCollection;
		private var _featureTypes:XMLListCollection;
		private var _featureTypeProperties:XMLListCollection;
		
		protected override function refresh(event:Event = null) : void {
			getServerLayers();
			getFeatureTypes();
			getFeatureTypeProperties();			
			
			super.refresh(event);
		}
		
		private function getServerLayers() : void {
			if(_dataSource && _node) {			
				var newServerLayers:XMLListCollection = _dataSource.serverInfo.getServerLayers(server);
				if(newServerLayers != _serverLayers) {
					if(_serverLayers) {
						_serverLayers.removeEventListener(CollectionEvent.COLLECTION_CHANGE, refresh);
					}
					_serverLayers = newServerLayers;
					if(_serverLayers) {
						_serverLayers.addEventListener(CollectionEvent.COLLECTION_CHANGE, refresh);
					}
					
					dispatchEvent(new Event("serverLayersChange"));
				}
			}
		} 
		
		private function getFeatureTypes() : void {
			if(_dataSource && _node) {			
				var newFeatureTypes:XMLListCollection = _dataSource.serverInfo.getFeatureTypes(featureServer,
					false, false);
				if(newFeatureTypes != _featureTypes) {
					if(_featureTypes) {
						_featureTypes.removeEventListener(CollectionEvent.COLLECTION_CHANGE, refresh);
					}
					_featureTypes = newFeatureTypes;
					if(_featureTypes) {
						_featureTypes.addEventListener(CollectionEvent.COLLECTION_CHANGE, refresh);
					}
					
					dispatchEvent(new Event("featureTypesChange"));
				}
			}
		} 
		
		private function getFeatureTypeProperties() : void {
			if(_dataSource && _node) {			
				var newFeatureTypeProperties:XMLListCollection = _dataSource.serverInfo.getFeatureTypeAttributes(
					featureServer, featureType);
				if(newFeatureTypeProperties != _featureTypeProperties) {
					if(_featureTypeProperties) {
						_featureTypeProperties.removeEventListener(CollectionEvent.COLLECTION_CHANGE, refresh);
					}
					_featureTypeProperties = newFeatureTypeProperties;
					if(_featureTypeProperties) {
						_featureTypeProperties.addEventListener(CollectionEvent.COLLECTION_CHANGE, refresh);
					}
					
					dispatchEvent(new Event("featureTypePropertiesChange"));
				}
			}
		}
		
		[Bindable(event="dataSourceChange")]
		public override function set dataSource(newDataSource:DataSource) : void {
			if(newDataSource != _dataSource) {
				if(_dataSource) {
					_dataSource.mapServers.removeEventListener(CollectionEvent.COLLECTION_CHANGE, refresh);
				}
				super.dataSource = newDataSource;
				
				if(_dataSource) {
					_dataSource.mapServers.addEventListener(CollectionEvent.COLLECTION_CHANGE, refresh);
				}
				refresh()
			}
		}
				
		public function get name() : String {
			return _node.Name;
		}
		
		[Bindable(name="namePropertyChange")]
		[Bindable(name="nodeChange")]
		public function set name(newName:String) : void {
			_node.Name = newName;
			
			dispatchEvent(new Event("namePropertyChange"));
		}
		
		[Bindable(name="serverPropertyChange")]
		[Bindable(name="nodeChange")]
		public function set server(newServer:XML) : void {
			_node.Server.@id = newServer.@id;
			_node.Server.@clientId = newServer.@clientId;
			getServerLayers();
			
			dispatchEvent(new Event("serverPropertyChange"));
		}
		
		public function get server() : XML {
			return getListItem(validServers.(@id == _node.Server.@id &&
				@clientId == _node.Server.@clientId));
		}
		
		[Bindable(name="dataSourceChange")]
		public function get validServers() : XMLList {
			return _dataSource.mapServers.source.copy();
		}
		
		public function get serverLayer() : XML {
			return getListItem(validServerLayers.
				(Name.children() == _node.Serverlayername.children()));
		}
		
		[Bindable(name="serverLayerPropertyChange")]
		[Bindable(name="nodeChange")]		
		public function set serverLayer(newServerLayer:XML) : void {
			_node.Serverlayername = newServerLayer.Name.toString();
			
			dispatchEvent(new Event("serverLayerPropertyChange"));
		}
		
		[Bindable(name="serverLayersChange")]
		public function get validServerLayers() : XMLList {
			return _serverLayers.source.copy();
		}
		
		public function get selectable() : Boolean {
			return _node.Selectable == "true";
		}
		
		[Bindable(name="selectablePropertyChange")]
		[Bindable(name="nodeChange")]
		public function set selectable(newSelectable:Boolean) : void {
			_node.Selectable = newSelectable ? "true" : "false";
			
			dispatchEvent(new Event("selectablePropertyChange"));
		}
		
		public function get editable() : Boolean {
			return _node.Editable == "true";
		}
		
		[Bindable(name="editablePropertyChange")]
		[Bindable(name="nodeChange")]		
		public function set editable(newEditable:Boolean) : void {
			_node.Editable = newEditable ? "true" : "false";
			
			dispatchEvent(new Event("editablePropertyChange"));
		}
		
		[Bindable(name="featureTypePropertiesChange")]
		[Bindable(name="nodeChange")]
		public function get hasConfiguredFeatureTypeProperties() : Boolean {
			return _node.FTproperties.FTproperty.length() > 0;
		}
		
		[Bindable(name="featureTypePropertiesChange")]
		[Bindable(name="nodeChange")]
		public function get configuredFeatureTypeProperties() : XMLList {
			var list:XMLList = new XMLList();
			list += <element name=""/>;
			if(featureTypeProperties) {
				list += featureTypeProperties;
			} 
			return list;
		}
		
		[Bindable(name="featureTypePropertiesChange")]
		[Bindable(name="nodeChange")]
		public function get featureTypeProperties() : XMLList {
			var allProperties:XMLList = validFeatureTypeProperties;
			var list:XMLList = new XMLList();
			
			for each(var item:XML in _node.FTproperties.FTproperty) {
				var name:String = item.Name;
				if(name.indexOf(":") != -1) {
					name = name.split(":")[1];
				}
				list += allProperties.(@name == name); 
			}
			return list;	
		}
		
		public function addToFeatureTypeProperties(newFeatureTypeProperty:XML) : void {
			if(_node.child("FTproperties").length() == 0) {
				_node.appendChild("FTproperties");
			}
			
			var prefix:String = "";
			if(_node.FeatureTypeName.toString().indexOf(":") != -1) {
				prefix = _node.FeatureTypeName.toString().split(":")[0] + ":";
			}
			
			XML(_node.FTproperties[0]).appendChild(
				<FTproperty>
					<Name>{prefix}{newFeatureTypeProperty.@name}</Name>
					<Titles>
						<Title>
							<Language>en</Language>
						</Title>
						<Title>
							<Language>nl</Language>
						</Title>
						<Title>
							<Language>de</Language>
						</Title>
					</Titles>
				</FTproperty>);
			
			dispatchEvent(new Event("featureTypePropertiesChange"));
		}
		
		private function getFTName(str:String) : String {
			if(str.indexOf(":") != -1) {
				return str.split(":")[1];
			}
			
			return str;
		}
		
		public function removeFromFeatureTypeProperties(removeFeatureTypeProperty:XML) : void {
			var list:XMLList = _node.FTproperties.FTproperty;
			list = list.(getFTName(Name) != removeFeatureTypeProperty.@name);
			_node.FTproperties.setChildren(list);
			
			dispatchEvent(new Event("featureTypePropertiesChange"));
		}
		
		[Bindable(name="dataSourceChange")]
		public function get featureServer() : XML {
			if(_node.child("Featureserver").length() == 0) {
				return null;
			}
			
			var server:XML = <Server id={_node.Featureserver.@id} clientId="false"/>;		
			if(_node.Featureserver[0].attribute("clientId").length() > 0) {
				server.@clientId = _node.Featureserver.@clientId;
			}
			
			return _dataSource.getProps(server);
		}
		
		[Bindable(name="featureServerPropertyChange")]
		[Bindable(name="nodeChange")]
		public function set featureServer(newFeatureServer:XML) : void {
			_node.Featureserver.@id = newFeatureServer.@id;
			_node.Featureserver.@clientId = newFeatureServer.@clientId;
			getFeatureTypes();
			
			dispatchEvent(new Event("featureServerPropertyChange"));
		}
		
		[Bindable(name="dataSourceChange")]
		public function get validFeatureServers() : XMLList {
			return _dataSource.featureServers.source.copy();
		}
		
		public function get featureType() : XML {
			return getListItem(validFeatureTypes.
				(Name.children() == _node.FeatureTypeName.children()));
		}
		
		[Bindable(name="featureTypePropertyChange")]
		[Bindable(name="nodeChange")]
		public function set featureType(newFeatureType:XML) : void {
			_node.FeatureTypeName = newFeatureType.Name;
			getFeatureTypeProperties();
			
			dispatchEvent(new Event("featureTypePropertyChange"));
		}
		
		[Bindable(name="featureTypesChange")]
		public function get validFeatureTypes() : XMLList {
			return _featureTypes.source.copy();
		}
		
		[Bindable(name="featureTypePropertiesChange")]
		public function get validFeatureTypeProperties() : XMLList {
			if(_featureTypeProperties) {		
				return _featureTypeProperties.source.copy();
			} else {
				return new XMLList();
			}
		}
		
		[Bindable(name="featureTypePropertiesChange")]
		public function get validNewFeatureTypeProperties() : XMLList {
			var list:XMLList = validFeatureTypeProperties;
			
			for each(var item:XML in _node.FTproperties.FTproperty) {
				var name:String = item.Name;
				if(name.indexOf(":") != -1) {
					name = name.split(":")[1];
				}
				
				list = list.(@name != name); 
			}
			
			return list;	
		}
		
		public function getFeatureTypeProperty(property:XML) : XML {
			if(!property) {
				return null;
			}
		
			for each(var item:XML in _node.FTproperties.FTproperty) {
				var name:String = item.Name;
				if(name.indexOf(":") != -1) {
					name = name.split(":")[1];
				}
				
				if(property.@name == name) {
					return item;
				}
			}
			
			return null;
		}
		
		[Bindable(name="nodeChange")]
		public function get owner() : String {
			return _node.Owner;
		}
		
		public function get scope() : String {
			return _node.Scope;
		}
		
		[Bindable(name="scopePropertyChange")]
		[Bindable(name="nodeChange")]
		public function set scope(newScope:String) : void {
			_node.Scope = newScope;
			
			dispatchEvent(new Event("scopePropertyChange"));
		}
		
		public function get validScopes() : Array {
			return ['public', 'private'];
		}
		
		public function get minScale() : String {
			return _node.MinScaleDenominator;
		} 
		
		[Bindable(name="minScalePropertyChange")]
		[Bindable(name="nodeChange")]
		public function set minScale(newMinScale:String) : void {
			_node.MinScaleDenominator = newMinScale;
			
			dispatchEvent(new Event("minScalePropertyChange"));
		} 
		
		public function get maxScale() : String {
			return _node.MaxScaleDenominator;
		} 
		
		[Bindable(name="maxScalePropertyChange")]
		[Bindable(name="nodeChange")]
		public function set maxScale(newMaxScale:String) : void {
			_node.MaxScaleDenominator = newMaxScale;
			
			dispatchEvent(new Event("maxScalePropertyChange"));
		}
		
		public function get geometryType() : String {
			return _node.GeometryType;
		}
		
		[Bindable(name="geometryTypePropertyChange")]
		[Bindable(name="nodeChange")]
		public function set geometryType(newGeometryType:String) : void {
			_node.GeometryType = newGeometryType;
			
			dispatchEvent(new Event("geometryTypePropertyChange"));
		}
		
		public function get validGeometryTypes() : Array {
			return ['', 'Point', 'Line', 'Polygon'];
		}
		
		public function get initialVisible() : Boolean {
			return _node.InitVisible == "true";
		}
		
		[Bindable(name="initialVisiblePropertyChange")]
		[Bindable(name="nodeChange")]
		public function set initialVisible(newInitialVisible:Boolean) : void {
			_node.InitVisible = newInitialVisible ? "true" : "false";
			
			dispatchEvent(new Event("initialVisiblePropertyChange"));
		}
		
		public function get initialExpanded() : Boolean {
			return _node.InitExpanded == "true";
		}
		
		[Bindable(name="initialExpandedPropertyChange")]
		[Bindable(name="nodeChange")]
		public function set initialExpanded(newInitialExpanded:Boolean) : void {
			_node.InitExpanded = newInitialExpanded ? "true" : "false";
			
			dispatchEvent(new Event("initialExpandedPropertyChange"));
		}
		
		public function get shownInLegend() : Boolean {
			return _node.NoLegendLayer != "true";
		}
		
		[Bindable(name="shownInLegendPropertyChange")]
		[Bindable(name="nodeChange")]
		public function set shownInLegend(newShownInLegend:Boolean) : void {
			_node.NoLegendLayer = newShownInLegend ? "false" : "true";
			
			dispatchEvent(new Event("shownInLegendPropertyChange"));
		}
		
		private function getProperty(node:XMLList) : XML {
			var name:String = node;
			if(name.indexOf(":") != -1) {
				name = name.split(":")[1];
			}
			
			return getListItem(configuredFeatureTypeProperties.(@name == name));
		}
		
		private function setProperty(node:XMLList, newProperty:XML) : void {
			if(!newProperty || newProperty.@name == "") {
				node[0].setChildren("");
			} else {
				var prefix:String = "";
				if(featureType.Name.toString().indexOf(":") != -1) {
					prefix = featureType.Name.toString().split(":")[0] + ":";
				}
				
				node[0].setChildren(prefix + newProperty.@name);
			}
		}
		
		public function get hyperlinkProperty() : XML {
			return getProperty(_node.HyperlinkProperty);
		}
		
		[Bindable(name="hyperlinkPropertyChange")]
		[Bindable(name="nodeChange")]
		public function set hyperlinkProperty(newHyperlinkProperty:XML) : void {
			setProperty(_node.HyperlinkProperty, newHyperlinkProperty);
			
			dispatchEvent(new Event("hyperlinkPropertyChange"));
		}
		
		public function get annotationProperty() : XML {
			return getProperty(_node.AnnotationProperty);
		}
		
		[Bindable(name="annotationPropertyChange")]
		[Bindable(name="nodeChange")]
		public function set annotationProperty(newAnnotationProperty:XML) : void {
			setProperty(_node.AnnotationProperty, newAnnotationProperty);
			
			dispatchEvent(new Event("annotationPropertyChange"));
		}
		
		public function get objectOwnerProperty() : XML {
			return getProperty(_node.ObjectOwnerProperty);
		}
		
		[Bindable(name="objectOwnerPropertyChange")]
		[Bindable(name="nodeChange")]
		public function set objectOwnerProperty(newObjectOwnerProperty:XML) : void {
			setProperty(_node.ObjectOwnerProperty, newObjectOwnerProperty);
			
			dispatchEvent(new Event("objectOwnerPropertyChange"));
		}
		
		public function get ownerRoles():String {
			return _node.OwnerRoles;
		}
		
		[Bindable(name="ownerRolesPropertyChange")]
		[Bindable(name="nodeChange")]
		public function set ownerRoles(newOwnerRoles:String) : void {
			_node.OwnerRoles = newOwnerRoles;
			
			dispatchEvent(new Event("ownerRolesPropertyChange"));
		}
		
		[Bindable(name="titlesPropertyChange")]
		[Bindable(name="nodeChange")]
		public function get titles() : Array {
			return getTitles(_node.Titles);
		}
		
		public function addToTitles(title:Object) : void {
			doAddToTitles(title, _node.Titles);
			
			dispatchEvent(new Event("titlesPropertyChange"));
		}
		
		public function get description() : String {
			return _node.Description;
		}
		
		[Bindable(name="descriptionPropertyChange")]
		[Bindable(name="nodeChange")]
		public function set description(newDescription:String) : void {
			_node.Description = newDescription;
			
			dispatchEvent(new Event("descriptionPropertyChange"));
		}
		
		public function get popupInfoUrl() : String {
			return _node.PopUpInfoUrl;
		}
		
		[Bindable(name="popupInfoUrlPropertyChange")]
		[Bindable(name="nodeChange")]
		public function set popupInfoUrl(newPopupInfoUrl:String) : void {
			_node.PopUpInfoUrl = newPopupInfoUrl;
			
			dispatchEvent(new Event("popupInfoUrlPropertyChange"));
		}
		
		public function get popupTrigger() : String {
			return _node.PopUpInfoTrigger;
		}
		
		[Bindable(name="popupTriggerPropertyChange")]
		[Bindable(name="nodeChange")]
		public function set popupTrigger(newPopupTrigger:String) : void {
			_node.PopUpInfoTrigger = newPopupTrigger;
			
			dispatchEvent(new Event("popupTriggerPropertyChange"));
		}
		
		public function get validPopupTriggers() : Array {
			return ['', 'MouseHoover', 'MouseClick'];
		}
		
		public function get metaUrl() : String {
			return _node.MetaUrl;
		}
		
		[Bindable(name="metaUrlPropertyChange")]
		[Bindable(name="nodeChange")]
		public function set metaUrl(newMetaUrl:String) : void {
			_node.MetaUrl = newMetaUrl;
			
			dispatchEvent(new Event("metaUrlPropertyChange"));
		}
	}
}