/**
 * @author copierrj
 */
import nl.idgis.giclient.template.TemplateElement;
import nl.idgis.giclient.template.BorderElement;
import nl.idgis.giclient.template.PrintInstruction;
import nl.idgis.giclient.util.XMLTools;
import nl.idgis.giclient.template.Page;
import nl.idgis.giclient.template.MapElement;
import nl.idgis.giclient.template.ParameterSource;
import nl.idgis.giclient.template.Viewer;
import nl.idgis.giclient.template.Parameter;
import nl.idgis.giclient.gis.GIS;
import nl.idgis.giclient.template.Parameterable;
import nl.idgis.giclient.template.LabelElement;
import nl.idgis.giclient.template.ImageElement;
import nl.idgis.giclient.template.GeometryElement;
import nl.idgis.giclient.template.TemplateDesc;
import nl.idgis.giclient.template.Util;
import nl.idgis.giclient.gis.Layer;
import nl.idgis.giclient.geoma.GMLFactory;
import nl.idgis.giclient.geoma.Geometry;
import nl.idgis.giclient.template.Dialog;
import nl.idgis.giclient.template.StandardDialog;
import nl.idgis.giclient.template.ScaleBarElement;
import nl.idgis.giclient.template.ReportRef;
import nl.idgis.giclient.template.WindowElement;
import nl.idgis.giclient.template.ResourceRef;
 
class nl.idgis.giclient.template.TemplateFactory {
	private var gis:GIS;
	private var viewer:ParameterSource;
	private var util:ParameterSource;
	private var language:String;
	
	public function TemplateFactory(gis:GIS, language:String) {
		this.gis = gis;
		viewer = new Viewer(gis);
		util = new Util(gis);
		this.language = language;
	}
	
	private function parsePage(pageNode:XMLNode, printInstruction:PrintInstruction, dialog:ParameterSource):Page {
		var marginNode = XMLTools.getChild("Margin", pageNode);				
		var page:Page = new Page(XMLTools.getNumberValue("Top", marginNode),
			XMLTools.getNumberValue("Bottom", marginNode),
			XMLTools.getNumberValue("Left", marginNode),
			XMLTools.getNumberValue("Right", marginNode));
		
		var elementsNode:XMLNode = XMLTools.getChild("Elements", pageNode);
		if(elementsNode != null) {
			var elements:Array = XMLTools.getChildNodes("Element", elementsNode);
			for(var j:Number = 0; j < elements.length; j++) {
				var elementNode:XMLNode = XMLNode(elements[j]);
				var parametersNode:XMLNode = XMLTools.getChild("Parameters", elementNode);
				if(parametersNode != null) {							
					var parameters:Array = XMLTools.getChildNodes("Parameter", parametersNode);
					
					var element:TemplateElement = 
						createElement(XMLTools.getStringValue("type", elementNode));
					page.addElement(element);
					
					for(var k:Number = 0; k < parameters.length; k++) {
						var currentParameter:XMLNode = XMLNode(parameters[k]);						
						var type:String = XMLTools.getStringValue("type", currentParameter);
														
						if(type == "const") {
							setConst(currentParameter, element);
						} else {
							var parameter:Parameter = createParameter(currentParameter, element, dialog);
							if(parameter != null) { 
								element.addDynamicParameter(parameter);
							}						
						}
					}								
				}
			}
		}
					
		return page;
	}
	
	private function parseDialog(dialogNode:XMLNode):Dialog {
		var type:String = XMLTools.getStringValue("Type", dialogNode);
		var dialog:Dialog = createDialog(type);
		
		var parametersNode:XMLNode = XMLTools.getChild("Parameters", dialogNode);
		if(parametersNode != null) {
			var parameters:Array = XMLTools.getChildNodes("Parameter", parametersNode);
		
			for(var i:Number = 0; i < parameters.length; i++) {
				var currentParameter:XMLNode = XMLNode(parameters[i]);						
				var parameterType:String = XMLTools.getStringValue("type", currentParameter);
												
				if(parameterType == "const") {
					setConst(currentParameter, dialog);
				} else {
					var parameter:Parameter = createParameter(currentParameter, dialog);
					if(parameter != null) { 
						parameter.execute();
					}						
				}
			}	
		}	
		
		return dialog;
	}
	
	private function parseParameters(resourceRef:ResourceRef, requestNode:XMLNode, dialog:Dialog):Void {
		var parametersNode:XMLNode = XMLTools.getChild("Parameters", requestNode);
		var parameters:Array = XMLTools.getChildNodes("Parameter", parametersNode);
		
		for(var i:Number = 0; i < parameters.length; i++) {
			var currentParameter:XMLNode = XMLNode(parameters[i]);
			var type:String = XMLTools.getStringValue("type", currentParameter);
											
			if(type == "const") {
				setConst(currentParameter, resourceRef);
			} else {
				var parameter:Parameter = createParameter(currentParameter, resourceRef, dialog);
				if(parameter != null) { 
					resourceRef.addDymanicParameter(parameter);
				}						
			}
		}
	}
	
	public function parseReportRef(reportRefNode:XMLNode):ReportRef {
		var titleNode:XMLNode = XMLTools.getChild("Title", reportRefNode);
		var title:String = XMLTools.getStringValue(language, titleNode);
		
		var requestNode:XMLNode = XMLTools.getChild("Request", reportRefNode);
		var url:String = XMLTools.getStringValue("Url", requestNode);
		
		var dialogNode:XMLNode = XMLTools.getChild("Dialog", reportRefNode);
		var dialog:Dialog = null;
		if(dialogNode != null) {
			dialog = parseDialog(dialogNode);
		}
		
		var reportRef:ReportRef = new ReportRef(url, dialog, title);
		
		parseParameters(reportRef, requestNode, dialog);
		
		return reportRef;
	}
	
	public function parseTemplateDesc(templateDescNode:XMLNode):TemplateDesc {
		var name:String = XMLTools.getStringValue("Name", templateDescNode);
		var titleNode:XMLNode = XMLTools.getChild("Title", templateDescNode);
		var title:String = XMLTools.getStringValue(language, titleNode);
		var format:String = XMLTools.getStringValue("Format", templateDescNode);
		var orientation:String = XMLTools.getStringValue("Orientation", templateDescNode);
				
		var requestNode:XMLNode = XMLTools.getChild("Request", templateDescNode);
		var url:String = XMLTools.getStringValue("Url", requestNode);
		
		var dialogNode:XMLNode = XMLTools.getChild("Dialog", templateDescNode);
		var dialog:Dialog = null;
		if(dialogNode != null) {
			dialog = parseDialog(dialogNode);
		}
		
		var templateDesc:TemplateDesc = new TemplateDesc(name, title, format, orientation, 
			url, dialog);	
			
		parseParameters(templateDesc, requestNode, dialog);
				
		return templateDesc;		
	}
	
	public function parsePrintInstruction(templateNode:XMLNode, dialog:ParameterSource):PrintInstruction {
		var printInstruction:PrintInstruction = new PrintInstruction();
		
		var pagesNode:XMLNode = XMLTools.getChild("Pages", templateNode);
		if(pagesNode != null) {
			var pages:Array = XMLTools.getChildNodes("Page", pagesNode);
			for(var i:Number = 0; i < pages.length; i++) {
				printInstruction.addPage(parsePage(XMLNode(pages[i]), printInstruction, dialog));				
			}
		}
		
		return printInstruction;
	}
	
	private function parseComplexValue(complexValue:XMLNode):Object {
		if(complexValue.localName == "Array") {
			var items:Array = new Array();
			for(var i:Number = 0; i < complexValue.childNodes.length; i++) {
				var item:Object = parseComplexValue(XMLNode(complexValue.childNodes[i]));
				if(item != null) {
					items.push(item);
				}
			}								
			return items;
		} else if(complexValue.localName == "String") {
			return complexValue.firstChild.toString();
		} else if(complexValue.localName == "Layer") {
			return gis.getLayer(complexValue.firstChild.toString());
		} else if(complexValue.localName == "Geometry") {
			var geom:Geometry = GMLFactory.parseGML(complexValue.firstChild);
			return geom;
		} else { //TODO: Additional complex types
			return null;
		}		
	}

	public function setConst(parameter:XMLNode, parameterable:Parameterable):Void {
		var name:String = XMLTools.getStringValue("name", parameter);
		
		if(parameter.childNodes.length == 0) {			
			parameterable.setParameter(name, "");
			return;
		} 
		
		if(parameter.firstChild.nodeType == 3) {			
			parameterable.setParameter(name, parameter.firstChild.toString());										
		} else {		
			parameterable.setParameter(name, parseComplexValue(parameter.firstChild));
		}
	}
	
	public function createParameter(parameterNode:XMLNode, appliedTo:Parameterable, dialog:ParameterSource):Parameter {
		var type:String = XMLTools.getStringValue("type", parameterNode);
		var name:String = XMLTools.getStringValue("name", parameterNode);
		var sourceName:String = XMLTools.getStringValue("source", parameterNode);		
		var source:ParameterSource = getParameterSource(type, 
			XMLTools.getStringValue("element", parameterNode), dialog);
		var parameter:Parameter = new Parameter(name, appliedTo, source, sourceName);
		var subParameters:Array = XMLTools.getChildNodes("Parameter", parameterNode);
		for(var i:Number = 0; i < subParameters.length; i++) {
			var currentSubParameter:XMLNode = XMLNode(subParameters[i]);
			var subType:String = XMLTools.getStringValue("type", currentSubParameter);
			if(subType == "const") {
				setConst(currentSubParameter, parameter);
			} else {
				parameter.addSubParameter(createParameter(currentSubParameter, parameter, dialog));
			}
		}	
		return parameter;
	}
	
	public function createDialog(type:String):Dialog {
		if(type == "standard") {
			return new StandardDialog(gis);
		} else {		
			return null;
		}
	}
	
	public function createElement(type:String):TemplateElement {
		if(type == "border") {
			return new BorderElement(gis);
		} else if(type == "map") {
			return new MapElement(gis);
		} else if(type == "label") {
			return new LabelElement(gis);
		} else if(type == "image") {
			return new ImageElement(gis);
		} else if(type == "geometry") {
			return new GeometryElement(gis);
		} else if(type == "scaleBar") {
			return new ScaleBarElement(gis);
		} else if(type == "window") {
			return new WindowElement(gis);
		} else {
			return null;
		}
	}
	
	public function getParameterSource(type:String, element:String, dialog:ParameterSource):ParameterSource {
		if(type == "viewer") {
			return viewer;		 
		} else if(type == "util") {
			return util;
		} else if(type == "dialog") {
			return dialog;
		}
		 
		return null;
	}
}