/**
 * Copyright (c) 2011 Forschungszentrum Juelich GmbH
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 * 		Carsten Karbach, FZ Juelich
 */

package org.eclipse.ptp.rm.lml.internal.core.nodedisplay;

import java.net.URL;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;

import javax.xml.XMLConstants;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBElement;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;

import org.eclipse.ptp.rm.lml.internal.core.elements.DataElement;
import org.eclipse.ptp.rm.lml.internal.core.elements.DataElement1;
import org.eclipse.ptp.rm.lml.internal.core.elements.DataElement2;
import org.eclipse.ptp.rm.lml.internal.core.elements.DataElement3;
import org.eclipse.ptp.rm.lml.internal.core.elements.DataElement4;
import org.eclipse.ptp.rm.lml.internal.core.elements.DataElement5;
import org.eclipse.ptp.rm.lml.internal.core.elements.DataElement6;
import org.eclipse.ptp.rm.lml.internal.core.elements.DataElement7;
import org.eclipse.ptp.rm.lml.internal.core.elements.DataElement8;
import org.eclipse.ptp.rm.lml.internal.core.elements.DataElement9;
import org.eclipse.ptp.rm.lml.internal.core.elements.DataType;
import org.eclipse.ptp.rm.lml.internal.core.elements.GobjectType;
import org.eclipse.ptp.rm.lml.internal.core.elements.LayoutType;
import org.eclipse.ptp.rm.lml.internal.core.elements.LguiType;
import org.eclipse.ptp.rm.lml.internal.core.elements.Nodedisplay;
import org.eclipse.ptp.rm.lml.internal.core.elements.Nodedisplayelement;
import org.eclipse.ptp.rm.lml.internal.core.elements.Nodedisplayelement0;
import org.eclipse.ptp.rm.lml.internal.core.elements.Nodedisplayelement1;
import org.eclipse.ptp.rm.lml.internal.core.elements.Nodedisplayelement2;
import org.eclipse.ptp.rm.lml.internal.core.elements.Nodedisplayelement3;
import org.eclipse.ptp.rm.lml.internal.core.elements.Nodedisplayelement4;
import org.eclipse.ptp.rm.lml.internal.core.elements.Nodedisplayelement5;
import org.eclipse.ptp.rm.lml.internal.core.elements.Nodedisplayelement6;
import org.eclipse.ptp.rm.lml.internal.core.elements.Nodedisplayelement7;
import org.eclipse.ptp.rm.lml.internal.core.elements.Nodedisplayelement8;
import org.eclipse.ptp.rm.lml.internal.core.elements.Nodedisplayelement9;
import org.eclipse.ptp.rm.lml.internal.core.elements.NodedisplaylayoutType;
import org.eclipse.ptp.rm.lml.internal.core.elements.ObjectsType;
import org.eclipse.ptp.rm.lml.internal.core.elements.SchemeElement;
import org.eclipse.ptp.rm.lml.internal.core.elements.SchemeElement1;
import org.eclipse.ptp.rm.lml.internal.core.elements.SchemeElement2;
import org.eclipse.ptp.rm.lml.internal.core.elements.SchemeElement3;
import org.eclipse.ptp.rm.lml.internal.core.elements.SchemeElement4;
import org.eclipse.ptp.rm.lml.internal.core.elements.SchemeElement5;
import org.eclipse.ptp.rm.lml.internal.core.elements.SchemeElement6;
import org.eclipse.ptp.rm.lml.internal.core.elements.SchemeElement7;
import org.eclipse.ptp.rm.lml.internal.core.elements.SchemeElement8;
import org.eclipse.ptp.rm.lml.internal.core.elements.SchemeElement9;
import org.eclipse.ptp.rm.lml.internal.core.elements.SchemeType;
import org.xml.sax.SAXException;

/**
 * This class is a copy of LMLCheck out of a lml-checking-tool
 * only function checkImplicitNames is missing
 * 
 * This class supports several view-classes by navigating through the nodedisplays
 * @author Carsten Karbach, FZ Juelich
 *
 */
public class LMLCheck {
	
	
	/**
	 * @return Object of LguiType parsed out of an lml-File
	 * @throws JAXBException
	 */
	public static LguiType parseLML(URL xml, URL xsd) throws JAXBException {
		//Causes errors while used in applet
		
		JAXBContext jc = JAXBContext.newInstance("lml");
		
		Unmarshaller unmar = jc.createUnmarshaller();

		
		if(xsd!=null){
			Schema mySchema;
			SchemaFactory sf =
				SchemaFactory.newInstance( XMLConstants.W3C_XML_SCHEMA_NS_URI );
			try {
				mySchema = sf.newSchema(xsd);
			} catch( SAXException saxe ){
				// ...(error handling)
				mySchema = null;
			}

			//Connect schema to unmarshaller
			unmar.setSchema(mySchema);
		}
		
		//Validate lml-file and unmarshall in one step
		JAXBElement<LguiType> doc = (JAXBElement<LguiType>) unmar.unmarshal( xml);
		//Get root-element
		LguiType lml = doc.getValue();
		
		return lml;
	}
	
	/**
	 * get all objects-Tags
	 * @param model
	 * @return
	 */
	public static List<ObjectsType> getObjects(LguiType model) {
		
		List<JAXBElement<?>> all = model.getObjectsAndRelationsAndInformation();
		
		List<ObjectsType> objects = new ArrayList<ObjectsType>();
		
		for (JAXBElement<?> aobj: all) {
			if (aobj.getValue() instanceof ObjectsType) {
				objects.add((ObjectsType) aobj.getValue());
			}
		}
		
		return objects;	
		
	}
	
	/**
	 * Get all Layout-Definitions out of the lml-file
	 * @param pmodell
	 * @return
	 */
	public static List<LayoutType> getLayouts(LguiType pmodell) {
		
		List<JAXBElement<?>> all = pmodell.getObjectsAndRelationsAndInformation();
		
		List<LayoutType> layouts = new ArrayList<LayoutType>();
		
		for (JAXBElement<?> aobj: all) {
			if (aobj.getValue() instanceof LayoutType) {
				layouts.add((LayoutType) aobj.getValue());
			}
		}
		
		return layouts;		
	}
	
	/**
	 * Get all graphical objects out of the lml-file
	 * @param pmodell
	 * @return
	 */
	public static List<GobjectType> getGraphicalObjects(LguiType pmodell)  {
		
		List<JAXBElement<?>> all = pmodell.getObjectsAndRelationsAndInformation();
		
		List<GobjectType> gobj = new ArrayList<GobjectType>();
		
		for (JAXBElement<?> aobj: all) {
			if (aobj.getValue() instanceof GobjectType) {
				gobj.add((GobjectType) aobj.getValue());
			}
		}
		
		return gobj;	
	}
	
	/**
	 * @param el
	 * @return in which level this dataelement is placed, 0 for DataType, 10 for DataElement (unspecific)
	 */
	public static int getDataLevel(Object el) {
		if (el instanceof DataType) {
			return 0;
		}		
		if (el instanceof DataElement1) {
			return 1;
		}
		if (el instanceof DataElement2) {
			return 2;
		}
		if (el instanceof DataElement3) {
			return 3;
		}
		if (el instanceof DataElement4) {
			return 4;
		}
		if (el instanceof DataElement5) {
			return 5;
		}
		if (el instanceof DataElement6) {
			return 6;
		}
		if (el instanceof DataElement7) {
			return 7;
		}
		if (el instanceof DataElement8) {
			return 8;
		}
		if (el instanceof DataElement9) {
			return 9;
		}
		if (el instanceof DataElement) {
			return 10;
		}
		
		return -1;
	}
	
	/**
	 * Returns a List of lower data-elements for a data-element or a dataType-instance
	 * within a data-section of a nodedisplay
	 * 
	 * @param el
	 * @return
	 */
	public static List getLowerDataElements(Object el) {
		
		if (el instanceof DataType) {
			return ((DataType) el).getEl1();
		}		
		if (el instanceof DataElement1) {
			return ((DataElement1)el).getEl2();
		}
		if (el instanceof DataElement2) {
			return ((DataElement2)el).getEl3();
		}
		if (el instanceof DataElement3) {
			return ((DataElement3)el).getEl4();
		}
		if (el instanceof DataElement4) {
			return ((DataElement4)el).getEl5();
		}
		if (el instanceof DataElement5) {
			return ((DataElement5)el).getEl6();
		}
		if (el instanceof DataElement6) {
			return ((DataElement6)el).getEl7();
		}
		if (el instanceof DataElement7) {
			return ((DataElement7)el).getEl8();
		}
		if (el instanceof DataElement8) {
			return ((DataElement8)el).getEl9();
		}
		if (el instanceof DataElement9) {
			return ((DataElement9)el).getEl10();
		}		
		
		return new ArrayList();
	}
	
	/**
	 * @param el
	 * @return in which level this schemeelement is placed, 0 for SchemeType, 10 for SchemeElement (unspecific)
	 */
	public static int getSchemeLevel(Object el){
		
		if (el instanceof SchemeType) {
			return 0;
		}		
		if (el instanceof SchemeElement1) {
			return 1;
		}
		if (el instanceof SchemeElement2) {
			return 2;
		}
		if (el instanceof SchemeElement3) {
			return 3;
		}
		if (el instanceof SchemeElement4) {
			return 4;
		}
		if (el instanceof SchemeElement5) {
			return 5;
		}
		if (el instanceof SchemeElement6) {
			return 6;
		}
		if (el instanceof SchemeElement7) {
			return 7;
		}
		if (el instanceof SchemeElement8) {
			return 8;
		}
		if (el instanceof SchemeElement9) {
			return 9;
		}
		if (el instanceof SchemeElement) {
			return 10;
		}
		
		return -1;
	}
	
	/**
	 * Returns a List of lower scheme elements for a scheme-element or a SchemeType-instance
	 * 
	 * @param el
	 * @return
	 */
	public static List getLowerSchemeElements(Object el) {
		
		if (el instanceof SchemeType) {
			return ((SchemeType) el).getEl1();
		}		
		if (el instanceof SchemeElement1) {
			return ((SchemeElement1)el).getEl2();
		}
		if (el instanceof SchemeElement2) {
			return ((SchemeElement2)el).getEl3();
		}
		if (el instanceof SchemeElement3) {
			return ((SchemeElement3)el).getEl4();
		}
		if (el instanceof SchemeElement4) {
			return ((SchemeElement4)el).getEl5();
		}
		if (el instanceof SchemeElement5) {
			return ((SchemeElement5)el).getEl6();
		}
		if (el instanceof SchemeElement6) {
			return ((SchemeElement6)el).getEl7();
		}
		if (el instanceof SchemeElement7) {
			return ((SchemeElement7)el).getEl8();
		}
		if (el instanceof SchemeElement8) {
			return ((SchemeElement8)el).getEl9();
		}
		if (el instanceof SchemeElement9) {
			return ((SchemeElement9)el).getEl10();
		}		
		
		return new ArrayList();
	}
	
	/**
	 * Returns a List of lower nodedisplayelements for a NodedisplayelementX or a NodedisplaylayoutType
	 * 
	 * @param el
	 * @return
	 */
	public static List getLowerNodedisplayElements(Object el) {
		
		if (el instanceof NodedisplaylayoutType) {
			ArrayList<Nodedisplayelement0> justonelement = new ArrayList<Nodedisplayelement0>();
			justonelement.add( ((NodedisplaylayoutType) el).getEl0() );
			return justonelement;
		}		
		if (el instanceof Nodedisplayelement0) {
			return ((Nodedisplayelement0)el).getEl1();
		}
		if (el instanceof Nodedisplayelement1) {
			return ((Nodedisplayelement1)el).getEl2();
		}
		if (el instanceof Nodedisplayelement2) {
			return ((Nodedisplayelement2)el).getEl3();
		}
		if (el instanceof Nodedisplayelement3) {
			return ((Nodedisplayelement3)el).getEl4();
		}
		if (el instanceof Nodedisplayelement4) {
			return ((Nodedisplayelement4)el).getEl5();
		}
		if (el instanceof Nodedisplayelement5) {
			return ((Nodedisplayelement5)el).getEl6();
		}
		if (el instanceof Nodedisplayelement6) {
			return ((Nodedisplayelement6)el).getEl7();
		}
		if (el instanceof Nodedisplayelement7) {
			return ((Nodedisplayelement7)el).getEl8();
		}
		if (el instanceof Nodedisplayelement8) {
			return ((Nodedisplayelement8)el).getEl9();
		}
		if (el instanceof Nodedisplayelement9) {
			return ((Nodedisplayelement9)el).getEl10();
		}
		
		return new ArrayList();
	}
	
	/**
	 * Returns the height of the scheme-tree given by this schemeEl
	 * @param schemeEl scheme elements or a SchemeType-instance
	 * @return
	 */
	public static int getDeepestSchemeLevel(Object schemeEl) {
		
		if (schemeEl == null) {
			return 0;
		}
		
		List els = getLowerSchemeElements(schemeEl);
		if (els == null) {
			return 1;
		}
		
		int max = 0;
		
		for (int i = 0; i < els.size(); i++) {
			int aheight = getDeepestSchemeLevel(els.get(i));
			
			if (aheight > max) {
				max = aheight;
			}
		}
		
		return max + (schemeEl instanceof SchemeType ? 0: 1);
		
	}
	
	/**
	 * Parses numberlist (for example 1,2,16,2,100) and returns a list of integers like new int[]{1,2,16,2,100}
	 * @param numberlist list of numbers separated by commas
	 * @return integer list
	 */
	public static int[] getNumbersFromNumberlist(String numberlist) {
		
		String[] parts = numberlist.split(",");
		
		int[] res = new int[parts.length];
		
		int i = 0;
		for (String part:parts) {
			res[i++] = Integer.parseInt(part.trim());
		}
		
		return res;		
	}
	
	
	/**
	 * A class which combines a data-element and the defining scheme-element
	 * @author karbach
	 *
	 */
	public static class SchemeAndData {
		
		public DataElement data;
		public SchemeElement scheme;
		
		public SchemeAndData(DataElement pdata, SchemeElement pscheme) {
			data = pdata;
			scheme = pscheme;
		}
		
	}
	
	/**
	 * Searches within the direct childs of dataEl for a tag
	 * which includes the idnr number.
	 * 
	 * @param number number of this element in current level
	 * @param dataEl data-object of the corresponding nodedisplay or a lower-level data-element
	 * @return the DataElement in which this scheme-node is described, null if there is no explicitly defined data
	 */
	public static DataElement isSchemenodeInThisData(int number, Object dataEl) {
		List els = getLowerDataElements(dataEl);
		
		if (els == null) {
			return null;
		}
		
		for (int i = 0; i < els.size(); i++) {
			
			DataElement ael = (DataElement) els.get(i);
			
			if(ael.getMin()!=null){ //ranges

				int min = ael.getMin().intValue();
				int max = min;

				if (ael.getMax() != null) {
					max = ael.getMax().intValue();
				}

				if (number >= min && number <= max) {
					return ael;
				}
			}
			else if (ael.getList() != null) {//list-attribute
				
				int[] listels = getNumbersFromNumberlist(ael.getList());//for example 1,2,16,23

				for (int anum:listels) {
					if (anum == number) {
						return ael;
					}
				}
				
			}
		}
		
		return null;
	}
	
	/**
	 * Traverses elements-tree of layout-section for a nodedisplay till all ids given by numbers are found
	 * 
	 * @param numbers contains level-ids
	 * @param nodeel upper-level-el-tag
	 * @return nodedisplayelement describing the object`s layout given by element-ids through numbers
	 */
	public static Nodedisplayelement getNodedisplayElementByLevels(ArrayList<Integer> numbers, Nodedisplayelement nodeel) {
		
		if (numbers == null || numbers.size() == 0) {
			return null;
		}

		if (nodeel == null) {
			return null;
		}

		int anum = numbers.get(0);

		numbers.remove((int)0);//Remove the first element of the arraylist

		List schemeEls = getLowerNodedisplayElements(nodeel);

		Nodedisplayelement scheme = null;

		//Find scheme-tag which contains element with id anum
		for (int i = 0; i < schemeEls.size(); i++) {

			Nodedisplayelement ascheme = (Nodedisplayelement)schemeEls.get(i);

			if (ascheme.getMin() != null) {//Scheme-elements defined by range through min- max-attributes
				int amin = ascheme.getMin().intValue();
				int amax = amin;

				if (ascheme.getMax() != null) {
					amax = ascheme.getMax().intValue();
				}

				if (anum >= amin && anum <= amax) {
					scheme = ascheme;

					break;
				}

			}
			else if (ascheme.getList() != null) {//Scheme defines list of elements

				int[] listels = getNumbersFromNumberlist(ascheme.getList());//for example 1,2,16,23

				for (int number:listels) {
					if (number == anum) {
						scheme = ascheme;		
						break;
					}
				}
				//if scheme found stop searching
				if (scheme != null) {
					break;
				}

			}
		}

		//No scheme found for anum
		if (scheme == null) {
			return null;
		}

		//Real solutions are always found in this part
		
		if (numbers.size() == 0) {
			return scheme;//All numbers processed?
		}
		else{
			//are the lower levels of the scheme-node allowed in the data-tag?
			Nodedisplayelement res = getNodedisplayElementByLevels(numbers, scheme);
			return res;
		}

	}
	
	
	/**
	 * Traverses scheme-tree till all ids given by numbers are found
	 * 
	 * @param numbers contains level-ids
	 * @param schemeEl upper-level-scheme-tag
	 * @return schemeelement describing the object given by element-ids through numbers
	 */
	public static SchemeElement getSchemeByLevels(ArrayList<Integer> numbers, Object schemeEl) {
		
		if (numbers == null || numbers.size() == 0) {
			return null;
		}

		if (schemeEl == null) {
			return null;
		}

		int anum = numbers.get(0);

		numbers.remove((int)0);//Remove the first element of the arraylist

		List schemeEls = getLowerSchemeElements(schemeEl);

		SchemeElement scheme = null;

		//Find scheme-tag which contains element with id anum
		for (int i = 0; i < schemeEls.size(); i++) {

			SchemeElement ascheme = (SchemeElement)schemeEls.get(i);

			if (ascheme.getMin() != null) {//Scheme-elements defined by range through min- max-attributes
				int amin = ascheme.getMin().intValue();
				int amax = amin;

				if (ascheme.getMax() != null) {
					amax = ascheme.getMax().intValue();
				}

				int astep = ascheme.getStep().intValue();

				if (anum >= amin && anum <= amax && (anum-amin) % astep == 0 ) {
					scheme = ascheme;

					break;
				}

			}
			else if (ascheme.getList() != null) {//Scheme defines list of elements

				int[] listels = getNumbersFromNumberlist(ascheme.getList());//for example 1,2,16,23

				for (int number:listels) {
					if (number == anum) {
						scheme = ascheme;		
						break;
					}
				}
				//if scheme found stop searching
				if (scheme != null) {
					break;
				}

			}
		}

		//No scheme found for anum
		if (scheme == null) {
			return null;
		}

		//Real solutions are always found in this part
		
		if (numbers.size() == 0) {
			return scheme;//All numbers processed?
		}
		else{
			//are the lower levels of the scheme-node allowed in the data-tag?
			SchemeElement res = getSchemeByLevels(numbers, scheme);
			return res;
		}

	}
	
	
	/**
	 * Nice call for just one number, just creates an arraylist with one number and calls overloaded function
	 * @param number one integer value with id for the element to be checked
	 * @param dataEl upper-level data-element
	 * @param schemeEl scheme-element on the same level as dataEl
	 * @return Data- and Scheme which are connected to each other
	 */
	public static SchemeAndData getSchemeAndDataByLevels(int number, Object dataEl, Object schemeEl) {
		
		ArrayList<Integer> numbers = new ArrayList<Integer>();
		numbers.add(number);
		
		return getSchemeAndDataByLevels(numbers, dataEl, schemeEl);
		
	}
	
	/**
	 * 
	 * Searches within the dataEl-tree for a data-element which describes the treenode
	 * with the level-ids given by numbers.
	 * 
	 * Returns corresponding scheme-element if available
	 * 
	 * @param numbers level-ids, which has to be searched in lower elements, content might be changed by this function
	 * @param dataEl root of the data-tags, which will be processed, dataEl itself is just used to get lower elements
	 * @param schemeEl root of the scheme-tags, which will be processed, schemeEl itself is just used to get lower elements
	 * @return data-element and corresponding scheme
	 */
	public static SchemeAndData getSchemeAndDataByLevels(ArrayList<Integer> numbers, Object dataEl, Object schemeEl) {
		
//		numbers=copyArrayList(numbers);
		
		if (numbers == null || numbers.size() == 0) {
			return null;
		}
		
		if (schemeEl == null) {
			return null;
		}
		
		int anum = numbers.get(0);
		
		numbers.remove((int)0);//Remove the first element of the arraylist
		
		List els = getLowerDataElements(dataEl);
		
		List schemeEls = getLowerSchemeElements(schemeEl);
		
		for (int i = 0; i < els.size(); i++) {
			
			DataElement ael = (DataElement) els.get(i);
			
			if (ael.getMin() != null) {//data-Element with ranges

				int min = ael.getMin().intValue();
				int max = min;

				if (ael.getMax() != null) {
					max = ael.getMax().intValue();
				}

				if (min>anum || max < anum) {
					continue;
				}
				//else data-Element for anum found
			}
			else if (ael.getList() != null) {//check if anum in list
				
				boolean found = false;
				
				int[] listels = getNumbersFromNumberlist(ael.getList());//for example 1,2,16,23

				for (int number : listels) {
					if (number == anum) {
						found = true;
						break;
					}
				}
				
				//if anum not in list, search for another data-element
				if (!found) {
					continue;				
				}
			}

			//Find corresponding scheme-element
			SchemeElement scheme = null;
			for (int j = 0; j < schemeEls.size(); j++) {

				SchemeElement ascheme = (SchemeElement) schemeEls.get(j);

				if (ascheme.getMin() != null) {//Scheme-elements defined by range through min- max-attributes
					int amin = ascheme.getMin().intValue();
					int amax = amin;

					if (ascheme.getMax() != null) {
						amax = ascheme.getMax().intValue();
					}

					int astep = ascheme.getStep().intValue();

					if (anum >= amin && anum <= amax && (anum-amin) % astep == 0 ) {
						scheme = ascheme;

						break;
					}

				}
				else if (ascheme.getList() != null) {//Scheme defines list of elements

					int[] listels = getNumbersFromNumberlist(ascheme.getList());//for example 1,2,16,23

					for (int number : listels) {
						if (number == anum) {
							scheme = ascheme;		
							break;
						}
					}
					//if scheme found stop searching
					if (scheme != null) {
						break;
					}

				}
			}

			//No scheme found for the current data-element
			if (scheme == null) {
				continue;
			}

			//Real solutions are always found in this part

			if (numbers.size() == 0) {
				return new SchemeAndData(ael, scheme);//All numbers processed?
			}
			else{
				//are the lower levels of the scheme-node allowed in the data-tag?
				SchemeAndData res = getSchemeAndDataByLevels(numbers, ael, scheme);
				if (res != null) {
					return res;
				}
			}
			
		}
		
		if(dataEl instanceof DataType){
			return null;
		}
		else
			return new SchemeAndData((DataElement) dataEl, (SchemeElement) schemeEl);
		
	}
	
	/**
	 * @param levels
	 * @return a string describing the levels of a node within a tree
	 */
	public static String getLevelString(ArrayList<Integer> levels) {
		
		String levelstring = "";
		
		for (int j = 1; j <= levels.size(); j++) {
			levelstring += "el" + j + "=" + levels.get(j-1) + " ";
		}
		
		return levelstring;		
	}
	
	/**
	 * Copy an Integer-ArrayList
	 * @param orig
	 * @return
	 */
	public static ArrayList<Integer> copyArrayList(ArrayList<Integer> orig) {
		ArrayList<Integer> res = new ArrayList<Integer>();
		
		for (int i = 0; i < orig.size(); i++) {
			res.add(orig.get(i));
		}
		
		return res;
	}
		
		
	
	/**
	 * Check if all created data-nodes are allowed as described in the corresponding scheme
	 * returns list of Errors containing messages about not-allowed nodes in Errorlist
	 */
	public static void checkDataNodesinScheme(ErrorList errl, Object datanode, ArrayList<Integer> upperlevelnumbers, Object scheme ) {
		
		if (datanode == null) {
			return;
		}
		
		List els = getLowerDataElements(datanode);
		if (els == null) {
			return;
		}
		
		for (int i = 0; i < els.size(); i++) {
			
			DataElement dat = (DataElement) els.get(i);
			
			if (dat.getMin() != null) {//data-tag given by range => check every element in range
				int min = dat.getMin().intValue();
				int max = min;

				if (dat.getMax() != null) {
					max = dat.getMax().intValue();
				}

				upperlevelnumbers.add(min);

				SchemeAndData first = getSchemeAndDataByLevels(min, datanode, scheme);
//				SchemeElement first=isDatanodeInScheme(upperlevelnumbers, scheme);

				if (first == null) {//Minimum of given data-node is not in scheme
					String levelstring = getLevelString(upperlevelnumbers);

					errl.addError("\tDatanode with tree-path " + levelstring + " is not allowed in scheme");
				}
				else{

					//Check Lower-Level Data-Nodes
					checkDataNodesinScheme(errl, dat, upperlevelnumbers, first.scheme);

					int step = first.scheme.getStep().intValue();//default of step is one, even if scheme does not define min- max- attributes

					for (int j = min + step; j <= max; j += step) {

						upperlevelnumbers.set(upperlevelnumbers.size()-1, j);
						
						//get current schemeanddata
						SchemeAndData asad = getSchemeAndDataByLevels(j, datanode, scheme);
//						SchemeElement ascheme=isDatanodeInScheme(upperlevelnumbers, scheme);

						if (asad == null) {//No scheme found for id j

							String levelstring = getLevelString(upperlevelnumbers);

							errl.addError("\tDatanode with tree-path " + levelstring + " is not allowed in scheme");
						}
						else{
							//Check inner Nodes
							checkDataNodesinScheme(errl, dat, upperlevelnumbers, asad.scheme);
						}

					}

				}

				upperlevelnumbers.remove((int)(upperlevelnumbers.size()-1));

			} //end of range-checks
			else if (dat.getList() != null) {//elements in data-tag defined with a list
				
				upperlevelnumbers.add(0);
				
				int[] elements = getNumbersFromNumberlist(dat.getList());
				for (int number : elements) {
					
					upperlevelnumbers.set(upperlevelnumbers.size()-1, number);
					
					SchemeAndData asad = getSchemeAndDataByLevels(number, datanode, scheme);
					
					if (asad == null) {
						String levelstring = getLevelString(upperlevelnumbers);

						errl.addError("\tDatanode with tree-path " + levelstring + " is not allowed in scheme");
					}
					else{//current number is allowed, check lower elements
						
						checkDataNodesinScheme(errl, dat, upperlevelnumbers, asad.scheme);						
					}
					
				}
				
				upperlevelnumbers.remove((int)(upperlevelnumbers.size()-1));
				
			}
			
		}//for-loop over subelements of datanode
		
	}
	
	/**
	 * @param ids identifying numbers on every level
	 * @param scheme upper-level scheme object
	 * @return implicit name for this object by using masks and maps
	 */
	public static String getImplicitName(ArrayList<Integer> ids, Object scheme) {
		
		if (ids == null || ids.size() == 0 ) {
			return "";
		}
		
		ArrayList<Integer> id = new ArrayList<Integer>();
		id.add(ids.get(0));
		
		SchemeElement subscheme = getSchemeByLevels(copyArrayList(id), scheme);
		
		if (subscheme == null) {
			return "";
		}
		
		String subname = getLevelName(subscheme, id.get(0));
		
		ids.remove(0);
		
		return subname + getImplicitName(ids, subscheme);
	}
	
	/**
	 * Uses mask-attribute to return formatted output of levelid
	 * Exception is the definition of map-attribute, then names are explicitly given by map-attribute
	 * @param scheme corresponding scheme-element
	 * @param levelid id of the element, the name is searched for
	 * @return implicit name of the element for this level
	 */
	public static String getLevelName(SchemeElement scheme, int levelid) {
		
		if (scheme.getMap() == null) {
			return String.format(scheme.getMask(), levelid);
		}
		
		String[] names = scheme.getMap().split(",");
		if (scheme.getMin() != null) {//min-max-attributes
			int min = scheme.getMin().intValue();
			int max = min;

			if (scheme.getMax() != null) {
				max = scheme.getMax().intValue();
			}

			int step = scheme.getStep().intValue();
			
			int namespos = (levelid - min) / step;
			
			if (namespos < names.length) {
				return names[namespos];
			}
		}
		else {//List-attribute, map list-ids to map-names, in other words: find position of levelid in list-attribute and return corresponding positioned map-name
			int[] nrs = getNumbersFromNumberlist(scheme.getList());
			
			for (int i = 0; i < nrs.length; i++) {
				if (nrs[i] == levelid) {
					return names[i];
				}
			}
		}
		
		return "";
	}
	
	/**
	 * Searches for allowed implicitly defined names from a name schema.
	 * Adds all names of elements, which are directly children of the schemeElement.
	 * Then calls this method again for all children. 
	 * 
	 * @param errlist list of errors occuring while parsing
	 * @param names allowed names
	 * @param schemeElement actual node in scheme-tree
	 * @param aname name of this element, can be extended by the names of children
	 */
	public static void addAllowedNames(ErrorList errlist, HashSet<String> names, Object schemeElement, String aname) {
		
		List els = getLowerSchemeElements(schemeElement);
		if (els == null) {
			return;//no sub-elements found
		}
		for (int i = 0; i < els.size(); i++) {
			
			SchemeElement el = (SchemeElement) els.get(i);
			
			if (el.getMin() != null) {//Lower elements through ranges
				int min = el.getMin().intValue();
				int max = min;

				if (el.getMax() != null) {
					max = el.getMax().intValue();
				}

				int step = el.getStep().intValue();

				if (min > max) {
					errlist.addError("A min-value is bigger then the appropriate max-value." + aname + " min= " + min + " max= " + max);
				}

				for (int j = min; j <= max; j += step) {

					String thisname = aname + getLevelName(el, j);
					names.add(thisname);

					addAllowedNames(errlist, names, el, thisname);				
				}
			}
			else if (el.getList() != null) {//Lower elements through list
				
				int[] numbers = getNumbersFromNumberlist(el.getList());
				
				for (int number : numbers) {
					String thisname = aname+getLevelName(el, number);
					names.add(thisname);

					addAllowedNames(errlist, names, el, thisname);
				}
				
			}
			
		}
		
	}
	
	/**
	 * Traverses the data-tag-tree and searches for refid-Attributes.
	 * Then checks whether these attributes have allowed values according to
	 * name scheme of the corresponding nodedisplay.
	 * Allowed names are passed as a set of names
	 * 
	 * Traverses all nodedisplay-references
	 * 
	 * @param errlist
	 * @param names
	 * @param schemeElement
	 */
	public static void checkNamesAllowed(ErrorList errlist, HashSet<String> names, Object datarefelement) {
		
		List els = getLowerDataElements(datarefelement);
		if (els == null) {
			return;//Keine Unterelemente gefunden
		}
		for (int i = 0; i < els.size(); i++) {
			
			DataElement el = (DataElement)els.get(i);
			
			String refname = el.getRefid();
			
			if (refname != null) {
				if (!names.contains(refname)) {
					errlist.addError("\t\tImplicit name " + refname + " is not allowed");
				}
			}
			
			checkNamesAllowed(errlist, names, el);
		}
		
	}
	
	/**
	 * Checks validity of nodedisplays.
	 * Checks whether only allowed attributes where used for
	 * base nodedisplays and nodedisplayrefs.
	 * 
	 * Also checks whether the defined data-nodes are allowed against the scheme of the corresponding nodedisplay
	 * 
	 * @param lgui
	 * @return found errors
	 */
	public static ErrorList checkNodedisplays(LguiType lgui) {
		
		ErrorList res = new ErrorList();
		
		List<GobjectType> gobjects = getGraphicalObjects(lgui);
		
		//Search all nodedisplays and check their attributes
		for (GobjectType gobj : gobjects) {
			if (gobj instanceof Nodedisplay) {
				
				Nodedisplay dis = (Nodedisplay)gobj;
				
				res.addMessage("Errors for Nodedisplay " + dis.getId());
				//This part is now done by xsl-file
//				checkAttributesAllowedForNodedisplay(dis.getRefto()!=null, res, dis.getData(), new ArrayList<Integer>());
				
				checkDataNodesinScheme(res, dis.getData(), new ArrayList<Integer>(), dis.getScheme());
				
			}			
		}
		
		return res;
	}
	
	private static final String line="-----------------------------------";
	
}