package forms.queryAspect
{
	import core.AbstractModel;
	
	import flash.events.Event;
	
	import mx.collections.XMLListCollection;
	import mx.events.CollectionEvent;

	[Event(name="queryTypePropertyChange")]
	public class QueryAspectModel 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 _queryColumns:XMLListCollection;
		
		private var _actions:XML = 
			<Actions>
				<Action label="Zoom">ZoomByFilter</Action>
				<Action label="Filter and zoom">FilterAndZoom</Action>
				<Action label="Select and zoom">SelectAndZoom</Action>
				<Action label="Select">SelectFeaturesByFilter</Action>
				<Action label="Filter">FilterFeatures</Action>
	      		<Action label="Clear selection">ClearSelection</Action>        
	      		<Action label="Clear filter">ClearFilter</Action>
			</Actions>;
		
		protected override function refresh(event:Event = null) : void {
			getServerLayers();
			getQueryColumns();
			
			super.refresh(event);
		}
		
		private function getServerLayers() : void {
			if(_dataSource && _node) {			
				var newServerLayers:XMLListCollection = _dataSource.serverInfo.getFeatureTypes(server, false, false);
				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 getQueryColumns() : void {
			if(_dataSource && _node) {			
				var newServerLayers:XMLListCollection = _dataSource.serverInfo.getFeatureTypeAttributes(server,
					serverLayer);
				if(newServerLayers != _serverLayers) {
					if(_queryColumns) {
						_queryColumns.removeEventListener(CollectionEvent.COLLECTION_CHANGE, refresh);
					}
					_queryColumns = newServerLayers;
					if(_queryColumns) {
						_queryColumns.addEventListener(CollectionEvent.COLLECTION_CHANGE, refresh);
					}
					
					dispatchEvent(new Event("queryColumnsChange"));
				}
			}
		} 
		
		public function get name() : String {
			return _node.Name;
		}
		
		[Bindable(event="namePropertyChange")]
		[Bindable(event="nodeChange")]
		public function set name(newName:String) : void {
			_node.Name = newName;
			
			dispatchEvent(new Event("namePropertyChange"));
		}

		[Bindable(event="titlesPropertyChange")]
		[Bindable(event="nodeChange")]		
		public function get titles() : Array {
			return getTitles(_node.Titles);
		}
		
		public function addToTitles(title:Object) : void {
			doAddToTitles(title, _node.Titles);
			
			dispatchEvent(new Event("titlesPropertyChange"));
		}
		
		[Bindable(event="nodeChange")]
		public function get owner() : String {
			return _node.Owner;
		}
		
		public function get scope() : String {
			return _node.Scope;
		}
		
		[Bindable(event="scopePropertyChange")]
		[Bindable(event="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 server() : XML {
			return getListItem(validServers.(@id == _node.Server.@id &&
				@clientId == _node.Server.@clientId));
		}
		
		[Bindable(event="serverPropertyChange")]
		[Bindable(event="nodeChange")]				
		public function set server(newServer:XML) : void {
			 _node.Server.@id = newServer.@id;
			 _node.Server.@clientId = newServer.@clientId;
			 getServerLayers();
			 
			 dispatchEvent(new Event("serverPropertyChange"));
		}
		
		[Bindable(event="dataSourceChange")]
		public function get validServers() : XMLList {
			return _dataSource.queryServers.source.copy();
		}
		
		[Bindable(event="serverLayersChange")]
		public function get validServerLayers() : XMLList {
			return _serverLayers.source.copy();
		}
		
		public function get serverLayer() : XML {
			var nspace:String = _node.Namespace;
			var layerName:String = _node.Layername;
			
			for each(var item:Object in validServerLayers) {
				var name:XMLList = item.child("Name");
					
				if(name.length() == 0) {
					name = item.child(new QName("http://www.opengis.net/wfs", "Name"));
				}
				
				var currentName:String;
				if(name.length() == 0) {
					currentName = item.toString();
				} else {
					currentName = name[0].toString();
				}
				
				var currentNspace:String = "";
				if(currentName.indexOf(":") != -1) {
					var splitted:Array = currentName.split(":");
					currentName = splitted[1];
					var ns:Object = item.namespace(splitted[0]);
					if(ns) {
						currentNspace = ns.toString();
					}
				}
				
				if(nspace == currentNspace && layerName == currentName) {
					return item as XML;
				}
			}
			
			return null;
		}
		
		[Bindable(event="serverLayerPropertyChange")]
		[Bindable(event="nodeChange")]
		public function set serverLayer(newServerLayer:XML) : void {
			if(newServerLayer) {
				var name:XMLList = newServerLayer.child("Name");
					
				if(name.length() == 0) {
					name = newServerLayer.child(new QName("http://www.opengis.net/wfs", "Name"));
				}
				
				var currentName:String;
				if(name.length() == 0) {
					currentName = newServerLayer.toString();
				} else {
					currentName = name[0].toString();
				}
				
				var currentNspace:String = "";
				if(currentName.indexOf(":") != -1) {
					var splitted:Array = currentName.split(":");
					currentName = splitted[1];
					var ns:Object = newServerLayer.namespace(splitted[0]);
					if(ns) {
						currentNspace = ns.toString();
					}
				}
				
				_node.Namespace = currentNspace;
				_node.Layername = currentName;
			} else {
				_node.Namespace = "";
				_node.Layername = "";
			}
			
			getQueryColumns();
			
			dispatchEvent(new Event("serverLayerPropertyChange"));
		}
		
		public function get queryType() : String {
			return _node.Querytype;	
		}
		
		[Bindable(event="queryTypePropertyChange")]
		[Bindable(event="nodeChange")]
		public function set queryType(newQueryType:String) : void {
			_node.Querytype = newQueryType;
			dispatchEvent(new Event("queryTypePropertyChange"));
		}
		
		[Bindable(event="serverPropertyChange")]
		[Bindable(event="nodeChange")]
		public function get validQueryTypes() : Array {
			var retval:Array = ["simple"];
			if(server.Service == "GI") {
				retval.push("advanced");
			}
			return retval;
		}
		
		public function get validActions() : XMLList {
			return _actions.Action.copy();
		}
		
		[Bindable(event="serverPropertyChange")]
		[Bindable(event="nodeChange")]
		public function get supportsAdvanced() : Boolean {
			if(server) {			
				return server.Service == "GI";
			} else {
				return false;
			}
		}
		
		[Bindable(event="actionsPropertyChange")]
		[Bindable(event="nodeChange")]
		public function get actions() : XMLList {
			return _node.Actions.Action.copy();
		}
		
		public function addToActions(item:XML) : void {
			if(_node.child("Actions").length() == 0) {
				_node.appendChild(<Actions/>);
			}
			
			_node.Actions[0].appendChild(<Action>{item.children().toString()}</Action>);
			
			dispatchEvent(new Event("actionsPropertyChange"));
		}
		
		public function removeFromActions(item:Object) : void {
			var allChildren:XMLList = _node.Actions.Action;
			allChildren = allChildren.(children() != item.children());
			_node.Actions[0].setChildren(allChildren);
			
			dispatchEvent(new Event("actionsPropertyChange"));
		}
		
		[Bindable(event="queryColumnsPropertyChange")]
		[Bindable(event="nodeChange")]
		public function get queryColumns() : XMLList {
			var all:XMLList = allQueryColumns;
			
			if(_node) {
				var retval:XMLList = new XMLList();
				
				for each(var item:XML in _node.FeatureTypeProperties.FeatureTypeProperty) {
					var ftqueryfield:String = item.Ftqueryfield;
					if(ftqueryfield.indexOf(":") != -1) {
						ftqueryfield = ftqueryfield.split(":")[1];
					}
					
					retval += all.(@name == ftqueryfield);
				}
							
				return retval;
			} else {
				return null;
			}
		}
		
		[Bindable(event="queryColumnsChange")]
		private function get allQueryColumns() : XMLList {
			return _queryColumns.source.copy();
		}
		
		[Bindable(event="queryColumnsChange")]
		[Bindable(event="queryColumnsPropertyChange")]
		[Bindable(event="nodeChange")]
		public function get validQueryColumns() : XMLList {
			var all:XMLList = allQueryColumns;
			
			for each(var item:XML in queryColumns) {
				all = all.(valueOf() != item);
			}
			return all;
		}
		
		private function get serverLayerName() : String {
			var name:XMLList = serverLayer.child("Name");
				
			if(name.length() == 0) {
				name = serverLayer.child(new QName("http://www.opengis.net/wfs", "Name"));
			}
			
			var currentName:String;
			if(name.length() == 0) {
				currentName = serverLayer.toString();
			} else {
				currentName = name[0].toString();
			}
			
			return currentName;
		}
		
		private function getFtqueryfield(item:XML) : String {
			var ftqueryfield:String = item.@name;
			
			var ftName:String = serverLayerName;
			if(ftName.indexOf(":") != -1) {
				ftqueryfield = ftName.split(":")[0] + ":" + ftqueryfield;
			}
			
			return ftqueryfield;
		}
		
		public function removeFromQueryColumns(item:XML) : void {
			var ftqueryfield:String = getFtqueryfield(item);
			
			var list:XMLList = _node.FeatureTypeProperties.FeatureTypeProperty.(Ftqueryfield != ftqueryfield);
			_node.FeatureTypeProperties[0].setChildren(list);
		
			dispatchEvent(new Event("queryColumnsPropertyChange"));
		}
		
		public function addToQueryColumns(item:XML) : void {
			_node.FeatureTypeProperties[0].appendChild(
				<FeatureTypeProperty>
					<Ftqueryfield>{getFtqueryfield(item)}</Ftqueryfield>
					<OperandValueFT>{serverLayerName}</OperandValueFT>
					<OperandValueField>{getFtqueryfield(item)}</OperandValueField>
					<OperandLabelField>{getFtqueryfield(item)}</OperandLabelField>
					<SearchType>ComboBox</SearchType>
				</FeatureTypeProperty>);
			
			dispatchEvent(new Event("queryColumnsPropertyChange"));
		}
		
		[Bindable(event="nodeChange")]
		[Bindable(event="queryColumnsPropertyChange")]
		public function getQueryColumn(item:XML) : XML {
			return getListItem(_node.FeatureTypeProperties
				.FeatureTypeProperty.(Ftqueryfield == getFtqueryfield(item)));
		}
		
		public function get description() : String {
			return _node.Description;
		}
		
		[Bindable(event="descriptionPropertyChange")]
		[Bindable(event="nodeChange")]
		public function set description(newDescription:String) : void {
			_node.Description = newDescription;
		}
	}
}