package org.opentrafficsim.editor;
   
   import java.io.IOException;
   import java.net.URI;
   import java.net.URISyntaxException;
   import java.util.ArrayList;
   import java.util.Iterator;
   import java.util.LinkedHashMap;
   import java.util.LinkedHashSet;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.Optional;
  import java.util.Queue;
  import java.util.Set;
  
  import javax.xml.parsers.ParserConfigurationException;
  
  import org.djutils.exceptions.Throw;
  import org.opentrafficsim.base.OtsRuntimeException;
  import org.opentrafficsim.base.logger.Logger;
  import org.w3c.dom.Document;
  import org.w3c.dom.Node;
  import org.xml.sax.SAXException;
  
  /**
   * Reads the XML Schema in XSD format for OTS. This class contains various methods that the editor can use to present relevant
   * structure and information to the user.
   * <p>
   * This class performs various checks on XSD consistency. To obtain a list of inconsistencies encountered, allow trace level
   * logging.
   * <p>
   * Copyright (c) 2023-2024 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
   * BSD-style license. See <a href="https://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
   * </p>
   * @author <a href="https://github.com/wjschakel">Wouter Schakel</a>
   */
  public class Schema
  {
  
      /** Root OTS node. */
      private Node root;
  
      /** List of read files. */
      private final Set<String> readFiles = new LinkedHashSet<>();
  
      /** All loaded types, xsd:simpleType or xsd:complexType with name={name} attribute. */
      private final Map<String, Node> types = new LinkedHashMap<>();
  
      /** Paths of all types that are sub-classed using xsd:extension, coupled to a set of the extending elements. */
      private final Map<String, Set<String>> extendedTypes = new LinkedHashMap<>();
  
      /**
       * Paths of types that are referred to by xsd:element or xsd:attribute with type={type}, coupled to a set of the referring
       * elements.
       */
      private final Map<String, Set<String>> referredTypes = new LinkedHashMap<>();
  
      /** All loaded elements, path and node. */
      private final Map<String, Node> elements = new LinkedHashMap<>();
  
      /** Paths of elements that are referred to by xsd:element with ref={ref}, coupled to a set of the referring elements. */
      private final Map<String, Set<String>> referredElements = new LinkedHashMap<>();
  
      /** Documentation xsd:documentation stored at its path. */
      private final Map<String, String> documentation = new LinkedHashMap<>();
  
      /** Nodes xsd:key. */
      private final Map<String, Node> keys = new LinkedHashMap<>();
  
      /** Nodes xsd:keyref. */
      private final Map<String, Node> keyrefs = new LinkedHashMap<>();
  
      /** Nodes xsd:unique. */
      private final Map<String, Node> uniques = new LinkedHashMap<>();
  
      /** Reading queue. */
      private final Queue<RecursionElement> queue = new LinkedList<>();
  
      /** Boolean to prevent infinite loop of self-queuing as a parent type is not found. */
      private boolean blockLoop = false;
  
      /**
       * Constructs the XML Schema information from a document.
       * @param document main document, other files may be included from within the file.
       */
      public Schema(final Document document)
      {
          this.readFiles.add(document.getDocumentURI());
  
          queue("", document, true);
          while (!this.queue.isEmpty())
          {
              RecursionElement next = this.queue.poll();
              read(next.path(), next.node(), next.extendPath());
          }
  
          // all elements with type={type} have that node stored, replace it with the referred node
         for (Entry<String, Node> entry : this.elements.entrySet())
         {
             Optional<String> referredTypeName = DocumentReader.getAttribute(entry.getValue(), "type");
             if (referredTypeName.isPresent() && !referredTypeName.get().startsWith("xsd:"))
             {
                 Node referredType = getType(referredTypeName.get()).get();
                 entry.setValue(referredType);
             }
         }
 
         // checks
         Set<String> allTypes = new LinkedHashSet<>(this.types.keySet());
         for (String str : this.extendedTypes.keySet())
         {
             allTypes.removeIf((val) -> val.startsWith(str));
         }
         for (String str : this.referredTypes.keySet())
         {
             allTypes.removeIf((val) -> val.startsWith(str));
         }
         if (!allTypes.isEmpty())
         {
             Logger.ots().trace("{} types are defined but never extended or referred to.", allTypes.size());
             // allTypes.forEach((str) -> Logger.ots().trace(" + {}", str));
         }
 
         Set<String> allElements = new LinkedHashSet<>(this.elements.keySet());
         for (String str : this.referredElements.keySet())
         {
             allElements.removeIf((val) -> val.startsWith(str));
         }
         for (String str : this.types.keySet())
         {
             allElements.removeIf((val) -> val.startsWith(str));
         }
         allElements.removeIf((path) -> path.startsWith("Ots"));
         if (!allElements.isEmpty())
         {
             Logger.ots().trace("{} elements are defined but never referred to, nor are they a type.", allElements.size());
             // allElements.forEach((str) -> Logger.ots().trace(" + {}", str));
         }
 
         checkKeys();
         checkKeyrefs();
         checkUniques();
 
         // allElements = new LinkedHashSet<>(this.elements.keySet());
         // allElements.removeIf((key) -> !key.startsWith("Ots."));
         // allElements.forEach((key) -> Logger.ots().trace(key));
 
         Logger.ots().trace("Root found as '{}'.", DocumentReader.getAttribute(this.getRoot(), "name").get());
         Logger.ots().trace("Read {} files.", this.readFiles.size());
         Logger.ots().trace("Read {} elements.", this.elements.size());
         Logger.ots().trace("Read {} types.", this.types.size());
         Logger.ots().trace("Read {} extended types.", this.extendedTypes.size());
         Logger.ots().trace("Read {} documentations.", this.documentation.size());
         Logger.ots().trace("Read {} keys.", this.keys.size());
         Logger.ots().trace("Read {} keyrefs.", this.keyrefs.size());
         Logger.ots().trace("Read {} uniques.", this.uniques.size());
         for (String type : this.extendedTypes.keySet())
         {
             if (!this.types.containsKey(type) && !type.startsWith("xsd:"))
             {
                 Logger.ots().trace("Type '{}' is extended but was not found.", type);
             }
         }
     }
 
     /**
      * Reads the next node. If recursion is found, the node is ignored.<br>
      * <br>
      * If the node is xsd:extension, reading the extended type in place of the path is queued. If, however, the extended type is
      * not yet loaded, reading this node is queued to be read again. The method will continue to read the parts of the node
      * defined additional to the extended type. To prevent that this is read again later, this is captured in the later read,
      * which will then be ignored.<br>
      * <br>
      * Extends the path for xsd:element's with either a name={name} or ref={ref} attribute. If the name is "Ots", this element
      * is stored as the root for the whole schema. If there is a ref={ref} attribute, rather than reading the given node, the
      * referred node is read at its place in the path.<br>
      * <br>
      * Also extends the path for an xsd:simpleType or xsd:complexType node, if it has a name={name} attribute.<br>
      * <br>
      * Finally, loops all the children of the node to read and processes them in the following manner:
      * <ul>
      * <li>#text nodes are ignored.</li>
      * <li>xsd:include, xsd:attribute, xsd:element and xsd:documentation nodes are forwarded to dedicated methods.</li>
      * <li>xsd:key, xsd:keyref and xsd:unique nodes are stored for later checks.</li>
      * <li>All other child nodes are recursively read.</li>
      * </ul>
      * @param path node path.
      * @param node xsd:attribute node.
      * @param extendPath whether the path should be extended with this node.
      */
     private void read(final String path, final Node node, final boolean extendPath)
     {
         if (recursion(path))
         {
             Logger.ots().trace("Recursion found at {}, further expansion is halted.", path);
             return;
         }
 
         if (node.getNodeName().equals("xsd:extension"))
         {
             String base = DocumentReader.getAttribute(node, "base").get().replace("ots:", "");
             if (!base.startsWith("xsd:"))
             {
                 Optional<Node> baseNode = getType(base);
                 if (baseNode.isEmpty())
                 {
                     if (this.blockLoop)
                     {
                         return;
                     }
                     this.blockLoop = true;
                     // this occurs if a type has a base, with the base being defined later in the XSD
                     queue(path, node, false);
                 }
                 else
                 {
                     queue(path, baseNode.get(), false);
                 }
             }
             if (this.extendedTypes.containsKey(base) && this.extendedTypes.get(base).contains(path))
             {
                 // this occurs if a type has a base, with the base being defined later in the XSD
                 // do not read what is additional to the base, as that was done previously and this is the queued base (re)read
                 return;
             }
             this.extendedTypes.computeIfAbsent(base, (key) -> new LinkedHashSet<String>()).add(path);
         }
         this.blockLoop = false;
 
         String nextPath = path;
         Node nextNode = node;
         if (node.getNodeName().equals("xsd:element") && node.hasAttributes())
         {
             // an xsd:element can not have a name and a ref attribute
             Optional<String> name = DocumentReader.getAttribute(node, "name");
             if (name.isPresent())
             {
                 if (name.get().equals("Ots"))
                 {
                     this.root = node;
                 }
                 nextPath = extendPath ? (nextPath.isEmpty() ? name.get() : nextPath + "." + name) : nextPath;
                 this.elements.put(nextPath, node);
             }
             String ref = DocumentReader.getAttribute(node, "ref").orElse(null);
             if (ref != null)
             {
                 ref = ref.replace("ots:", "");
                 nextNode = getElement(ref).get();
                 /*
                  * There might be more exotic referring situations than this one. Here, we have an <xsd:element ref="Model">
                  * pointing to a <xsd:element name="Model" type="ModelType" /> being typed by an <xsd:complexType
                  * name="ModelType">.
                  */
                 if (DocumentReader.getAttribute(nextNode, "type").isPresent())
                 {
                     element(path, nextNode);
                 }
                 nextPath = extendPath ? (nextPath.isEmpty() ? ref : nextPath + "." + ref) : nextPath;
                 this.elements.put(nextPath, nextNode);
                 Throw.whenNull(nextNode, "Element %s refers to a type that was not loaded in first pass.", nextPath);
             }
         }
 
         Optional<String> name = DocumentReader.getAttribute(nextNode, "name");
 
         String nodeName = nextNode.getNodeName();
         if (name.isPresent() && (nodeName.equals("xsd:complexType") || nodeName.equals("xsd:simpleType")))
         {
             this.types.put(name.get(), nextNode);
             nextPath = extendPath ? (nextPath.isEmpty() ? name.get() : nextPath + "." + name.get()) : nextPath;
         }
 
         if (!nextNode.hasChildNodes())
         {
             return;
         }
         for (int childIndex = 0; childIndex < nextNode.getChildNodes().getLength(); childIndex++)
         {
             Node child = nextNode.getChildNodes().item(childIndex);
             switch (child.getNodeName())
             {
                 case "#text":
                     break;
                 case "xsd:include":
                     include(nextPath, child);
                     break;
                 case "xsd:element":
                     element(nextPath, child);
                     break;
                 case "xsd:attribute":
                     attribute(nextPath, child);
                     break;
                 case "xsd:documentation":
                     documentation(nextPath, child);
                     break;
                 case "xsd:union":
                     union(nextPath, child);
                     break;
                 case "xsd:key":
                     if (nextPath.startsWith("Ots"))
                     {
                         this.keys.put(nextPath + "." + DocumentReader.getAttribute(child, "name").get(), child);
                     }
                     break;
                 case "xsd:keyref":
                     if (nextPath.startsWith("Ots"))
                     {
                         this.keyrefs.put(nextPath + "." + DocumentReader.getAttribute(child, "name").get(), child);
                     }
                     break;
                 case "xsd:unique":
                     if (nextPath.startsWith("Ots"))
                     {
                         this.uniques.put(nextPath + "." + DocumentReader.getAttribute(child, "name").get(), child);
                     }
                     break;
                 default:
                     read(nextPath, child, true);
             }
         }
     }
 
     /**
      * Checks for recursion. This is recognized as the same end of the path, is duplicated in an equal sub-path before that end.
      * For example CarFollowingModel{.Socio}{.Socio} or CarFollowingModel{.Socio.Parent}{.Socio.Parent}.
      * @param path node path.
      * @return true if the path contains recursion.
      */
     private boolean recursion(final String path)
     {
         StringBuffer sub = (new StringBuffer(path)).reverse();
         int fromIndex = 0;
         while (fromIndex < sub.length())
         {
             int dot = sub.indexOf(".", fromIndex);
             if (dot < 0)
             {
                 return false; // no dot in path
             }
             int toIndex = 2 * (dot + 1);
             if (toIndex > sub.length())
             {
                 return false; // first dot beyond middle
             }
             if (sub.substring(0, dot + 1).equals(sub.substring(dot + 1, toIndex)))
             {
                 return true;
             }
             fromIndex = dot + 1;
         }
         return false;
     }
 
     /**
      * Queues reading the node at specified path. This is used to start all the reading, and to delay reading that is dependent
      * on parent types to be loaded. When the read is queued as a parent type is not yet loaded, the path should not be extended
      * upon the queued read. The path will have been extended in processing the child element itself.
      * @param path node path.
      * @param node node.
      * @param extendPath whether the path should be extended with this node.
      */
     private void queue(final String path, final Node node, final boolean extendPath)
     {
         this.queue.add(new RecursionElement(path, node, extendPath));
     }
 
     /**
      * Reads further from an included file.
      * @param path node path.
      * @param node xsd:include node.
      */
     private void include(final String path, final Node node)
     {
         String schemaLocation = DocumentReader.getAttribute(node, "schemaLocation").get();
         String schemaPath = folder(node) + schemaLocation;
         if (!this.readFiles.add(schemaPath))
         {
             return;
         }
         try
         {
             read(path, DocumentReader.open(new URI(schemaPath)), true);
         }
         catch (SAXException | IOException | ParserConfigurationException | URISyntaxException e)
         {
             throw new OtsRuntimeException("Unable to find resource " + folder(node) + schemaLocation);
         }
     }
 
     /**
      * Returns the path, with separator at the end, relative to which an include in the node should be found.
      * @param node node.
      * @return path, with separator at the end, relative to which an include in the node should be found.
      */
     private String folder(final Node node)
     {
         String uri = node.getBaseURI();
         if (uri == null)
         {
             return "";
         }
         int a = uri.lastIndexOf("\\");
         int b = uri.lastIndexOf("/");
         return uri.substring(0, (a > b ? a : b) + 1);
     }
 
     /**
      * Reads further from an element node.
      * @param path node path.
      * @param node xsd:element node.
      */
     private void element(final String path, final Node node)
     {
         if (DocumentReader.getAttribute(node, "ref").isPresent())
         {
             ref(path, node);
             return;
         }
         String type = DocumentReader.getAttribute(node, "type").orElse(null);
         if (type != null && !type.startsWith("xsd:"))
         {
             type = type.replace("ots:", "");
             this.referredTypes.computeIfAbsent(type, (key) -> new LinkedHashSet<>())
                     .add(path.isEmpty() ? DocumentReader.getAttribute(node, "name").get()
                             : path + "." + DocumentReader.getAttribute(node, "name").get());
             Optional<Node> referred = getType(type);
             if (referred.isEmpty())
             {
                 queue(path, node, true);
                 return; // prevents reading the type now and later from queue
             }
             else
             {
                 queue(path + "." + DocumentReader.getAttribute(node, "name").get(), referred.get(), false);
             }
         }
         read(path, node, true);
     }
 
     /**
      * Reads further from an element node with a ref={ref} attribute. If the ref equals "xi:include" it is ignored, as this
      * specifies that the XML file can include another XML file. It does not specify the schema further. If the referred type is
      * not yet loaded, reading from this ref node is placed at the back of the queue.
      * @param path node path.
      * @param node xsd:element node.
      */
     private void ref(final String path, final Node node)
     {
         String ref = DocumentReader.getAttribute(node, "ref").get().replace("ots:", "");
         if (ref.equals("xi:include"))
         {
             return;
         }
         this.referredElements.computeIfAbsent(ref, (key) -> new LinkedHashSet<>()).add(path);
         Optional<Node> refNode = getElement(ref);
         if (refNode.isEmpty())
         {
             queue(path, node, true);
         }
         else
         {
             read(path, node, true);
         }
     }
 
     /**
      * Reads further from an attribute node.
      * @param path node path.
      * @param node xsd:attribute node.
      */
     private void attribute(final String path, final Node node)
     {
         String type = DocumentReader.getAttribute(node, "type").orElse(null);
         if (type != null)
         {
             type = DocumentReader.getAttribute(node, "type").get().replace("ots:", "");
             String name = DocumentReader.getAttribute(node, "name").get();
             this.referredTypes.computeIfAbsent(type, (key) -> new LinkedHashSet<>()).add(path + "." + name);
         }
         read(path, node, true);
     }
 
     /**
      * Stores documentation at the current path.
      * @param path node path.
      * @param node xsd:attribute node.
      */
     private void documentation(final String path, final Node node)
     {
         Optional<Node> doc = DocumentReader.getChild(node, "#text");
         if (doc.isPresent())
         {
             this.documentation.put(path, doc.get().getNodeValue().trim().replaceAll("\r\n", " ").replaceAll("\n", " ")
                     .replaceAll("\r", " ").replace("  ", ""));
         }
     }
 
     /**
      * Read union node.
      * @param path node path.
      * @param node xsd:union node.
      */
     private void union(final String path, final Node node)
     {
         /*
          * Note: unions can only consist of simple types (with only a regular value). Therefore this pertains to valid values
          * only, and not to children and attributes. Therefore the memberTypes do not need to be read in place of the node.
          */
         for (String type : DocumentReader.getAttribute(node, "memberTypes").get().split(" "))
         {
             this.referredTypes.computeIfAbsent(type.replace("ots:", ""), (key) -> new LinkedHashSet<>()).add(path);
         }
         read(path, node, true);
     }
 
     /**
      * Stores the information to read in a queue.
      * <p>
      * Copyright (c) 2023-2024 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
      * <br>
      * BSD-style license. See <a href="https://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
      * </p>
      * @author <a href="https://github.com/wjschakel">Wouter Schakel</a>
      * @param path node path.
      * @param node xsd:attribute node.
      * @param extendPath whether the path should be extended with this node.
      */
     private record RecursionElement(String path, Node node, boolean extendPath)
     {
     }
 
     /**
      * Checks that all xsd:key refer to a loaded type with their xsd:selector node. And that all xsd:field nodes point to
      * existing attributes in loaded types. This method assumes only attributes (@) and no elements (ots:) are checked.
      */
     private void checkKeys()
     {
         checkKeyOrUniques("Key", this.keys);
     }
 
     /**
      * Checks that all xsd:unique refer to a loaded type with their xsd:selector node. And that all xsd:field nodes point to
      * existing attributes in loaded types. This method assumes only attributes (@) and no elements (ots:) are checked.
      */
     private void checkUniques()
     {
         checkKeyOrUniques("Unique", this.uniques);
     }
 
     /**
      * Checks that all xsd:key or xsd:unique refer to a loaded type with their xsd:selector node. And that all xsd:field nodes
      * point to existing attributes in loaded types. This method assumes only attributes (@) and no elements (ots:) are checked.
      * @param label "Key" or "Unique" for log messaging.
      * @param map map of nodes, either xsd:key or xsd:unique.
      */
     private void checkKeyOrUniques(final String label, final Map<String, Node> map)
     {
         for (String fullPath : map.keySet())
         {
             Node node = map.get(fullPath);
             String context = fullPath.substring(0, fullPath.lastIndexOf("."));
             String element = DocumentReader.getAttribute(node, "name").get();
             for (String selector : getXpath(node).split("\\|"))
             {
                 String path;
                 Node selected = null;
                 if (!selector.startsWith(".//"))
                 {
                     path = context + "." + selector.replace("/", ".");
                     selected = getElement(path).orElse(null);
                 }
                 else
                 {
                     // do it the hard way for if there are intermediate layers, e.g. Ots.{...}.GtuTypes.GtuType
                     path = context + selector.replace(".//", ".{...}").replace("/", ".");
                     for (Entry<String, Node> entry : this.elements.entrySet())
                     {
                         String elementPath = entry.getKey();
                         if (elementPath.startsWith(context) && elementPath.endsWith(selector.substring(3).replace("/", ".")))
                         {
                             selected = entry.getValue();
                             break;
                         }
                     }
                 }
                 if (selected == null)
                 {
                     Logger.ots().trace("{} {} ({}) not found among elements.", label, element, path);
                 }
                 else
                 {
                     for (Node field : DocumentReader.getChildren(node, "xsd:field"))
                     {
                         String xpathFieldString = DocumentReader.getAttribute(field, "xpath").get();
                         boolean found = false;
                         for (String xpathField : xpathFieldString.split("\\|"))
                         {
                             if (xpathField.startsWith("@"))
                             {
                                 xpathField = xpathField.substring(1); // removes '@'
                                 if (hasElementAttribute(selected, xpathField))
                                 {
                                     found = true;
                                 }
                             }
                             else
                             {
                                 Logger.ots().trace("Field {} in {} {} not checked.", xpathField, label.toLowerCase(), element);
                             }
                         }
                         if (!found)
                         {
                             Logger.ots().trace("{} {} ({}) points to non existing field {}.", label, element, path,
                                     xpathFieldString);
                         }
                     }
                 }
             }
         }
     }
 
     /**
      * Checks that all xsd:keyrefs refer to loaded keys. That they refer to a loaded type with their xsd:selector node. And that
      * all xsd:field nodes point to existing attributes (@), values (.), or elements (ots:), in loaded types.
      */
     private void checkKeyrefs()
     {
         for (String fullPath : this.keyrefs.keySet())
         {
             Node node = this.keyrefs.get(fullPath);
             String keyref = DocumentReader.getAttribute(node, "name").get();
             String keyName = DocumentReader.getAttribute(node, "refer").get().replace("ots:", "");
             Node key = null;
             boolean keyFound = false;
             Iterator<Node> iterator = this.keys.values().iterator();
             while (!keyFound && iterator.hasNext())
             {
                 key = iterator.next();
                 keyFound = keyName.equals(DocumentReader.getAttribute(key, "name").orElse(null));
             }
             if (!keyFound)
             {
                 Logger.ots().trace("Keyref {} refers to non existing key {}.", keyref,
                         DocumentReader.getAttribute(node, "refer").orElse(null));
             }
             String context = fullPath.substring(0, fullPath.lastIndexOf("."));
             List<Node> elementList = getSelectedElements(context, node);
             if (elementList.isEmpty())
             {
                 Logger.ots().trace("Keyref {} ({}) not found among elements.", keyref, getXpath(node));
             }
             else
             {
                 for (int i = 0; i < elementList.size(); i++)
                 {
                     Node selected = elementList.get(i);
                     for (Node field : DocumentReader.getChildren(node, "xsd:field"))
                     {
                         String xpathFieldString = DocumentReader.getAttribute(field, "xpath").get();
                         String[] xpathFieldValues = xpathFieldString.split("\\|");
                         String xpathField = xpathFieldValues.length == 1 ? xpathFieldValues[0] : xpathFieldValues[i];
                         if (!followXPath(selected, xpathField))
                         {
                             Logger.ots().trace("Keyref {} ({}) points to non existing field {}.", keyref,
                                     getXpath(node).split("\\|")[i], xpathField);
                         }
                     }
                 }
             }
         }
     }
 
     /**
      * Follows to xpath recursively to find a referred element.
      * @param selected current node from which xpath is relative
      * @param xpath xpath
      * @return whether the element was found
      */
     private boolean followXPath(final Node selected, final String xpath)
     {
         if (xpath.startsWith("@"))
         {
             String xpathField = xpath.substring(1); // removes '@'
             return hasElementAttribute(selected, xpathField);
         }
         String selectedName = selected.getNodeName();
         if (xpath.equals(".") && (selectedName.equals("xsd:simpleType") || selectedName.equals("xsd:element")))
         {
             return true; // value is in element
         }
         int index = xpath.indexOf("/");
         String name = index < 0 ? xpath : xpath.substring(0, index);
         String remainder = index < 0 ? null : xpath.substring(index);
         name = name.replace("ots:", "");
         boolean found = false;
         if (name.equals(DocumentReader.getAttribute(selected, "name").orElse(null)))
         {
             found = true;
         }
         else if (selectedName.equals("xsd:complexType") || selectedName.equals("xsd:sequence")
                 || selectedName.equals("xsd:choice") || selectedName.equals("xsd:all") || selectedName.equals("xsd:element"))
         {
             for (int i = 0; i < selected.getChildNodes().getLength() && !found; i++)
             {
                 Node child = selected.getChildNodes().item(i);
                 found = followXPath(child, name);
             }
         }
         if (found && remainder != null)
         {
             for (int i = 0; i < selected.getChildNodes().getLength() && !found; i++)
             {
                 Node child = selected.getChildNodes().item(i);
                 if (selectedName.equals("xsd:simpleType") || selectedName.equals("xsd:complexType")
                         || selectedName.equals("xsd:element"))
                 {
                     found = followXPath(child, remainder);
                 }
             }
         }
         return found;
     }
 
     /**
      * Returns loaded elements referred to from an xsd:selector child of the given node. A list is returned as multiple elements
      * may be referred to in the selector string split by "|".
      * @param context context.
      * @param node node (xsd:key, xsd:keyref or xsd:unique).
      * @return elements referred to from an xsd:selector child of the given node.
      */
     private List<Node> getSelectedElements(final String context, final Node node)
     {
         List<Node> nodes = new ArrayList<>();
         for (String selector : getXpath(node).split("\\|"))
         {
             Node selected = null;
             if (!selector.startsWith(".//"))
             {
                 selected = getElement(context + "." + selector.replace("/", ".")).orElse(null);
             }
             else
             {
                 // do it the hard way for if there are intermediate layers, e.g. Ots.{...}.GtuTypes.GtuType
                 for (Entry<String, Node> entry : this.elements.entrySet())
                 {
                     String elementPath = entry.getKey();
                     if (elementPath.startsWith(context) && elementPath.endsWith(selector.replace(".//", "").replace("/", ".")))
                     {
                         selected = entry.getValue();
                         break;
                     }
                 }
             }
             if (selected != null)
             {
                 nodes.add(selected);
             }
             else
             {
                 for (Entry<String, Node> entry : this.elements.entrySet())
                 {
                     if (!entry.getKey().startsWith("Ots.")
                             && entry.getKey().endsWith(selector.replace(".//", "").replace("/", ".")))
                     {
                         nodes.add(entry.getValue());
                         break;
                     }
                     else if (isType(entry.getValue(), selector.replace(".//", "").replace("/", ".")))
                     {
                         nodes.add(entry.getValue());
                         break;
                     }
                 }
             }
         }
         return nodes;
     }
 
     /**
      * Reads the xpath from an xsd:selector child of the given node.
      * @param node node (xsd:key, xsd:keyref or xsd:unique).
      * @return xpath from an xsd:selector child of the given node.
      */
     private String getXpath(final Node node)
     {
         Node child = DocumentReader.getChild(node, "xsd:selector").get();
         String xpath = DocumentReader.getAttribute(child, "xpath").get();
         xpath = xpath.replace("ots:", "");
         return xpath;
     }
 
     /**
      * Returns whether the given node defines an element to have a specified attribute. This can be either because the node is
      * xsd:complexType in which an xsd:attribute with the specified name is defined, because it has a child xsd:complexType
      * meeting the same criteria, or because it is found in an underlying xsd:extension. For an xsd:extension, the attribute is
      * sought in both the base type, and in the specified extension elements.
      * @param node node.
      * @param name attribute name, i.e. &lt;xsd:attribute name={name} ... &gt;.
      * @return whether the given node defines an element to have a specified attribute.
      */
     private boolean hasElementAttribute(final Node node, final String name)
     {
         if (node.getNodeName().equals("xsd:complexType"))
         {
             // node is a "xsd:complexType"
             return hasElementAttribute(node, name, null);
         }
         // node is a "xsd:element" with a "xsd:complexType"
         return hasElementAttribute(node, name, "xsd:complexType");
     }
 
     /**
      * Searches for an xsd:attribute in a given node. If no viaType is specified, this happens on the children of the given
      * node. Otherwise, first a child node of viaType is taken, and the children nodes of that node are considered. If this
      * method encounters an xsd:complexContent child that itself has a xsd:extension child, both the extended type and the
      * specified extension elements are considered.
      * @param node node.
      * @param name attribute name, i.e. &lt;xsd:attribute name={name} ... &gt;.
      * @param viaType viaType, can be used for recursion with or without an intermediate child layer.
      * @return whether the given node defines an element to have a specified attribute.
      */
     private boolean hasElementAttribute(final Node node, final String name, final String viaType)
     {
         Node via = viaType == null ? node : DocumentReader.getChild(node, viaType).get();
         for (int childIndex = 0; childIndex < via.getChildNodes().getLength(); childIndex++)
         {
             Node child = via.getChildNodes().item(childIndex);
             String childName = DocumentReader.getAttribute(child, "name").orElse(null);
             String childNodeName = child.getNodeName();
             if (childNodeName.equals("xsd:attribute") && name.equals(childName)
                     || childNodeName.equals("xsd:sequence") && hasElementAttribute(child, name, null))
             {
                 return true;
             }
             if (childNodeName.equals("xsd:complexContent") || childNodeName.equals("xsd:simpleContent"))
             {
                 Optional<Node> extension = DocumentReader.getChild(child, "xsd:extension");
                 if (extension.isPresent())
                 {
                     Optional<String> base = DocumentReader.getAttribute(extension.get(), "base");
                     if (base.isPresent())
                     {
                         Optional<Node> baseNode = getType(base.get());
                         // null input, referred types are already complex
                         if (baseNode.isPresent() && hasElementAttribute(baseNode.get(), name, null))
                         {
                             return true;
                         }
                     }
                     if (hasElementAttribute(extension.get(), name, null)) // null, xsd:extension directly contains xsd:attribute
                     {
                         return true;
                     }
                 }
             }
         }
         return false;
     }
 
     /**
      * Get the root node.
      * @return root node.
      */
     public Node getRoot()
     {
         return this.root;
     }
 
     /**
      * Returns the node for the given path.
      * @param path path.
      * @return type, empty if not known
      */
     public Optional<Node> getElement(final String path)
     {
         return Optional.ofNullable(this.elements.get(path.replace("ots:", "")));
     }
 
     /**
      * Returns the type, as pointed to by base={base}.
      * @param base type.
      * @return type, as pointed to by base={base}, empty if not known.
      */
     public Optional<Node> getType(final String base)
     {
         return Optional.ofNullable(this.types.get(base.replace("ots:", "")));
     }
 
     /**
      * Returns the xsd:key and the paths where they are defined.
      * @return xsd:key and the paths where they are defined.
      */
     public Map<String, Node> keys()
     {
         return new LinkedHashMap<>(this.keys);
     }
 
     /**
      * Returns the xsd:keyref and the paths where they are defined.
      * @return xsd:keyref and the paths where they are defined.
      */
     public Map<String, Node> keyrefs()
     {
         return new LinkedHashMap<>(this.keyrefs);
     }
 
     /**
      * Returns the xsd:unique and the paths where they are defined.
      * @return xsd:unique and the paths where they are defined.
      */
     public Map<String, Node> uniques()
     {
         return new LinkedHashMap<>(this.uniques);
     }
 
     /**
      * Return whether the given node is of the type.
      * @param node node.
      * @param path path of the type in dotted xpath notation, e.g. "SignalGroup.TrafficLight".
      * @return whether the given node is of the type.
      */
     public boolean isType(final Node node, final String path)
     {
         Optional<String> name = DocumentReader.getAttribute(node, "name");
         if (name.isPresent() && path.equals(name.get()))
         {
             return true;
         }
         Node nodeUse = node;
         if (nodeUse.getNodeName().equals("xsd:element"))
         {
             nodeUse = DocumentReader.getChild(node, "xsd:complexType").orElse(null);
             if (nodeUse == null)
             {
                 nodeUse = DocumentReader.getChild(node, "xsd:simpleType").orElse(null);
                 if (nodeUse == null)
                 {
                     return false;
                 }
             }
         }
         for (int childIndex = 0; childIndex < nodeUse.getChildNodes().getLength(); childIndex++)
         {
             Node child = nodeUse.getChildNodes().item(childIndex);
             if (child.getNodeName().equals("xsd:complexContent") || child.getNodeName().equals("xsd:simpleContent"))
             {
                 String base = null;
                 Optional<Node> extension = DocumentReader.getChild(child, "xsd:extension");
                 if (extension.isPresent())
                 {
                     base = DocumentReader.getAttribute(extension.get(), "base").orElse(null);
                 }
                 Optional<Node> restriction = DocumentReader.getChild(child, "xsd:restriction");
                 if (restriction.isPresent())
                 {
                     base = DocumentReader.getAttribute(restriction.get(), "base").orElse(null);
                 }
                 if (base == null)
                 {
                     return false;
                 }
                 if (base.endsWith(path))
                 {
                     return true;
                 }
                 if (!base.startsWith("xsd:"))
                 {
                     Optional<Node> baseNode = getType(base);
                     if (baseNode.isPresent() && !baseNode.equals(nodeUse))
                     {
                         return isType(baseNode.get(), path);
                     }
                 }
             }
         }
         return false;
     }
 
 }