package data
{
	import events.ConfigChangeEvent;
	import events.LoginEvent;
	
	import flash.display.DisplayObject;
	import flash.events.Event;
	import flash.events.EventDispatcher;
	import flash.events.IOErrorEvent;
	import flash.net.URLLoader;
	import flash.net.URLRequest;
	import flash.net.URLRequestHeader;
	import flash.net.URLRequestMethod;
	
	import mx.binding.utils.BindingUtils;
	import mx.collections.XMLListCollection;
	import mx.controls.Alert;
	import mx.core.Application;
	import mx.events.CollectionEvent;
	import mx.events.PropertyChangeEvent;
	import mx.managers.PopUpManager;
	import mx.resources.IResourceManager;
	import mx.resources.ResourceManager;
	import mx.rpc.events.FaultEvent;
	import mx.rpc.events.ResultEvent;
	import mx.rpc.http.HTTPService;
	
	import panels.ServerLoginPanel;
		
	[Event(name="ready")]
	[Event(name="serverCacheDropped")]
	public class DataSource extends EventDispatcher
	{
		[Bindable]
		public var contextTree:XMLListCollection = new XMLListCollection();
		
		[Bindable]
		public var serverTree:XMLListCollection = new XMLListCollection();		
		
		[Bindable]
	 	public var guiTree:XMLListCollection = new XMLListCollection();
	 
	 	[Bindable]
		public var defaultConfig:XML;
		
		[Bindable]
		public var properties:XML;
		
		[Bindable]
		public var resourceManager:IResourceManager = ResourceManager.getInstance();
		
		private var serverProps:XMLListCollection = new XMLListCollection();
		private var layerProps:XMLListCollection = new XMLListCollection();
		private var contextProps:XMLListCollection = new XMLListCollection();
		private var mapProps:XMLListCollection = new XMLListCollection();
		private var queryAspectProps:XMLListCollection = new XMLListCollection();
		private var templateProps:XMLListCollection = new XMLListCollection();
		private var reportProps:XMLListCollection = new XMLListCollection();
		private var guiConfigProps:XMLListCollection = new XMLListCollection();
		
		private var fullPropsLoading:Object = new Object();
				
		private var lastId:Number = 0;
		
		private var _serverUrl:String;	
		private var _proxyServerUrl:String;
		private var _login:String;	
		private var _defaultConfigUrl:String;		
		private var _propertiesUrl:String;	
		
		namespace wfs = "http://www.opengis.net/wfs";
		namespace xsd = "http://www.w3.org/2001/XMLSchema";
		use namespace wfs;
		use namespace xsd;
		
		private var entityNames:Array = ["Context", "Layer", "Map", "QueryAspect", 
			"Report", "Server", "Template"];
		
		private function reloadProxy():void
		{
			var proxyReload:URLLoader = new URLLoader();
			proxyReload.addEventListener(Event.COMPLETE, function():void {
				var resp:Object = XML(proxyReload.data).localName();	
				
			});
			
			proxyReload.load(new URLRequest(this._proxyServerUrl + "/?service=reload"));
		}
		
		public function logout(callback:Function):void {
			var logoutLoader:URLLoader = new URLLoader();
			logoutLoader.addEventListener(Event.COMPLETE, function():void
			{
				callback();
			});
			logoutLoader.load(new URLRequest(_serverUrl + "request=Logout"));			
		}
		
		private function createContextTree():XML {
			var contexts:XML = <Contexts/>;
			
			for(var i:int = 0; i < contextProps.length; i++) {
				var context:XML = XML(contextProps.getItemAt(i));
				var contextRef:XML = newRef(context);
				
				contexts.appendChild(contextRef);
			}
			
			return contexts;
		}
		
		private function updateStatusAttributes(list:XMLList):void {
			for each(var item:XML in list) {
				var props:XML = getProps(item);
				if(props.@status != item.@status) {
					item.@status = props.@status;
				}
			}
		}	
		
		private function updateContextTree():void {
			updateStatusAttributes(contextTree.source..Context);
			updateStatusAttributes(contextTree.source..Context);
			updateStatusAttributes(contextTree.source..Layer);
			updateStatusAttributes(contextTree.source..Map);
			updateStatusAttributes(contextTree.source..QueryAspect);
			updateStatusAttributes(contextTree.source..Report);
			updateStatusAttributes(contextTree.source..Template);
		}
		

		private function buildServerTree():void {
			var servers:XML = <Servers/>;
			for each(var server:XML in serverProps) {
				servers.appendChild(newRef(server));
			}
			serverTree.removeAll();
			serverTree.addItem(servers);
		}	
		
		private function buildContextTree():void {
			contextTree.removeAll();			
			contextTree.addItem(createContextTree());
		}
		
		private function buildGUIDataSource():void{
			var newConfigList:XMLList = new XMLList();
			for each(var config:XML in guiConfigProps) {
				newConfigList += refactorGuiConfig(config);
			}
			guiConfigProps.source = newConfigList;
			buildConfigTree();
		}
		
		public function buildConfigTree():void{
			var tree:XML = <Configs></Configs>;
			for each(var config:XML in guiConfigProps) {
				tree.appendChild(deleteConfigTagsToHide(config.copy()));
			}	
			var treeList:XMLList = XMLList(tree);
			guiTree.source = treeList;
			guiTree.source = treeList;
		}

		
		
		private function refactorGuiConfig(guiConfig:XML):XML{
			var newConfig:XML = new XML(defaultConfig); 
			newConfig.@name = guiConfig.@name;
			newConfig.Description = guiConfig.Description;
			var colorNodes:XMLList = newConfig.Colors.children();
			for(var i:Number=0;i<colorNodes.length();i++){
					var colorName:String = String(colorNodes[i].localName());
					if(guiConfig.Colors.child(colorName).length() > 0){
						colorNodes[i] = guiConfig.Colors.child(colorName)[0];
					}	
			}
			newConfig.ButtonBars = guiConfig.ButtonBars;
			var buttonsOnBars:XMLList = newConfig.ButtonBars.ButtonBar.Buttons.children();
			var buttonNodes:XMLList = newConfig.ActionButtons.children();
			buttonNodes += newConfig.PaneButtons.children();
			buttonNodes += newConfig.MapViewerButtons.children();
			for each(var buttonNode:XML in buttonNodes){
				buttonNode.@used="false";
				for each (var buttonOnBar:XML in buttonsOnBars){
					if(buttonOnBar.@name==buttonNode.Name){
						buttonOnBar.@datatip = buttonNode.ToolTipText.child(String(resourceManager.localeChain[0]).substr(0, 2))[0];
					}
				}
			}					
			
			var orgButtonNodes:XMLList = guiConfig.ActionButtons.children();
			orgButtonNodes += guiConfig.PaneButtons.children();
			orgButtonNodes += guiConfig.MapViewerButtons.children(); 
			for(var j:Number=0;j<buttonNodes.length();j++){
				var buttonName:String = String(buttonNodes[j].Name);
				var button:XML = orgButtonNodes.(Name==buttonName)[0];
				if(button!=null){
					var buttonAttributes:XMLList = buttonNodes[j].children();
					for(var k:Number=0;k<buttonAttributes.length();k++){
						var attrName:String = buttonAttributes[k].localName();
						if(attrName!="Name" && 
							attrName!="IconURL" && attrName!="Action"){
							if(button.child(attrName)[0]!=null){
								buttonAttributes[k] = button.child(attrName)[0];
							}
						}
					}
				}	
			}
			var buttonCollection:XMLListCollection = new XMLListCollection();
			buttonCollection.source = buttonNodes;

			var paneNodes:XMLList =  newConfig.SinglePaneComponents.children();
			paneNodes += newConfig.MultiPaneComponents.children();
			var orgPaneNodes:XMLList = guiConfig.SinglePaneComponents.children();
			orgPaneNodes += guiConfig.MultiPaneComponents.children();
			for(var l:Number=0;l<paneNodes.length();l++){
				var paneName:String = String(paneNodes[l].Name);
				var pane:XML = orgPaneNodes.(Name==paneName)[0];
				var paneAttributes:XMLList = paneNodes[l].children();
				if(paneName!=null && pane!=null){ 
					for(var m:Number=0;m<paneAttributes.length();m++){
						var paneAttrName:String = paneAttributes[m].localName();
						if(paneAttrName!="Name" && 
						    paneAttrName!="URL" && 
							paneAttrName!="Scrollable" && 
							paneAttrName!="Resizable" &&
							paneAttrName!="Closeable" && 
							paneAttrName!="PaneButton" && paneAttrName!="Adapters" &&
							paneAttrName!="Buttons"){
							if(pane.child(paneAttrName)[0]!=null){
								paneAttributes[m] = pane.child(paneAttrName)[0];
							}
						}
					}
				}	
			}
			
			newConfig.@id = guiConfig.@id;
			newConfig.@clientId = guiConfig.@clientId;
			newConfig.@status = guiConfig.@status;
			return newConfig;
		}
		
		private function deleteConfigTagsToHide(config:XML):XML{
			delete(config.child("DebugStatementsLevel")[0] );
			delete(config.child("MultiFeatureEdit")[0] );
			delete(config.child("Type")[0] );
			delete(config.child("FrameClass")[0] );
			delete(config.child("ButtonBarClass")[0] );
			delete(config.child("GIContext")[0] );
			delete(config.child("SRSInfo")[0] );
			delete(config.child("Strings")[0] );
			delete(config.child("Modes")[0] );
			delete(config.child("Description")[0] );
			return config;		
		}
		
		private function mainUpdateListener(event:CollectionEvent):void {
			for each(var item:Object in event.items) {
				if(item is PropertyChangeEvent) {
					var changeEvent:PropertyChangeEvent =
						PropertyChangeEvent(item);
						
					var source:XML = XML(changeEvent.source);		
						
					// update contextTree (layer updates are handled seperately)
					if(source.localName() != "Layer") {	
						for each(var itemRef:XML in contextTree.source.descendants(source.localName())) {
							if(itemRef.@id == source.@id 
								&& itemRef.@clientId == source.@clientId) {
								var newChilds:XMLList = newRef(source).children();
								if(newChilds != itemRef.children()) {
									itemRef.setChildren(newChilds);
								}
							}
						}
					}
						
					if(changeEvent.kind == "update") {
						if(changeEvent.property != "@status") {		
							// update status							
							if(source.@status != "new") {
								source.@status = "changed";
								
								// Also update the status in the contextTree
								for each(var treeItem:XML in 
									contextTree.descendants(source.localName())) {
									if(treeItem.@id == source.@id
										&& treeItem.@clientId == source.@clientId) { 
										treeItem.@status = "changed";
									}
								}
								
								// Also update the status in the guiTree
								for each(treeItem in 
									guiTree.descendants(source.localName())) {
									if(treeItem.@id == source.@id
										&& treeItem.@clientId == source.@clientId) { 
										treeItem.@status = "changed";
									}
								}
								
								// Also update the status in the serverTree (only Server entities)
								if(source.localName() == "Server") {
									for each(treeItem in 
										serverTree.descendants(source.localName())) {
										if(treeItem.@id == source.@id
											&& treeItem.@clientId == source.@clientId) { 
											treeItem.@status = "changed";
										}
									}
								}
							}
						} else { // changeEvent.property == "@status"
							if(changeEvent.newValue == "deleted") {
								if(source.localName() == "Server") {
									for each(treeItem in serverTree.descendants("Server")) {
										if(treeItem.@id == source.@id
											&& treeItem.@clientId == source.@clientId) { 
											treeItem.@status = "deleted";
										}
									}
								} else {
									for each(treeItem in contextTree.descendants(source.localName())) {
										if(treeItem.@id == source.@id
											&& treeItem.@clientId == source.@clientId) { 
											treeItem.@status = "deleted";
										}
									}
								}
							}
						}
					}
				}
			}
		}
		
		private function contextUpdateListener(event:CollectionEvent):void {
			if(event.kind == "add" && event.items is Array) {
				for each(var context:XML in event.items) {
					XML(contextTree.getItemAt(0)).appendChild(newRef(context));
				}
			}
		}
		
		private function layerUpdateListener(event:CollectionEvent):void {				
			for each(var map:XML in contextTree.source..Map) {
				// lookout for differences between the current references and 
				// the desired references						
				var altRef:XML = newRef(map);
				
				// ignore differences in status attribute (unless status == "deleted")
				var altRefCopy:XML = altRef.copy();
				var mapCopy:XML = map.copy();
				
				for each(var item:XML in altRefCopy.descendants()) {
					if(item.@status != "deleted") {
						delete item.@status;
					}
				}
				
				for each(item in mapCopy.descendants()) {
					if(item.@status != "deleted") {
						delete item.@status;
					}
				}
				
				if(altRefCopy != mapCopy) { 
					map.setChildren(altRef.children());
				}
			}
		}
		
		private function serverUpdateListener(event:CollectionEvent):void {
			if(event.kind != "update") {
				buildServerTree();
			}
		}
		
		private function addListeners() : void {
			// listener for updates in entity xml collections
			layerProps.addEventListener(CollectionEvent.COLLECTION_CHANGE, mainUpdateListener);
			contextProps.addEventListener(CollectionEvent.COLLECTION_CHANGE, mainUpdateListener);
			mapProps.addEventListener(CollectionEvent.COLLECTION_CHANGE, mainUpdateListener);
			queryAspectProps.addEventListener(CollectionEvent.COLLECTION_CHANGE, mainUpdateListener);
			templateProps.addEventListener(CollectionEvent.COLLECTION_CHANGE, mainUpdateListener);
			reportProps.addEventListener(CollectionEvent.COLLECTION_CHANGE, mainUpdateListener);
			serverProps.addEventListener(CollectionEvent.COLLECTION_CHANGE, mainUpdateListener);
			guiConfigProps.addEventListener(CollectionEvent.COLLECTION_CHANGE, mainUpdateListener);
			
			// listener for new contexts
			contextProps.addEventListener(CollectionEvent.COLLECTION_CHANGE, contextUpdateListener);
			
			// listener for layer updates (adding sublayers doens't result in 
			// change events on maps)
			layerProps.addEventListener(CollectionEvent.COLLECTION_CHANGE, layerUpdateListener);
			
			serverProps.addEventListener(CollectionEvent.COLLECTION_CHANGE, serverUpdateListener);
		}
		
		private function removeListeners() : void {
			layerProps.removeEventListener(CollectionEvent.COLLECTION_CHANGE, mainUpdateListener);
			contextProps.removeEventListener(CollectionEvent.COLLECTION_CHANGE, mainUpdateListener);
			mapProps.removeEventListener(CollectionEvent.COLLECTION_CHANGE, mainUpdateListener);
			queryAspectProps.removeEventListener(CollectionEvent.COLLECTION_CHANGE, mainUpdateListener);
			templateProps.removeEventListener(CollectionEvent.COLLECTION_CHANGE, mainUpdateListener);
			reportProps.removeEventListener(CollectionEvent.COLLECTION_CHANGE, mainUpdateListener);
			serverProps.removeEventListener(CollectionEvent.COLLECTION_CHANGE, mainUpdateListener);
			
			contextProps.removeEventListener(CollectionEvent.COLLECTION_CHANGE, contextUpdateListener);
			
			layerProps.removeEventListener(CollectionEvent.COLLECTION_CHANGE, layerUpdateListener);
			
			serverProps.removeEventListener(CollectionEvent.COLLECTION_CHANGE, serverUpdateListener);
		}
		
		private function setDefaultAttributes(list:XMLList):void {
			for each(var item:XML in list) {
				item.@clientId = "false";
				item.@status = "existing";
			}
		}
		
		public function setAllDefaultAttributes(response:XML):void {		
			setDefaultAttributes(response..Context);
			setDefaultAttributes(response..Layer);
			setDefaultAttributes(response..Map);
			setDefaultAttributes(response..QueryAspect);
			setDefaultAttributes(response..Report);
			setDefaultAttributes(response..Map_id); // reference to map in report entity
			setDefaultAttributes(response..Server);
			setDefaultAttributes(response..Featureserver);
			setDefaultAttributes(response..Template);
			setDefaultAttributes(response..Geoide_Client_Config);
		}
		
		private function loadData():void {
			var getPropertiesRequest:URLLoader = new URLLoader();
			getPropertiesRequest.addEventListener(IOErrorEvent.IO_ERROR, function():void {
				dispatchEvent(new Event("ioError"));
			});
			getPropertiesRequest.addEventListener(Event.COMPLETE, function():void
			{	
				properties = XML(getPropertiesRequest.data);
				
				var defaultConfigRequest:URLLoader = new URLLoader();
				defaultConfigRequest.addEventListener(IOErrorEvent.IO_ERROR, function():void {
					dispatchEvent(new Event("ioError"));
				});
				defaultConfigRequest.addEventListener(Event.COMPLETE, function():void
				{	
					defaultConfig = XML(defaultConfigRequest.data);
					
					var getEntitiesRequest:URLLoader = new URLLoader();
					getEntitiesRequest.addEventListener(IOErrorEvent.IO_ERROR, function():void {
						dispatchEvent(new Event("ioError"));
					});
					getEntitiesRequest.addEventListener(Event.COMPLETE, function():void
					{
						var response:XML = XML(getEntitiesRequest.data);
						setAllDefaultAttributes(response);
						
						layerProps.source = response.Layers.Layer.copy();										
						contextProps.source = response.Contexts.Context.copy();
						mapProps.source = response.Maps.Map.copy();
						queryAspectProps.source = response.QueryAspects.QueryAspect.copy();
						templateProps.source = response.Templates.Template.copy();
						reportProps.source = response.Reports.Report.copy();
						serverProps.source = response.Servers.Server.copy();
						guiConfigProps.source =  response.Configs.Geoide_Client_Config.copy();
						
						buildContextTree();
						buildServerTree();
						buildGUIDataSource();
						
						addListeners();
					});
					
					getEntitiesRequest.load(new URLRequest(_serverUrl + "request=GetEntities&brief=true"));
				});
					
				defaultConfigRequest.load(new URLRequest(_defaultConfigUrl));
			});
			getPropertiesRequest.load(new URLRequest(_propertiesUrl));
		}
			
		public function DataSource(callback:Function){	
			var configLoader:URLLoader = new URLLoader();
			configLoader.addEventListener(Event.COMPLETE, function():void
			{
				_serverUrl = XML(configLoader.data).server.toString();
				_proxyServerUrl = XML(configLoader.data).proxyServer.toString();
				_defaultConfigUrl = XML(configLoader.data).defaultGUIConfigUrl.toString();
				_propertiesUrl = XML(configLoader.data).propertiesUrl.toString();
				var getAuthorRequest:URLLoader = new URLLoader();
				getAuthorRequest.addEventListener(IOErrorEvent.IO_ERROR, function():void {
					dispatchEvent(new Event("ioError"));
				});
				getAuthorRequest.addEventListener(Event.COMPLETE, function():void
				{
					var response:XML = XML(getAuthorRequest.data);
					_login = response.Name.toString();
					callback();						
					loadData();					
				});
				getAuthorRequest.load(new URLRequest(_serverUrl + "request=GetAuthor"));
			});	
			var baseUrl:String = "";
			var index:int = Application.application.url.lastIndexOf("/");
			if(index != -1) {
				baseUrl = Application.application.url.substr(0, index + 1);
			}	
			configLoader.load(new URLRequest(baseUrl + "config.xml"));	
		}
		
		public function getLayers(mapItem:XML):XMLList
		{
			return newRef(mapItem)..Layer;
		}
		
		private function getMaps(contextItem:XML):XMLList 
		{
			return getProps(contextItem).Maps.Map;
		}
		
		public function getQueryAspects(mapItem:XML):XMLList 
		{
			return getProps(mapItem).QueryAspects.QueryAspect;
		}
		
		public function getTemplates(mapItem:XML):XMLList 
		{
			return getProps(mapItem).Templates.Template;
		}
		
		public function getProps(item:XML, acceptBrief:Boolean = true, handler:Function = null):XML
		{	
			if(item == null) 
				return null;
				
			var localName:String = item.localName();
			if(localName == "Featureserver") {				
				localName = "Server";				
			}
				
			var list:XMLList = null;
			var entry:XML = item;			
			switch(localName)
			{
				case "Context":
					list = contextProps.source;
					break;
				case "Map":
					list = mapProps.source;
					break;
				case "Server":
					list = serverProps.source;
					break;
				case "Layer":
					list = layerProps.source;
					break;
				case "QueryAspect":
					list = queryAspectProps.source;
					break;
				case "Template":
					list = templateProps.source;
					break;	
				case "Report":
					list = reportProps.source;					
					break;
				case "Geoide_Client_Config":
				case "Colors":
				case "ButtonBar":
				case "MapViewerButton":
				case "ActionButton":
				case "PaneButton":
				case "SinglePaneComponent":
				case "MultiPaneComponent":					
					list = guiConfigProps.source;
					while(entry.localName() != 'Geoide_Client_Config') {
						entry = entry.parent();
					}
			}
			
			if(list == null)
				return null;
									
			var retval:XML = null;
			for each(var currentItem:XML in list)
			{
				if(currentItem.@id == entry.@id
							&& currentItem.@clientId == entry.@clientId) {
					switch(localName) {
						case "Colors":
							retval = currentItem..Colors[0];
						case "ButtonBar":
							retval = currentItem..ButtonBars.ButtonBar.(Name == item.Name)[0];
						case "MapViewerButton":
							retval = currentItem..MapViewerButtons.MapViewerButton.(Name == item.Name)[0];
						case "ActionButton":
							retval = currentItem..ActionButtons.ActionButton.(Name == item.Name)[0];
						case "SinglePaneComponent":
							retval = currentItem..SinglePaneComponents.SinglePaneComponent.(Name == item.Name)[0];
						case "MultiPaneComponent":
							retval = currentItem..MultiPaneComponents.MultiPaneComponent.(Name == item.Name)[0];
						case "PaneButton":
							retval = currentItem..PaneButtons.PaneButton.(Name == item.Name)[0];
						default:
							retval = currentItem;
					}
				}
			}
			
			if(retval.@brief == 'false' && handler != null) {
				handler();
			}
			
			if(retval != null && retval.@brief == 'true' && !acceptBrief) {
				if(fullPropsLoading[item.localName() + item.@id] == null) {
					// start request
					var getFullProps:URLLoader = new URLLoader();
					getFullProps.addEventListener(IOErrorEvent.IO_ERROR, function():void {
						dispatchEvent(new Event("ioError"));
					});
					getFullProps.addEventListener(Event.COMPLETE, function():void
					{	
						var fullProps:XML = XML(getFullProps.data);
						setAllDefaultAttributes(fullProps);
						
						// also fetch refered servers
						switch(retval.localName()) {
							case "Layer":
							case "QueryAspect":
								var count:Number = 0;
								var handler:Function = function():void {
									count--;
									if(count == 0) {
										storeProps(fullProps, retval);
									}	
								}
								
								for each(var server:XML in fullProps..Server) {
									getProps(server, false, handler);
									count++;
								}
								for each(server in fullProps..Featureserver) {
									getProps(server, false, handler);
									count++;
								}
							default:
								storeProps(fullProps, retval);
						}
						
						if(handler != null) {
							handler();
						}
					});
					
					
					var request:String = _serverUrl + "request=GetEntities&brief=false&"
						+ item.localName().toString().toLowerCase() + "=" + item.@id;
					getFullProps.load(new URLRequest(request));
					fullPropsLoading[item.localName() + item.@id] = new Object();
				}
			}
			
			return retval;
		}
		
		private function storeProps(props:XML, item:XML):void {
			var fullItem:XML = props.descendants(item.localName())[0];
			removeListeners();
			item.setChildren(fullItem.children());
			item.@brief = false;
			addListeners();
			fullPropsLoading[item.localName() + item.@id] = null;
		}
		
		public function getXMLAsString():String		
		{
			/*return "\nlayerProps:\n" + layerProps.toString()
				+ "\nmapProps:\n" + mapProps.toString()
				+ "\ncontextTree:\n" + contextTree.toString()
				+ "\ncontextProps:\n" + contextProps.toString()
				+ "\nserverProps:\n" + serverProps.toString()
				+ "\nqueryAspectProps:\n" + queryAspectProps.toString()
				+ "\ntemplateProps:\n" + templateProps.toString();*/
				
			return layerProps.source.(@brief == 'false').toString();
			
			//return contextProps.toString() + '\n' + serverProps.toString();
			//return transaction.toString();
			//return queryAspectProps.toString();	
		}
		
		public function isGroupLayer(layerItem:XML):Boolean
		{
			return getProps(layerItem).Type == "Group";
		}
		
		public function isOwner(item:XML):Boolean
		{
			var props:XML = item.child("Owner").length() == 0 ? getProps(item)[0] : item;
			if(props != null && props.Owner.length() > 0) {
				return props.Owner == _login;
			}
				return false;			
		}
		
		private function isClientId(item:XML):Boolean {
			return item.child("@clientId").length() > 0 && item.@clientId;
		}
		
		public function duplicateItem(item:XML, parentNode:XML):void {
			item = getProps(item).copy();
			while(!isUnique(item.localName(), item.Name, true)) {
				item.Name += "_copy";
			}			
			item.@clientId = true;
			item.@status = "new";
			item.@id = lastId++;
			item.Owner = _login;
			
			addItem(item, parentNode);
		}
		
		public function newRef(item:XML, subRef:Boolean = true):XML 
		{
			var language:String = resourceManager.localeChain[0].toString().substr(0, 2);
			
			item = getProps(item);
			var localName:String = item.localName();
						
			var itemRef:XML = <{localName}/>;
			itemRef.@status = item.@status;
			itemRef.@id = item.@id;			
			itemRef.@clientId = item.@clientId;
			
			if(subRef) {	
				switch(localName) {
					case "Map":
						var layersNode:XML = <Layers/>;
						for each(var currentLayer:XML in item.Layers.Layer) {
							var layerRef:XML = newRef(currentLayer);
							layerRef.@status = currentLayer.@status;
							layersNode.appendChild(layerRef);
						}
						itemRef.appendChild(layersNode);
						
						var queryAspectsNode:XML = <QueryAspects/>;
						var queryAspectsCollection:XMLListCollection 
							= new XMLListCollection(item.QueryAspects.QueryAspect);
						/*var queryAspectsSort:Sort = new Sort();
						var queryAspectsField:SortField = new SortField();
						var defaultCompareFunction:Function = queryAspectsField.compareFunction;
						queryAspectsField.compareFunction = function(a:Object, b:Object):int {										
							return defaultCompareFunction(getProps(XML(a)).Titles.Title.(Language == language).Title, 
								getProps(XML(b)).Titles.Title.(Language == language).Title);
						}
						queryAspectsSort.fields = [queryAspectsField];
						queryAspectsCollection.sort = queryAspectsSort;
						queryAspectsCollection.refresh();*/
						for each(var currentQueryAspect:XML in queryAspectsCollection) {
							var queryAspectRef:XML = newRef(currentQueryAspect);
							// Use the same status as the reference in the entity (for deleted references)
							queryAspectRef.@status = currentQueryAspect.@status;
							queryAspectsNode.appendChild(queryAspectRef);
						}
						itemRef.appendChild(queryAspectsNode);
						
						var templatesNode:XML = <Templates/>;
						for each(var currentTemplate:XML in item.Templates.Template) {
							var templateRef:XML = newRef(currentTemplate);
							templateRef.@status = currentTemplate.@status;
							templatesNode.appendChild(templateRef);
						}
						itemRef.appendChild(templatesNode);
						
						var reports:XML = <Reports/>;
						for each(var report:XML in reportProps) {
							if(report.Map_id == item.@id 
								&& report.Map_id.@clientId == item.@clientId) {
								var reportRef:XML = newRef(report);
								reportRef.@status = report.@status;
								reports.appendChild(reportRef);									
							}
						}
						
						itemRef.appendChild(reports); 
					break;
					
					case "Context":
					var maps:XML = <Maps/>;
					var mapsCollection:XMLlistCollection = new XMLListCollection(item.Maps.Map);
					/*var mapsSort:Sort = new Sort();
					var mapsField:SortField = new SortField();
					defaultCompareFunction = mapsField.compareFunction;
					mapsField.compareFunction = function(a:Object, b:Object):int {														
						return defaultCompareFunction(getProps(XML(a)).Titles.Title.(Language == language).Title, 
							getProps(XML(b)).Titles.Title.(Language == language).Title);
					}
					mapsSort.fields = [mapsField];
					mapsCollection.sort = mapsSort;
					mapsCollection.refresh();*/
					for each(var map:XML in mapsCollection) {
						var mapRef:XML = newRef(map);
						mapRef.@status = map.@status; 
						maps.appendChild(mapRef);
					}
					itemRef.appendChild(maps);
					break;
					
					case "Layer":	
					var layerProps:XML = getProps(item);
					if(layerProps.Type == "Group") {
						for each(var subLayer:XML in layerProps.Layers.Layer) {
							var subLayerRef:XML = newRef(subLayer);
							// Use the same status as the reference in the entity (for deleted references)
							subLayerRef.@status = subLayer.@status; 
							itemRef.appendChild(subLayerRef);
						}
					}
					break;				
				}
			}		
						
			return itemRef;
		}
		
		public function newLayer():XML
		{
			var newItem:XML = 
			<Layer clientId="true" status="new">
				<Type>Layer</Type>
				<Titles>
					<Title>
						<Language>en</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>nl</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>de</Language>
						<Title></Title>
					</Title>
				</Titles>
				<Server/>
			</Layer>;
			newItem.@id = lastId++;	
			newItem.Owner = _login;	
			//newItem.Server.@id = serverProps.source.Server[0].@id;			
			return newItem;
		}
		
		public function newGroupLayer():XML
		{
			var newItem:XML = 
			<Layer clientId="true" status="new">
				<Type>Group</Type>
				<Titles>
					<Title>
						<Language>en</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>nl</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>de</Language>
						<Title></Title>
					</Title>
				</Titles>		
				<Layers/>		
			</Layer>;
			newItem.@id = lastId++;
			newItem.Owner = _login;
			return newItem;
		}
		
		public function newMap():XML
		{
			var newItem:XML = 
			<Map clientId="true" status="new">
				<Titles>
					<Title>
						<Language>en</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>nl</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>de</Language>
						<Title></Title>
					</Title>
				</Titles>
				<Layers/>
				<QueryAspects/>	
				<Templates/>
				<Reports/>							
			</Map>;
			newItem.@id = lastId++;
			newItem.Owner = _login;
			return newItem;
		}
		
		public function newServer():XML
		{
			var newItem:XML =
			<Server clientId="true" status="new">
			</Server>;
			newItem.@id = lastId++;
			newItem.Owner = _login;						
			return newItem;
		}
		
		public function newQueryAspect():XML
		{
			var newItem:XML =
			<QueryAspect clientId="true" status="new">
				<Titles>
					<Title>
						<Language>en</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>nl</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>de</Language>
						<Title></Title>
					</Title>
				</Titles>
				<Actions/>
				<FeatureTypeProperties/>
			</QueryAspect>;
			newItem.@id = lastId++;
			newItem.Owner = _login;						
			return newItem;
		}
		
		public function newTemplate():XML
		{
			var newItem:XML =
			<Template clientId="true" status="new">
				<Titles>
					<Title>
						<Language>en</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>nl</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>de</Language>
						<Title></Title>
					</Title>
				</Titles>
				<Margin>
					<Top>10</Top>
					<Left>10</Left>
					<Right>10</Right>
					<Bottom>10</Bottom>
				</Margin>
				<Elements>
					<Element>
						<Type>map</Type>
						<X>0</X>
						<Y>0</Y>
						<Width>0</Width>
						<Height>0</Height>
					</Element>
				</Elements>				
			</Template>;
			newItem.@id = lastId++;
			newItem.Owner = _login;						
			return newItem;
		}
		
		public function newReport(map:XML):XML
		{
			var newItem:XML =
			<Report clientId="true" status="new">
				
				<Titles>
					<Title>
						<Language>en</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>nl</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>de</Language>
						<Title></Title>
					</Title>
				</Titles>
				<Map_id clientId={map.@clientId} status={map.@status}>{map.@id}</Map_id>
			</Report>
			newItem.@id = lastId++;
			return newItem;
		}
		
		
		public function newContext():XML
		{
			var newItem:XML =
			<Context clientId="true" status="new">
				<Maps/>
			</Context>
			newItem.@id = lastId++;
			newItem.Owner = _login;
			return newItem;
		}
		
		public function newButtonBar(buttonBars:XML):XML
		{
			var newItem:XML =
			<ButtonBar>
				<Name>
					New ButtonBar
				</Name>
				<InitVisible>True</InitVisible>
           		<ButtonSize>27</ButtonSize>

				<Buttons/>
			</ButtonBar>

			return newItem;
		}
		
		public function newConfig(configs:XML):XML
		{
			var newItem:XML = new XML(this.defaultConfig);	
			newItem.@name = '';
			newItem.@id = lastId++; 
			newItem.@status = 'new';
			newItem.@clientId = 'true';
			newItem.Description = '';
			return newItem;
		}
		
		
		
		private function getParentEntity(parentNode:XML):XML {
			if(parentNode == null) {
				return null;
			}
			
			
			while(entityNames.indexOf(parentNode.localName()) == -1) {
				parentNode = parentNode.parent();
				if(parentNode == null) {
					return null;
				}				
			}
			
			return getProps(parentNode);
		}
		
		public function addRef(item:XML, parentNode:XML):void {
			if(item.localName() == "Context" || item.localName() == "Server") {
				parentNode = null;
				
				getProps(item).@status = "deleted";
			} else {			
				parentNode = getParentEntity(parentNode);
			}
			
			if(parentNode != null) {
				XML(parentNode.child(item.localName() + "s")[0]).appendChild(newRef(item, false));
			}
		}
		
		public function removeRef(item:XML, parentNode:XML):void {
			if(item.localName() == "Context" || item.localName() == "Server") {
				parentNode = null;
				
				getProps(item).@status = "deleted";
			} else {			
				parentNode = getParentEntity(parentNode);
			}
			
			if(parentNode != null) {
				var items:XMLList = parentNode.descendants(item.localName());
				for each(var currentItem:XML in items) {
					if(currentItem.@id == item.@id
						&& currentItem.@clientId == item.@clientId) {
						currentItem.@status = "deleted";
					}
				}  
			}
		}
		
		public function addItem(newItem:XML, parentNode:XML):void
		{
			switch(newItem.localName()) {
				case 'Geoide_Client_Config':
					parentNode.appendChild(deleteConfigTagsToHide(newItem.copy()));
					guiConfigProps.addItem(newItem);
					return;		
				case 'ButtonBar':
					getProps(parentNode.parent()).ButtonBars.appendChild(newItem);
					parentNode.appendChild(newItem);
					return;	
			}
			
			if(newItem.localName() == "Context") {
				parentNode = null;
			} else {			
				parentNode = getParentEntity(parentNode);
			}
			
			switch(newItem.localName())
			{
				case 'Layer':
					layerProps.addItem(newItem);
					parentNode.Layers.Layer += newRef(newItem, false);
					break;
				case 'Map':
					mapProps.addItem(newItem);
					parentNode.Maps.Map += newRef(newItem, false);
					break;
				case 'Server':
					serverProps.addItem(newItem);
					break;
				case 'Context':
					contextProps.addItem(newItem);					
					break;
				case 'QueryAspect':
					queryAspectProps.addItem(newItem);
					parentNode.QueryAspects.QueryAspect += newRef(newItem, false);
					break;
				case 'Template':
					templateProps.addItem(newItem);
					parentNode.Templates.Template += newRef(newItem, false);
					break;
				case 'Report':
					reportProps.addItem(newItem);
					parentNode.Reports.Report += newRef(newItem, false);
			}
		}
		
		private function replaceClientId(clientId:Number, serverId:Number, 
			items:XMLList, recursive:Boolean = true):void
		{
			var newItems:XMLList = items.(@status == "new").(@id == clientId);
			for each(var item:XML in newItems)
			{
				delete item.@clientId;
				item.@id = serverId;
				item.@status = "existing";				
			}
			
			if(recursive)
			{
				for each(item in items)
				{
					replaceClientId(clientId, serverId, item.children());
				}
			}
		}
		
		private function setLayerId(list:XMLList, clientId:String, serverId:String):void {
			for each(var layerRef:XML in list..Layer.
				(attribute("clientId").length() > 0 
					&& @clientId.toString().toLowerCase() == "true"
					&& @id == clientId)) {
				layerRef.@id = serverId;
				delete layerRef.@clientId;
				layerRef.@status = "existing";
			}
		}
		
		private function setMapId(list:XMLList, clientId:String, serverId:String):void {
			for each(var mapRef:XML in list..Map.
				(attribute("clientId").length() > 0 
					&& @clientId.toString().toLowerCase() == "true"
					&& @id == clientId)) {
				mapRef.@id = serverId;
				delete mapRef.@clientId;
				mapRef.@status = "existing";
			}
		}
		
		private function setContextId(list:XMLList, clientId:String, serverId:String):void {
			for each(var contextRef:XML in list..Context.
				(attribute("clientId").length() > 0 
					&& @clientId.toString().toLowerCase() == "true"
					&& @id == clientId)) {
				contextRef.@id = serverId;
				delete contextRef.@clientId;
				contextRef.@status = "existing";
			}
		}
		
		private function setTemplateId(list:XMLList, clientId:String, templateId:String):void {
			for each(var templateRef:XML in list..Template.
				(attribute("clientId").length() > 0 
					&& @clientId.toString().toLowerCase() == "true"
					&& @id == clientId)) {
				templateRef.@id = templateId;
				delete templateRef.@clientId;
				templateRef.@status = "existing";
			}
		}
		
		private function setReportId(list:XMLList, clientId:String, reportId:String):void {
			for each(var reportRef:XML in list..Report.
				(attribute("clientId").length() > 0 
					&& @clientId.toString().toLowerCase() == "true"
					&& @id == clientId)) {
				reportRef.@id = reportId;
				delete reportRef.@clientId;
				reportRef.@status = "existing";
			}
		}
		
		private function setQueryAspectId(list:XMLList, clientId:String, serverId:String):void {
			for each(var queryAspectRef:XML in list..QueryAspect.
				(attribute("clientId").length() > 0 
					&& @clientId.toString().toLowerCase() == "true"
					&& @id == clientId)) {
				queryAspectRef.@id = serverId;
				delete queryAspectRef.@clientId;
				queryAspectRef.@status = "existing";
			}
		}
		
		private function setServerId(list:XMLList, clientId:String, serverId:String):void {
			for each(var server:XML in list..Server.
				(attribute("clientId").length() > 0 
					&& @clientId.toString().toLowerCase() == "true"
					&& @id == clientId)) { 
				server.@id = serverId;
				delete server.@clientId;
				server.@status = 'existing';
			}
			
			for each(server in list..Featureserver.
				(attribute("clientId").length() > 0 
					&& @clientId.toString().toLowerCase() == "true"
					&& @id == clientId)) { 
				server.@id = serverId;
				delete server.@clientId;
				server.@status = 'existing';
			}
		}
		
		private var transaction:XML;
		
		public function save():void {
			transaction = 
			<Transaction>
				<Insert>
					<Contexts>{contextProps.source.copy().(@status == 'new')}</Contexts>
					<Layers>{layerProps.source.copy().(@status == 'new')}</Layers>
					<Maps>{mapProps.source.copy().(@status == 'new')}</Maps>
					<QueryAspects>{queryAspectProps.source.copy().(@status == 'new')}</QueryAspects>
					<Templates>{templateProps.source.copy().(@status == 'new')}</Templates>
					<Reports>{reportProps.source.copy().(@status == 'new')}</Reports>
					<Servers>{serverProps.source.copy().(@status == 'new')}</Servers>
					<Geoide_Client_Configs>{guiConfigProps.source.copy().(@status == 'new')}</Geoide_Client_Configs>
				</Insert>
				<Update>
					<Contexts>{contextProps.source.copy().(@status == 'changed')}</Contexts>
					<Layers>{layerProps.source.copy().(@status == 'changed')}</Layers>
					<Maps>{mapProps.source.copy().(@status == 'changed')}</Maps>
					<QueryAspects>{queryAspectProps.source.copy().(@status == 'changed')}</QueryAspects>
					<Templates>{templateProps.source.copy().(@status == 'changed')}</Templates>
					<Reports>{reportProps.source.copy().(@status == 'changed')}</Reports>
					<Servers>{serverProps.source.copy().(@status == 'changed')}</Servers>
					<Geoide_Client_Configs>{guiConfigProps.source.copy().(@status == 'changed')}</Geoide_Client_Configs>
				</Update>
				<Delete>
					<Contexts>{contextProps.source.copy().(@status == 'deleted' && @clientId == 'false')}</Contexts>
					<Layers>{layerProps.source.copy().(@status == 'deleted' && @clientId == 'false')}</Layers>
					<Maps>{mapProps.source.copy().(@status == 'deleted' && @clientId == 'false')}</Maps>
					<QueryAspects>{queryAspectProps.source.copy().(@status == 'deleted' && @clientId == 'false')}</QueryAspects>
					<Templates>{templateProps.source.copy().(@status == 'deleted' && @clientId == 'false')}</Templates>
					<Reports>{reportProps.source.copy().(@status == 'deleted' && @clientId == 'false')}</Reports>
					<Servers>{serverProps.source.copy().(@status == 'deleted' && @clientId == 'false')}</Servers>
					<Geoide_Client_Configs>{guiConfigProps.source.copy().(@status == 'deleted' && @clientId == 'false')}</Geoide_Client_Configs>
				</Delete>
			</Transaction>;
			
			var contextsUpdated:Boolean = transaction..Contexts.children().length() > 0;
			var guiConfigsUpdated:Boolean = transaction..Geoide_Client_Configs.children().length() > 0;
			
			var item:XML;
			// remove deleted references			
			for each(item in transaction.Insert.descendants().(attribute("status").length() > 0 && @status == "deleted")) {
				delete transaction.Insert.descendants().(copy() == item)[0];
			}
			
			for each(item in transaction.Update.descendants().(attribute("status").length() > 0 && @status == "deleted")) {
				delete transaction.Update.descendants().(copy() == item)[0];
			}
			 
			// remove status attributes			
			for each(item in transaction.descendants()) {				
				delete item.@status;
			}
			
			// Send transaction to server
			var doTransactionRequest:URLLoader = new URLLoader();
			doTransactionRequest.addEventListener(IOErrorEvent.IO_ERROR, function():void {
				dispatchEvent(new Event("ioError"));
			});
			doTransactionRequest.addEventListener(Event.COMPLETE, function(event:Event):void
			{
				var response:XML = XML(doTransactionRequest.data);	
				if(response.localName() == "Exception") {
					Alert.show(response.Message.toString());
				} else if(response.localName() == "TransactionResult") {
					// Disable listeners
					removeListeners();
							   
					// Update id's  
					for each(var insertNode:XML in response.Inserted.children()) {
						var id:String = insertNode.@id; 
						var clientId:String = insertNode.@clientId;
						
						var localName:String = insertNode.localName();
						
						var list:XMLList = (serverProps.descendants(localName)
							+ layerProps.descendants(localName)
							+ queryAspectProps.descendants(localName)
							+ templateProps.descendants(localName)
							+ reportProps.descendants(localName)
							+ mapProps.descendants(localName)
							+ guiConfigProps.descendants(localName)
							+ contextProps.descendants(localName)).(@clientId == "true" && @id == clientId)
							+ getProps(<{localName} clientId="true" id={clientId}/>);
							
							
						for each(var item:XML in list) {
							item.@id = id;
							item.@clientId = "false";
							item.@status = "existing";
						}
					}
												   
					// Reset status attributes
					list = (serverProps.descendants()
							+ layerProps.descendants()
							+ queryAspectProps.descendants()
							+ templateProps.descendants()
							+ reportProps.descendants()
							+ mapProps.descendants()
							+ contextProps.descendants()
							+ serverProps.source
							+ layerProps.source
							+ queryAspectProps.source
							+ templateProps.source
							+ reportProps.source
							+ mapProps.source
							+ contextProps.source
							+ guiConfigProps.source).(attribute("status").length() > 0 && @status == "changed");
					
					for each(item in list) {
						item.@status = "existing";
					}
					
					// Remove deleted entities
					var collections:Array = [serverProps, layerProps, queryAspectProps, templateProps, reportProps,
						mapProps, contextProps, guiConfigProps];
					for each(var collection:XMLListCollection in collections) {
						for each(item in collection) {
							if(item.@status == "deleted") {
								collection.removeItemAt(collection.getItemIndex(item));
							}
						}
					}
					
					// Remove deleted references
					for each(item in layerProps.source.descendants().(attribute("status").length() > 0 && @status == "deleted")) {
						delete layerProps.source.descendants().(copy() == item)[0];
					}
					
					for each(item in mapProps.source.descendants().(attribute("status").length() > 0 && @status == "deleted")) {
						delete mapProps.source.descendants().(copy() == item)[0];
					}
					
					for each(item in contextProps.source.descendants().(attribute("status").length() > 0 && @status == "deleted")) {
						delete contextProps.source.descendants().(copy() == item)[0];
					}
					
					for each(item in guiConfigProps.source.descendants().(attribute("status").length() > 0 && @status == "deleted")) {
						delete guiConfigProps.source.descendants().(copy() == item)[0];
					}
					
					// Rebuild trees
					buildContextTree();
					buildServerTree();
					buildConfigTree();

					
					// Re enable listeners
					addListeners();
					
					if(contextsUpdated) {
						var contexts:Array = new Array();
						for each(item in contextProps) {
							contexts.push(item.Name.toString());
						}
						
						Application.application.dispatchEvent(new ConfigChangeEvent(ConfigChangeEvent.CONTEXTS_CHANGE,
							contexts));
					}
					
					if(guiConfigsUpdated) {
						var guiConfigs:Array = new Array();
						for each(item in guiConfigProps) {
							guiConfigs.push(item.@name.toString());
						}
						
						Application.application.dispatchEvent(new ConfigChangeEvent(ConfigChangeEvent.GUI_CONFIGS_CHANGE,
							guiConfigs));
					}
					
					// Show alert
					Alert.show("Inserted : " + response.Inserted.@count + "\n" +
							   "Updated  : " + response.Updated.@count + "\n" +
							   "Deleted  : " + response.Deleted.@count);
				}
			});
			
			var request:URLRequest = new URLRequest(_serverUrl + "request=DoTransaction");
			request.data = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + transaction.toXMLString();
			request.method =  URLRequestMethod.POST;			
			request.contentType = "text/xml; charset=utf-8"
			request.requestHeaders.push(new URLRequestHeader("Content-Encoding", "UTF-8"));						
			doTransactionRequest.load(request);		
			
			var doGUIConfigRequest:URLLoader = new URLLoader();
			doGUIConfigRequest.addEventListener(IOErrorEvent.IO_ERROR, function():void {
				dispatchEvent(new Event("ioError"));
			});
	
				
		}
		
		public function hasChanges():Boolean {
			return (XMLList(contextProps.source.Context.(@status != "existing"))
				.length() > 0 || 
				XMLList(serverProps.source.Server.(@status != "existing"))
				.length() > 0 ||
				XMLList(layerProps.source.Layer.(@status != "existing"))
				.length() > 0 ||
				XMLList(mapProps.source.Map.(@status != "existing"))
				.length() > 0 ||
				XMLList(templateProps.source.Template.(@status != "existing"))
				.length() > 0 ||
				XMLList(reportProps.source.Report.(@status != "existing"))
				.length() > 0);
		}
		
		/*public function addCollectionsEventListener(listener:Function):void
		{
						
		}*/
		
		private var clientCapabilities:Object = new Object();
		private var serverCapabilities:Object = new Object();
		
		private function doGetCapabilitiesRequest(server:XML, retServer:Server):void {
			var serverProps:XML = getProps(server)[0];
			
			var service:HTTPService = new HTTPService();
			service.url = getCapabilitiesUrl(serverProps, retServer); 
			service.resultFormat = "e4x";		
			service.addEventListener(FaultEvent.FAULT, function(event:FaultEvent):void {
				Alert.show(event.toString());
			});
			service.addEventListener(ResultEvent.RESULT, function():void {
				var result:XMLList = XMLList(service.lastResult);
				var serviceType:String = serverProps.Service.toString();
				
				retServer.capabilities.source = result;
				retServer.layers.source = getServerLayersFromResponse(
					result, serviceType);
				if(serviceType == "OGC:WFS") {
					retServer.featureTypes.source = result.FeatureTypeList.FeatureType.copy();					
					for each(var type:XML in result.FeatureTypeList.FeatureType) {
						var name:String = type.Name;
						var uri:String = null;
						if(name.indexOf(":") != -1) {
							var prefix:String = name.split(":")[0];
							name = name.split(":")[1];
							uri = type.namespace(prefix);
						}					
						
						var list:XMLListCollection = 
							retServer.getFeatureTypeAttributes(new QName(uri, name));
						doDescribeFeatureRequest(serverProps, uri, name, list);
					}				
				} else if(serviceType == "GI") {
					retServer.featureTypes.source = result.FeatureTypesLocalWFSClient.FeatureType.copy();
					for each(type in result.FeatureTypesLocalWFSClient.FeatureType) {
						name = type.toString();
						uri = null;
						if(name.indexOf(":") != -1) {
							prefix = name.split(":")[0];
							name = name.split(":")[1];
							uri = type.namespace(prefix);
						}					
						
						list = 
							retServer.getFeatureTypeAttributes(new QName(uri, name));
						doDescribeFeatureRequest(serverProps, uri, name, list);
					}
				}
				
				retServer.featureTypesEmptyItem.source = 
					<FeatureType><Name/></FeatureType> + retServer.featureTypes.source.copy();								
				
				if(serviceType == "GI") {
					for each(var layer:XML in retServer.capabilities.source.Layer) {
						name = layer.FeatureType;
						uri = null;
						if(name.indexOf(":") != -1) {
							prefix = name.split(":")[0];
							name = name.split(":")[1];
							uri = layer.FeatureType.namespace(prefix);
						}
						list = retServer.getLayerFeatureTypeAttributes(layer.Name.toString());
						doDescribeFeatureRequest(serverProps, uri, name, list);
						
						retServer.layerFeatureTypes[layer.Name] = layer.FeatureType[0];
					}
				}
			});
			service.send();		
		}
		
		private function getCapabilities(server:XML, forceLoad:Boolean = false):Server {
			if(server == null || server.attribute("id").length() == 0 ||
				server.attribute("clientId").length() == 0) {
				return new Server();		
			}
			
			var serverProps:XML = getProps(server);
			if(serverProps.@brief == 'true') {
				return new Server();
			}
			
			var clientId:Boolean = server.@clientId == "true";			
			
			var retServer:Server;
			if(!forceLoad) {
				 retServer = clientId ? 
					clientCapabilities["" + server.@id] :
					serverCapabilities["" + server.@id];
					
				if(retServer != null) {
					return retServer;
				}
			}
			
			retServer = new Server();
			if(clientId) {
				clientCapabilities["" + server.@id] = retServer;
			} else {
				serverCapabilities["" + server.@id] = retServer;
			}
			
			
			
			if(serverProps.child("Security").length() > 0
				&& serverProps.Security != "none" 
					&& XML(serverProps.Security[0]).children().length() != 0) {
					
				var serverLoginPanel:ServerLoginPanel = new ServerLoginPanel();				
				PopUpManager.addPopUp(serverLoginPanel, DisplayObject(Application.application), true);
				BindingUtils.bindProperty(serverLoginPanel, "maxHeight", Application.application, "height");
				BindingUtils.bindProperty(serverLoginPanel, "maxWidth", Application.application, "width");							
				BindingUtils.bindSetter(function():void {
					PopUpManager.centerPopUp(serverLoginPanel);
				}, mx.core.Application.application, "height");
				BindingUtils.bindSetter(function():void {
					PopUpManager.centerPopUp(serverLoginPanel);
				}, mx.core.Application.application, "width");
				PopUpManager.centerPopUp(serverLoginPanel);
				serverLoginPanel.loginHeading = serverProps.Title;
				serverLoginPanel.addEventListener(LoginEvent.LOGIN, 
				function(event:LoginEvent):void {
					PopUpManager.removePopUp(serverLoginPanel);
					retServer.user = event.login;
					retServer.password = event.password;
					doGetCapabilitiesRequest(serverProps, retServer);				
				});
			} else {
				doGetCapabilitiesRequest(serverProps, retServer);
			}
			
			return retServer;
		}
		
		public function getServerLayers(server:XML, forceLoad:Boolean = false):XMLListCollection {
			return getCapabilities(server, forceLoad).layers;
		}
		
		public function getFeatureTypes(server:XML, forceLoad:Boolean = false, emptyItem:Boolean = true):XMLListCollection {
			if(emptyItem) {
				return getCapabilities(server, forceLoad).featureTypesEmptyItem;				
			} else {
				return getCapabilities(server, forceLoad).featureTypes;
			}			
		}
		
		public function getFeatureTypeAttributes(server:XML, featureType:XML, forceLoad:Boolean = false):XMLListCollection {
			if(featureType == null || server == null) {
				return null;
			}
			
			var serverProps:XML = getProps(server)[0];									
			var name:String = null; 
			if(serverProps.Service == "OGC:WFS") {
				name = featureType.Name;
			} else if(serverProps.Service == "GI") {
				name = featureType.children()[0];
			}
			var uri:String = null;
			if(name.indexOf(":") != -1) {
				uri = featureType.namespace(name.split(":")[0]);
				name = name.split(":")[1];
			}			
			
			var serverObj:Server = getCapabilities(server, forceLoad);
			return serverObj.getFeatureTypeAttributes(new QName(uri, name), forceLoad);
		}
		
		private function getCapabilitiesUrl(server:XML, retServer:Server):String {
			var url:String = "";
			
			switch(server.Service.toString()) {
				case "GI":			
					url = server.Onlineresource.toString() + "request=GetCapabilities";
					break;
				case "OGC:WMS":
					url = server.Onlineresource.toString() + "service=WMS&request=GetCapabilities&version=" + server.Version.toString();
					break;
				case "OGC:WFS":
					url = server.Onlineresource.toString() + "service=WFS&request=GetCapabilities&version=" + server.Version.toString();
			}
			
			if(server.child("Proxy").length() > 0
				&& server.Proxy.toString() == "t") {
				
				url = this._proxyServerUrl + "/" 
					+ url.split("//")[1];
			}
			
			if(server.child("Security").length() > 0) {
				switch(server.Security.toString()) {
					case "ows":
						url += "&user=" + retServer.user + "&password=" + retServer.password;				
				}	
			}		
			
			return url;
		}
		
		private function removeNameless(layers:XMLList):XMLList {
			return layers.(child("Name").length() > 0);
		}
		
		private function flattenLayerList(rootLayer:XML):XMLList {
			var list:XMLList = new XMLList(<Root/>);
			XML(list[0]).appendChild(rootLayer.copy()[0]);
			var subLayers:XMLList =  rootLayer.Layer.copy();
			delete list.Layer.Layer;
			for each(var layer:XML in subLayers) {
				for each(var subLayer:XML in flattenLayerList(layer)) {
					XML(list[0]).appendChild(subLayer);
				}					
			}
			return list.children();
		}
		
		private function getServerLayersFromResponse(serverResponse:XMLList, service:String):XMLList {
			switch(service) {
				case "GI":
					return serverResponse.Layer;
				case "OGC:WMS":
					return removeNameless(
						flattenLayerList(serverResponse.Capability.Layer[0]));
			}
			
			return null;
		}
		
		private function getFeatureTypeNamesFromResponse(serverResponse:XMLList, server:XML):Array {
			var names:Array = new Array();
			var serviceType:String = server.Service;
			if(serviceType == "OGC:WFS") {
				for each(var type:XML in serverResponse.FeatureTypeList.FeatureType) {
					var name:String = type.Name;
					var uri:String = null;
					if(name.indexOf(":") != -1) {
						var prefix:String = name.split(":")[0];
						name = name.split(":")[1];
						uri = type.namespace(prefix);
					}					
					
					var list:XMLListCollection = new XMLListCollection();
					doDescribeFeatureRequest(server, uri, name, list);			
					
					names.push([new QName(uri, name), list]);
				}
			} else if(serviceType == "GI") {
				
			}
			return names;
		}
		
		private function doDescribeFeatureRequest(server:XML, uri:String, name:String, list:XMLListCollection):void {
			var service:HTTPService = new HTTPService();
			service.url = server.Onlineresource.toString() + "service=WFS&version=1.1.0&request=DescribeFeatureType"
				+ "&typeName=" + (uri ? "pref:" : "") + name;
			if(uri != null) { 
				service.url += "&namespace=xmlns(" +
					"pref=" + uri + ")";
			}
			service.resultFormat = "e4x";
			service.addEventListener(ResultEvent.RESULT, function(event:ResultEvent):void
			{				
				var result:XMLList = XMLList(service.lastResult);				
				var typeName:String = result.element.(@name == name).@type;
				var prefix:String = "";
				var nspace:String = "";
				if(typeName.indexOf(":") != -1) {
					var parts:Array = typeName.split(":");
					if(result.namespace(parts[0]) == result.@targetNamespace) {
						typeName = parts[1];
					}
					prefix = parts[0];
					nspace = parts[1];
				}
				var complexType:XMLList = result.complexType.(@name == typeName);
				var elements:XMLList = new XMLList(<elements/>);
				elements.elements += complexType..element;
				elements.@prefix = prefix;
				elements.@nspace = nspace;
				list.source = elements.element;
			});
			service.send();	
		}
		
		public function getLayerFeatureTypeAttributes(server:XML, layer:QName, forceLoad:Boolean = false):XMLListCollection {
			if(server.Service.toString() == "OGC:WFS") {
				return getCapabilities(server, forceLoad).getFeatureTypeAttributes(layer, forceLoad);
			} else {
				return getCapabilities(server, forceLoad).getLayerFeatureTypeAttributes(layer.localName);
			}			
		}
		
		public function getFeatureTypeForQueryLayer(layer:XML, server:XML, forceLoad:Boolean = false):XML {
			var serverProps:XML = getProps(server)[0];
			
			if(serverProps.Service == "OGC:WFS") {
				return layer;
			} else if(serverProps.Service == "GI") {
				return getCapabilities(server, forceLoad).layerFeatureTypes[layer.Name];				
			}
			
			return null;
		}
		
		public function getQueryLayers(server:XML, forceLoad:Boolean = false):XMLListCollection {
			if(server == null) {
				return null;
			}
			
			var serverProps:XML = getProps(server)[0];
			if(serverProps.Service == "GI") {
				return getServerLayers(server, forceLoad);
			} else if(serverProps.Service == "OGC:WFS") {
				return getFeatureTypes(server, forceLoad, false);
			}
			
			return null;
		}
		
		private function getServerVersion(version:XMLList, position:Number):Number {
			var str:String = version.toString();
			var index:Number = -1;
			for(var i:Number = 0; i < position; i++) {
				index = str.indexOf(".", index + 1);				
			}

			var end:Number = str.indexOf(".", index + 1);
			if(end == -1) {
				str = str.substr(index + 1);
			} else {
				str = str.substring(index + 1, end);
			}
			
			return Number(str);
		}
		
		public function getTransformationServers():XMLList {			
			return serverProps.source.(Service == "GI")
				.(getServerVersion(Version, 0) == 3);						
		}
		
		public function getMapServers():XMLList {			
			return serverProps.source
				.(Service == "GI" 
				|| Service == "OGC:WMS");			
		}
		
		public function getQueryServers(omitWfs:Boolean = false):XMLList {			
			return serverProps.source
				.(Service == "GI" 
				|| (Service == "OGC:WFS" && !omitWfs));
		}
		
		public function getFeatureServers():XMLList {
			return serverProps.source
				.(Service == "OGC:WFS");
		}
		
		public function supportsFormats(server:XML):Boolean {
			return getProps(server).Service == "OGC:WMS";
		}
		
		public function supportsSelections(server:XML):Boolean {
			return getProps(server).Service == "GI";
		}
		
		public function isUnique(type:String, name:String, newElement:Boolean = false):Boolean {
			var count:Number = newElement ? 0 : 1;
			
			switch(type) 
			{
				case 'Context':
					return XMLList(contextProps.source.(Name == name)).length() == count;
					break;
				case 'Layer':
					return XMLList(layerProps.source.(Name == name)).length() == count;
					break;
				case 'QueryAspect':
					return XMLList(queryAspectProps.source.(Name == name)).length() == count;
					break;
				case 'Template':
					return XMLList(templateProps.source.(Name == name)).length() == count;
					break	
				case 'Map':
					return XMLList(mapProps.source.(Name == name)).length() == count;
			}
			
			return true;
		}
		
		public function getUnusedLayers(map:XML):XMLList {
			var list:XMLList = layerProps.source.copy();
			var usedLayers:XMLList = this.getLayers(map).copy();
			
			for(var i:Number = 0; i < list.length(); i++) {
				for each(var currentLayer:XML in usedLayers) { 					
					if(currentLayer.@clientId == list[i].@clientId 
						&& currentLayer.@id == list[i].@id) {
						delete list[i];
						i--;
					}
				}
			} 
			return list;
		}
		
		public function getUnusedMaps(context:XML):XMLList {
			var list:XMLList = mapProps.source.copy();
			var usedMaps:XMLList = this.getMaps(context).copy();
			
			for(var i:Number = 0; i < list.length(); i++) {
				for each(var currentMap:XML in usedMaps) {					
					if(currentMap.@clientId == list[i].@clientId 
						&& currentMap.@id == list[i].@id) {
						delete list[i];
						i--;						
					}
				}
			}
			
			return list;
		}
		
		public function getUnusedQueryAspects(map:XML):XMLList {
			var list:XMLList = queryAspectProps.source.copy();			
			var usedQueryAspects:XMLList = this.getQueryAspects(map).copy();
			
			for(var i:Number = 0; i < list.length(); i++) {
				for each(var currentQueryAspect:XML in usedQueryAspects) {
					if(currentQueryAspect.@clientId == list[i].@clientId 
						&& currentQueryAspect.@id == list[i].@id) {
						delete list[i];
						i--;
					}
				}
			}
			
			return list;
		}
		
		public function getUnusedTemplates(map:XML):XMLList {
			var list:XMLList = templateProps.source.copy();			
			var usedTemplates:XMLList = this.getTemplates(map).copy();
			
			for(var i:Number = 0; i < list.length(); i++) {
				for each(var currentTemplate:XML in usedTemplates) {
					if(currentTemplate.@clientId == list[i].@clientId 
						&& currentTemplate.@id == list[i].@id) {
						delete list[i];
						i--;
					}
				}
			}
			
			return list;
		}
		
		
		public function dropServerCache(server:XML):void {
			var clientId:Boolean = false;
			if(server.child("@clientId").length() > 0) {
				clientId = server.@clientId == "true";
			} 	
			
			if(clientId) {
				clientCapabilities["" + server.@id] = null;
			} else {
				serverCapabilities["" + server.@id] = null;
			}
			
			//dispatchEvent(new Event("serverCacheDropped"));
		}
		
		public function isServerUsed(server:XML):Boolean {
			if(server.localName() != "Server") {
				return false;
			}
			
			var clientId:Boolean = false;
			if(server.attribute("clientId").length() > 0) {
				clientId = server.@clientId.toString().toLowerCase() == "true";
			}						
			
			for each(var currentServer:XML in layerProps.source..Server) {
				var currentClientId:Boolean = false;
				if(currentServer.attribute("clientId").length() > 0) {
					currentClientId = currentServer.@clientId.toString().toLowerCase() == "true";
				}
				
				if(currentClientId == clientId 
					&& currentServer.@id == server.@id) {
					return true;		
				} 
			}
			
			for each(currentServer in layerProps.source..Featureserver) {
				currentClientId = false;
				if(currentServer.attribute("clientId").length() > 0) {
					currentClientId = currentServer.@clientId.toString().toLowerCase() == "true";
				}
				
				if(currentClientId == clientId 
					&& currentServer.@id == server.@id) {
					return true;		
				} 
			}
			
			for each(currentServer in queryAspectProps.source..Server) {
				currentClientId = false;
				if(currentServer.attribute("clientId").length() > 0) {
					currentClientId = currentServer.@clientId.toString().toLowerCase() == "true";
				}
				
				if(currentClientId == clientId 
					&& currentServer.@id == server.@id) {
					return true;		
				} 
			}
			
			for each(currentServer in contextProps.source..Server) {
				currentClientId = false;
				if(currentServer.attribute("clientId").length() > 0) {
					currentClientId = currentServer.@clientId.toString().toLowerCase() == "true";
				}
				
				if(currentClientId == clientId 
					&& currentServer.@id == server.@id) {
					return true;		
				} 
			}
			
			return false;
		}
		
		public function treeToProps(tree:XML, disableListeners:Boolean = false):void {
			// Disable listeners
			if(disableListeners) {
				removeListeners();
			}
			
			if(tree.localName() == "Contexts") {
				for each(var map:XML in tree..Map) {
					var currentRef:XML = newRef(map);					 
					if(map != currentRef) {						
						var props:XML = getProps(map);
						
						var mapLayerChilds:XMLList = new XMLList();
						for each(var mapLayer:XML in map.Layers.Layer) {
							mapLayerChilds += newRef(mapLayer, false);
						}
												
						XML(props.Layers[0]).setChildren(mapLayerChilds);
						// TODO: drag and drop between maps allowed??
						/*XML(props.Templates[0]).setChildren(map.Templates.Template);
						XML(props.QueryAspects[0]).setChildren(map.QueryAspects.QueryAspect);
						XML(props.Reports[0]).setChildren(map.Reports.Report);*/
						
						for each(var layer:XML in map.Layers..Layer.(getProps(copy()).Type.toString() == "Group")) {
							var layerProps:XML = getProps(layer);
							var layerChilds:XMLList = new XMLList();
							for each(var subLayer:XML in layer.children()) {
								layerChilds += newRef(subLayer, false);
							}
							if(layerChilds != layerProps.Layers.Layer) {
								XML(layerProps.Layers[0]).setChildren(layerChilds);
								
								if(layerProps.@status != "new") {
									layerProps.@status = "changed";
								}
							}
						}
						
						if(props.@status != "new") {
							props.@status = "changed";
						}
					}
				}
			}
			
			// Re enable listeners
			if(disableListeners) {
				addListeners();
			}
		}
		
		// Copy content of contextTree to entities (used for dragging)
		public function updateEntity(item:XML, disableListeners:Boolean = false):void {
			// Disable listeners
			if(disableListeners) {
				removeListeners();
			}
			
			var groupName:String = item.localName();
			if(groupName == "Layer") {
				groupName = "Layers";
			}
			
			var items:XMLList = new XMLList();
			for each(var currentItem:XML in item.children()) {
				items += newRef(currentItem, false);
			} 
			
			var parentNode:XML = getParentEntity(item);
			if(parentNode != null) {
				XML(parentNode.child(groupName)).setChildren(items);
				if(parentNode.@status != "new") {
					parentNode.@status = "changed";
				}
			}
			
			// Re enable listeners
			if(disableListeners) {
				addListeners();
			}
		}
	}
}