XsdTreeNodeRoot

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 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-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 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;

    /**
     * Constructor for root node, based on a schema.
     * @param schema XSD Schema.
     * @throws RemoteException when unable to listen for created nodes.
     */
    public XsdTreeNodeRoot(final Schema schema) throws RemoteException
    {
        super(schema);
        // 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;
    }

    /**
     * {@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));
        }
        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));
        }
        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));
                    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));
                    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);
    }

}