package org.opentrafficsim.editor;
   
   import java.rmi.RemoteException;
   import java.util.LinkedHashSet;
   import java.util.Map.Entry;
   import java.util.Objects;
   import java.util.Set;
   import java.util.function.Supplier;
   
  import org.djutils.eval.Eval;
  import org.djutils.event.Event;
  import org.djutils.event.EventListener;
  import org.djutils.event.EventType;
  import org.djutils.event.reference.ReferenceType;
  import org.djutils.metadata.MetaData;
  import org.djutils.metadata.ObjectDescriptor;
  import org.opentrafficsim.base.OtsRuntimeException;
  import org.opentrafficsim.editor.decoration.validation.KeyValidator;
  import org.opentrafficsim.editor.decoration.validation.KeyrefValidator;
  import org.opentrafficsim.editor.decoration.validation.XPathValidator;
  import org.w3c.dom.Node;
  
  /**
   * Extends {@code XsdTreeNode} with event producer capabilities. In this way there is a clear central point for subscription to
   * events on node creation and removal. Because this node itself is created, and the tree table model will expand two layers,
   * for none of those nodes creation events can be thrown regularly after listeners have had a change to register with this root
   * node. Therefore, this class overrides {@code addListener(...)} to throw a creation event for all existing nodes in the tree.
   * <br>
   * <br>
   * This class also sets up a listener for all xsd:key, xsd:keyref and xsd:unique from the schema.
   * <p>
   * Copyright (c) 2023-2026 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 Wouter Schakel
   */
  public class XsdTreeNodeRoot extends XsdTreeNode
  {
  
      /**
       * Event when a node is created. This event is always thrown by the root of the data structure. Listeners should register
       * with the root.
       */
      public static final EventType NODE_CREATED = new EventType("NODECREATED",
              new MetaData("Node created", "Created tree node",
                      new ObjectDescriptor("Node created", "Created tree node", XsdTreeNode.class),
                      new ObjectDescriptor("Parent", "Parent node", XsdTreeNode.class),
                      new ObjectDescriptor("Index", "Index where it is in the parent", Integer.class)));
  
      /**
       * Event when a node is removed. Invoked for each individual node, including all child nodes of a node that a user removes.
       * This event is always thrown by the root of the data structure. Listeners should register with the root.
       */
      public static final EventType NODE_REMOVED = new EventType("NODEREMOVED",
              new MetaData("Node removed", "Removed tree node",
                      new ObjectDescriptor("Node removed", "Removed tree node", XsdTreeNode.class),
                      new ObjectDescriptor("Parent", "Parent node", XsdTreeNode.class),
                      new ObjectDescriptor("Index", "Index where it was in the parent", Integer.class)));
  
      /** Directory, relevant for relative paths in include nodes. */
      private String directory;
  
      /** Whether validation should be ignored for the entire tree. */
      private final Supplier<Boolean> ignoreChanges;
  
      /** Eval supplier. */
      private final Supplier<Eval> evalSupplier;
  
      /**
       * Constructor for root node, based on a schema.
       * @param schema XSD Schema.
       * @param ignoreChanges whether to ignore changes
       * @param evalSupplier eval supplier
       * @throws RemoteException when unable to listen for created nodes.
       */
      public XsdTreeNodeRoot(final Schema schema, final Supplier<Boolean> ignoreChanges, final Supplier<Eval> evalSupplier)
              throws RemoteException
      {
          super(schema);
          this.ignoreChanges = ignoreChanges;
          this.evalSupplier = evalSupplier;
          // pointless to fire NODE_CREATED event, no one can be listening yet
          setupXPathListener(schema);
      }
  
      /**
       * Returns the directory.
       * @return directory.
       */
      public String getDirectory()
      {
          return this.directory;
      }
  
      /**
       * Set the directory.
       * @param directory directory.
       */
      public void setDirectory(final String directory)
     {
         if (Objects.equals(this.directory, directory))
         {
             return;
         }
         this.directory = directory;
         // invalidate entire tree, as saving may trigger relative paths to includes to become ok, causing types to be found
         invalidateAll();
     }
 
     @Override
     public XsdTreeNodeRoot getRoot()
     {
         return this;
     }
 
     /**
      * Returns the evaluator.
      * @return evaluator
      */
     public Eval getEval()
     {
         return this.evalSupplier.get();
     }
 
     /**
      * {@inheritDoc} Overridden to throw events on existing nodes to the listener.
      */
     @Override
     public boolean addListener(final EventListener listener, final EventType eventType, final int position,
             final ReferenceType referenceType)
     {
         if (NODE_CREATED.equals(eventType))
         {
             try
             {
                 XsdTreeNodeUtil.fireCreatedEventOnExistingNodes(this, listener);
             }
             catch (RemoteException exception)
             {
                 throw new OtsRuntimeException("Unexpected remote exception in local context.", exception);
             }
         }
         return super.addListener(listener, eventType, position, referenceType);
     }
 
     /**
      * Sets up the listener that reports on new and removed nodes for each xsd:key, xsd:keyref and xsd:unique. It is up to each
      * key to determine whether the node is relevant for the key.
      * @param schema schema.
      * @throws RemoteException when unable to listen for created nodes.
      */
     private void setupXPathListener(final Schema schema) throws RemoteException
     {
         Set<KeyValidator> keys = new LinkedHashSet<>();
         for (Entry<String, Node> entry : schema.keys().entrySet())
         {
             String path = entry.getKey().substring(0, entry.getKey().lastIndexOf("."));
             keys.add(new KeyValidator(entry.getValue(), path, this.ignoreChanges));
         }
         Set<KeyValidator> uniques = new LinkedHashSet<>();
         for (Entry<String, Node> entry : schema.uniques().entrySet())
         {
             String path = entry.getKey().substring(0, entry.getKey().lastIndexOf("."));
             uniques.add(new KeyValidator(entry.getValue(), path, this.ignoreChanges));
         }
         Set<KeyrefValidator> keyrefs = new LinkedHashSet<>();
         for (Entry<String, Node> entry : schema.keyrefs().entrySet())
         {
             String keyName = DocumentReader.getAttribute(entry.getValue(), "refer").get().replace("ots:", "");
             for (KeyValidator key : keys)
             {
                 if (key.getKeyName().equals(keyName))
                 {
                     String path = entry.getKey().substring(0, entry.getKey().lastIndexOf("."));
                     keyrefs.add(new KeyrefValidator(entry.getValue(), path, key, this.ignoreChanges));
                     break;
                 }
             }
             for (KeyValidator unique : uniques)
             {
                 if (unique.getKeyName().equals(keyName))
                 {
                     String path = entry.getKey().substring(0, entry.getKey().lastIndexOf("."));
                     keyrefs.add(new KeyrefValidator(entry.getValue(), path, unique, this.ignoreChanges));
                     break;
                 }
             }
         }
 
         EventListener listener = new EventListener()
         {
             @Override
             public void notify(final Event event)
             {
                 // loop keys, keyrefs and uniques to add or remove the node (key, keyref or unique determines node relevance).
                 int iteration = 0;
                 Set<? extends XPathValidator> keysIteration = keys;
                 XsdTreeNode node = (XsdTreeNode) ((Object[]) event.getContent())[0];
                 while (iteration < 3)
                 {
                     for (XPathValidator key : keysIteration)
                     {
                         if (event.getType().equals(NODE_CREATED))
                         {
                             key.addNode(node);
                         }
                         else
                         {
                             key.removeNode(node);
                         }
                     }
                     keysIteration = iteration == 0 ? keyrefs : uniques;
                     iteration++;
                 }
             }
         };
 
         addListener(listener, NODE_CREATED);
         addListener(listener, NODE_REMOVED);
     }
 
 }