package data
{
	import mx.collections.XMLListCollection;
	import mx.rpc.events.FaultEvent;
	import mx.rpc.events.ResultEvent;
	import mx.rpc.http.HTTPService;
	import mx.controls.Alert;
	import data.DataSource;
	
	public class ServerInfo
	{
		namespace wfs = "http://www.opengis.net/wfs";
		namespace xsd = "http://www.w3.org/2001/XMLSchema";
		use namespace wfs;
		use namespace xsd;
		
		public var dataSource:DataSource;
		
		private var clientCapabilities:Object = new Object();
		private var serverCapabilities:Object = new Object();
			
		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 = dataSource.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;
			}
			
			doGetCapabilitiesRequest(serverProps, retServer);
			
			return retServer;
		}
		
		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 = dataSource.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 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();	
		}
		
		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 doGetCapabilitiesRequest(server:XML, retServer:Server):void {
			var serverProps:XML = dataSource.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();		
		}
		
		public function getServerLayers(server:XML, forceLoad:Boolean = false):XMLListCollection {
			return getCapabilities(server, forceLoad).layers;
		}
		
		public function getFeatureTypeAttributes(server:XML, featureType:XML, forceLoad:Boolean = false):XMLListCollection {
			if(featureType == null || server == null) {
				return null;
			}
			
			var serverProps:XML = dataSource.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);
		}
		
		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;
			}			
		}
	}
}