package jmri.jmrit.entryexit;

import java.awt.Color;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyVetoException;
import java.util.*;
import java.util.Map.Entry;

import javax.annotation.CheckReturnValue;
import javax.annotation.Nonnull;
import javax.annotation.OverridingMethodsMustInvokeSuper;
import javax.swing.JDialog;
import javax.swing.JPanel;

import jmri.*;
import jmri.beans.VetoableChangeSupport;
import jmri.jmrit.display.EditorManager;
import jmri.jmrit.display.layoutEditor.LayoutBlock;
import jmri.jmrit.display.layoutEditor.LayoutBlockConnectivityTools;
import jmri.jmrit.display.layoutEditor.LayoutBlockManager;
import jmri.jmrit.display.layoutEditor.LayoutEditor;
import jmri.jmrix.internal.InternalSystemConnectionMemo;
import jmri.util.ThreadingUtil;
import jmri.util.swing.JmriJOptionPane;

/**
 * Implements an Entry Exit based method of setting turnouts, setting up signal
 * logic and allocating blocks through a path based on the Layout Editor.
 * <p>
 * The route is based upon having a sensor assigned at a known location on the
 * panel (set at the boundary of two different blocks) through to a sensor at a
 * remote location on the same panel. Using the layout block routing, a path can
 * then be set between the two sensors so long as one exists and no
 * section of track is set occupied. If available an alternative route will be
 * used when the direct path is occupied (blocked).
 * <p>
 * Initial implementation only handles the setting up of turnouts on a path.
 *
 * @author Kevin Dickerson Copyright (C) 2011
 */
public class EntryExitPairs extends VetoableChangeSupport implements Manager<DestinationPoints>, jmri.InstanceManagerAutoDefault,
        PropertyChangeListener {

    public LayoutBlockConnectivityTools.Metric routingMethod = LayoutBlockConnectivityTools.Metric.METRIC;

    public static final int NXBUTTONSELECTED = 0x08;
    public static final int NXBUTTONACTIVE = Sensor.ACTIVE;
    public static final int NXBUTTONINACTIVE = Sensor.INACTIVE;
    private final SystemConnectionMemo memo;
    private final Map<String, Boolean> silencedProperties = new HashMap<>();

    private int settingTimer = 2000;

    public int getSettingTimer() {
        return settingTimer;
    }

    public void setSettingTimer(int i) {
        settingTimer = i;
    }

    private Color settingRouteColor = null;

    public boolean useDifferentColorWhenSetting() {
        return (settingRouteColor != null);
    }

    public Color getSettingRouteColor() {
        return settingRouteColor;
    }

    public void setSettingRouteColor(Color col) {
        settingRouteColor = col;
    }

    /**
     * Constant value to represent that the entryExit will only set up the
     * turnouts between two different points.
     */
    public static final int SETUPTURNOUTSONLY = 0x00;

    /**
     * Constant value to represent that the entryExit will set up the turnouts
     * between two different points and configure the Signal Mast Logic to use
     * the correct blocks.
     */
    public static final int SETUPSIGNALMASTLOGIC = 0x01;

    /**
     * Constant value to represent that the entryExit will do full interlocking.
     * It will set the turnouts and "reserve" the blocks.
     */
    public static final int FULLINTERLOCK = 0x02;

    boolean allocateToDispatcher = false;
    boolean absSignalMode = false;
    boolean quietFail = false;      // Suppress the dialog when a route allocation fails.
    boolean skipGuiFix = false;     // Hold back NX button clicks while a route is set.  This keeps double-click chaining.

    public static final int PROMPTUSER = 0x00;
    public static final int AUTOCLEAR = 0x01;
    public static final int AUTOCANCEL = 0x02;
    public static final int AUTOSTACK = 0x03;

    public static final int OVERLAP_CANCEL = 0x01;
    public static final int OVERLAP_STACK = 0x02;

    /**
     * String constant for auto generate complete.
     */
    public static final String PROPERTY_AUTO_GENERATE_COMPLETE = "autoGenerateComplete";

    /**
     * String constant for active.
     */
    public static final String PROPERTY_ACTIVE = "active";

    int routeClearOption = PROMPTUSER;
    int routeOverlapOption = PROMPTUSER;
    String memoryOption = "";     // Optional memory variable to receive allocation messages
    int memoryClearDelay = 0;     // Delay before clearing memory, 0 for clearing disabled

    private final JPanel glassPane = new JPanel();

    /**
     * Delay between issuing Turnout commands
     */
    public int turnoutSetDelay = 0;

    /**
     * Constructor for creating an EntryExitPairs object and create a transparent JPanel for it.
     */
    public EntryExitPairs() {
        memo = InstanceManager.getDefault(InternalSystemConnectionMemo.class);
        InstanceManager.getOptionalDefault(ConfigureManager.class).ifPresent(cm -> cm.registerUser(this));
        InstanceManager.getDefault(LayoutBlockManager.class).addPropertyChangeListener(propertyBlockManagerListener);

        glassPane.setOpaque(false);
        glassPane.setLayout(null);
        glassPane.addMouseListener(new MouseAdapter() {
            @Override
            public void mousePressed(MouseEvent e) {
                e.consume();
            }
        });
    }

    public void setDispatcherIntegration(boolean boo) {
        allocateToDispatcher = boo;
    }

    public boolean getDispatcherIntegration() {
        return allocateToDispatcher;
    }

    public void setAbsSignalMode(boolean absMode) {
        absSignalMode = absMode;
    }

    public boolean isAbsSignalMode() {
        return absSignalMode;
    }

    public void setQuietFail(boolean quiet) {
        quietFail = quiet;
    }

    public boolean isQuietFail() {
        return quietFail;
    }

    public void setSkipGuiFix(boolean skip) {
        skipGuiFix = skip;
    }

    public boolean isSkipGuiFix() {
        return skipGuiFix;
    }

    /**
     * Get the transparent JPanel for this EntryExitPairs.
     * @return JPanel overlay
     */
    public JPanel getGlassPane() {
        return glassPane;
    }

    HashMap<PointDetails, Source> nxpair = new HashMap<>();

    public void addNXSourcePoint(LayoutBlock facing, List<LayoutBlock> protecting, NamedBean loc, LayoutEditor panel) {
        PointDetails point = providePoint(facing, protecting, panel);
        point.setRefObject(loc);
    }

    public void addNXSourcePoint(NamedBean source) {
        PointDetails point = null;
        for (LayoutEditor editor : InstanceManager.getDefault(EditorManager.class).getAll(LayoutEditor.class)) {
            point = providePoint(source, editor);
        }
        if (point == null) {
            log.error("Unable to find a location on any panel for item {}", source.getDisplayName());  // NOI18N
        }
    }

    public void addNXSourcePoint(NamedBean source, LayoutEditor panel) {
        if (source == null) {
            log.error("source bean supplied is null");  // NOI18N
            return;
        }
        if (panel == null) {
            log.error("panel supplied is null");  // NOI18N
            return;
        }
        PointDetails point;
        point = providePoint(source, panel);
        if (point == null) {
            log.error("Unable to find a location on the panel {} for item {}",
                panel.getLayoutName(), source.getDisplayName());
        }
    }

    public Object getEndPointLocation(NamedBean source, LayoutEditor panel) {
        if (source == null) {
            log.error("Source bean past is null");  // NOI18N
            return null;
        }
        if (panel == null) {
            log.error("panel passed is null");  // NOI18N
            return null;
        }
        PointDetails sourcePoint = getPointDetails(source, panel);
        if (sourcePoint == null) {
            log.error("Point is not located");  // NOI18N
            return null;
        }
        return sourcePoint.getRefLocation();
    }

    /** {@inheritDoc} */
    @Override
    public int getXMLOrder() {
        return ENTRYEXIT;
    }

    /** {@inheritDoc} */
    @Override
    public DestinationPoints getBySystemName(String systemName) {
        for (Source e : nxpair.values()) {
            DestinationPoints pd = e.getByUniqueId(systemName);
            if (pd != null) {
                return pd;
            }
        }
        return null;
    }

    /** {@inheritDoc} */
    @Override
    public DestinationPoints getByUserName(@Nonnull String userName) {
        for (Source e : nxpair.values()) {
            DestinationPoints pd = e.getByUserName(userName);
            if (pd != null) {
                return pd;
            }
        }
        return null;
    }

    /** {@inheritDoc} */
    @Override
    public DestinationPoints getNamedBean(@Nonnull String name) {
        DestinationPoints b = getByUserName(name);
        if (b != null) {
            return b;
        }
        return getBySystemName(name);
    }

    /** {@inheritDoc} */
    @Nonnull
    @Override
    public SystemConnectionMemo getMemo() {
        return memo;
    }

    /** {@inheritDoc} */
    @Override
    @Nonnull
    public String getSystemPrefix() {
        return memo.getSystemPrefix();
    }

    /** {@inheritDoc} */
    @Override
    public char typeLetter() {
        throw new UnsupportedOperationException("Not supported yet.");  // NOI18N
    }

    /** {@inheritDoc} */
    @Override
    @Nonnull
    public String makeSystemName(@Nonnull String s) {
        throw new UnsupportedOperationException("Not supported yet.");  // NOI18N
    }

    /** {@inheritDoc} */
    @Override
    @CheckReturnValue
    public int getObjectCount() {
        return getNamedBeanSet().size();
    }

    /**
     * Implemented to support the Conditional combo box name list
     * @since 4.9.3
     * @return a list of Destination Point beans
     */
    @Override
    @Nonnull
    public SortedSet<DestinationPoints> getNamedBeanSet() {
        TreeSet<DestinationPoints> beanList = new TreeSet<>(new jmri.util.NamedBeanComparator<>());
        for (Source e : nxpair.values()) {
            List<String> uidList = e.getDestinationUniqueId();
            for (String uid : uidList) {
                beanList.add(e.getByUniqueId(uid));
            }
        }
        return beanList;
    }

    /** {@inheritDoc} */
    @Override
    public void register(@Nonnull DestinationPoints n) {
        throw new UnsupportedOperationException("Not supported yet.");  // NOI18N
    }

    /** {@inheritDoc} */
    @Override
    public void deregister(@Nonnull DestinationPoints n) {
        throw new UnsupportedOperationException("Not supported yet.");  // NOI18N
    }

    public void setClearDownOption(int i) {
        routeClearOption = i;
    }

    public int getClearDownOption() {
        return routeClearOption;
    }

    public void setOverlapOption(int i) {
        routeOverlapOption = i;
    }

    public int getOverlapOption() {
        return routeOverlapOption;
    }

    public void setMemoryOption(String memoryName) {
        memoryOption = memoryName;
    }

    public String getMemoryOption() {
        return memoryOption;
    }

    public void setMemoryClearDelay(int secs) {
        memoryClearDelay = secs;
    }

    public int getMemoryClearDelay() {
        return memoryClearDelay;
    }

    /** {@inheritDoc} */
    @Override
    public void dispose() {
        InstanceManager.getDefault(LayoutBlockManager.class).removePropertyChangeListener(propertyBlockManagerListener);
    }

    /**
     * Generate the point details, given a known source and a
     * Layout Editor panel.
     *
     * @param source Origin of movement
     * @param panel  A Layout Editor panel
     * @return A PointDetails object
     */
    public PointDetails providePoint(NamedBean source, LayoutEditor panel) {
        PointDetails sourcePoint = getPointDetails(source, panel);
        if (sourcePoint == null) {
            LayoutBlock facing = InstanceManager.getDefault(jmri.jmrit.display.layoutEditor.LayoutBlockManager.class).getFacingBlockByNamedBean(source, null);
            List<LayoutBlock> protecting = InstanceManager.getDefault(jmri.jmrit.display.layoutEditor.LayoutBlockManager.class).getProtectingBlocksByNamedBean(source, null);
//             log.info("facing = {}, protecting = {}", facing, protecting);
            if (facing == null && protecting.isEmpty()) {
                log.error("Unable to find facing and protecting blocks");  // NOI18N
                return null;
            }
            sourcePoint = providePoint(facing, protecting, panel);
            sourcePoint.setRefObject(source);
        }
        return sourcePoint;
    }

    /**
     * Return a list of all source (origin) points on a given
     * Layout Editor panel.
     *
     * @param panel  A Layout Editor panel
     * @return A list of source objects
     */
    public List<Object> getSourceList(LayoutEditor panel) {
        List<Object> list = new ArrayList<>();

        for (Entry<PointDetails, Source> e : nxpair.entrySet()) {
            Object obj = (e.getKey()).getRefObject();
            LayoutEditor pan = (e.getKey()).getPanel();
            if (pan == panel && !list.contains(obj)) {
                list.add(obj);
            }
        }
        return list;
    }

    public Source getSourceForPoint(PointDetails pd) {
        return nxpair.get(pd);
    }

    public int getNxPairNumbers(LayoutEditor panel) {
        int total = 0;
        for (Entry<PointDetails, Source> e : nxpair.entrySet()) {
            PointDetails key = e.getKey();
            LayoutEditor pan = key.getPanel();
            if (pan == panel) {
                total += e.getValue().getNumberOfDestinations();
            } // end while
        }

        return total;
    }

    /**
     * Set a reversed route between two points.  Special case to support a LogixNG action.
     * @since 5.5.7
     * @param nxPair The system or user name of the destination point.
     */
    public void setReversedRoute(String nxPair) {
        DestinationPoints dp = getNamedBean(nxPair);
        if (dp != null) {
            String destUUID = dp.getUniqueId();
            nxpair.forEach((pd, src) -> {
                for (String srcUUID : src.getDestinationUniqueId()) {
                    if (destUUID.equals(srcUUID)) {
                        log.debug("Found the correct reverse route source: src = {}, dest = {}",
                                pd.getSensor().getDisplayName(), dp.getDestPoint().getSensor().getDisplayName());
                        int ref = nextRef();
                        addRoutesToSet(Collections.singletonList(new SourceToDest(src, dp, true, ref)));
                        processRoutesToSet(ref);
                        return;
                    }
                }
            });
        }
    }

    /**
     * Set the route between the two points represented by the Destination Point name.
     *
     * @since 4.11.1
     * @param nxPair The system or user name of the destination point.
     */
    public void setSingleSegmentRoute(String nxPair) {
        DestinationPoints dp = getNamedBean(nxPair);
        if (dp != null) {
            String destUUID = dp.getUniqueId();
            nxpair.forEach((pd, src) -> {
                for (String srcUUID : src.getDestinationUniqueId()) {
                    if (destUUID.equals(srcUUID)) {
                        log.debug("Found the correct source: src = {}, dest = {}",
                                pd.getSensor().getDisplayName(), dp.getDestPoint().getSensor().getDisplayName());
                        setMultiPointRoute(pd, dp.getDestPoint());
                        return;
                    }
                }
            });
        }
    }

    public void setMultiPointRoute(PointDetails requestpd, LayoutEditor panel) {
        for (PointDetails pd : pointDetails) {
            if ( pd != requestpd && pd.getNXState() == NXBUTTONSELECTED ) {
                setMultiPointRoute(pd, requestpd);
                return;
            }
        }
    }

    private void setMultiPointRoute(PointDetails fromPd, PointDetails toPd) {
        log.debug("[setMultiPointRoute] Start, from = {}, to = {}", fromPd.getSensor().getDisplayName(), toPd.getSensor().getDisplayName());
        boolean cleardown = false;
        if (fromPd.isRouteFromPointSet() && toPd.isRouteToPointSet()) {
            cleardown = true;
        }
        for (LayoutBlock pro : fromPd.getProtecting()) {
            try {
                jmri.jmrit.display.layoutEditor.LayoutBlockManager lbm = InstanceManager.getDefault(
                    jmri.jmrit.display.layoutEditor.LayoutBlockManager.class);
                LayoutBlock toProt = null;
                if (!toPd.getProtecting().isEmpty()) {
                    toProt = toPd.getProtecting().get(0);
                }
                log.trace("Calling checkValidDest");
                boolean result = lbm.getLayoutBlockConnectivityTools().checkValidDest(
                    fromPd.getFacing(), pro, toPd.getFacing(), toProt,
                        LayoutBlockConnectivityTools.Routing.NONE); // Was SENSORTOSENSOR, needs to be consistent with three lines below
                                                                    // See also around line 353 in LayoutBlockConnectivityTools
                log.trace("         checkValidDest returned {}", result);
                if (result) {
                    List<LayoutBlock> blkList = lbm.getLayoutBlockConnectivityTools().getLayoutBlocks(fromPd.getFacing(), toPd.getFacing(), pro, cleardown, LayoutBlockConnectivityTools.Routing.NONE);
                    if (!blkList.isEmpty()) {
                        if (log.isDebugEnabled()) {
                            log.debug("[setMultiPointRoute] blocks and sensors");
                            for (LayoutBlock blk : blkList) {
                                log.debug("  blk = {}", blk.getDisplayName());
                            }
                        }
                        List<jmri.NamedBean> beanList = lbm.getLayoutBlockConnectivityTools().getBeansInPath(blkList, null, jmri.Sensor.class);
                        PointDetails fromPoint = fromPd;
                        int ref = nextRef();
                        List<SourceToDest> toSet = new ArrayList<>();
                        if (!beanList.isEmpty()) {
                            if (log.isDebugEnabled()) {
                                for (NamedBean xnb : beanList) {
                                    log.debug("  sensor = {}", xnb.getDisplayName());
                                }
                            }
                            for (int i = 1; i < beanList.size(); i++) {
                                NamedBean nb = beanList.get(i);
                                PointDetails cur = getPointDetails(nb, fromPd.getPanel());
                                Source s = nxpair.get(fromPoint);
                                if (s != null) {
                                    toSet.add(new SourceToDest(s, s.getDestForPoint(cur), false, ref));
                                }
                                fromPoint = cur;
                            }
                        }
                        Source s = nxpair.get(fromPoint);
                        if (s != null) {
                            if (s.getDestForPoint(toPd) != null) {
                                toSet.add(new SourceToDest(s, s.getDestForPoint(toPd), false, ref));
                            }
                        }
                        log.debug("[setMultiPointRoute] Invoke processRoutesToSet");
                        addRoutesToSet(toSet);
                        processRoutesToSet(ref);
                        log.debug("[setMultiPointRoute] processRoutesToSet is done");
                        return;
                    }
                }
            } catch (jmri.JmriException e) {
                log.debug("setMultiPointRoute catches exception", e);
                // Can be considered normal if route is blocked
                if (!isQuietFail()) {
                    JmriJOptionPane.showMessageDialog(null,
                            Bundle.getMessage("MultiPointBlocked"),  // NOI18N
                            Bundle.getMessage("WarningTitle"),  // NOI18N
                            JmriJOptionPane.WARNING_MESSAGE);
                }
            }
        }
        fromPd.setNXButtonState(NXBUTTONINACTIVE);
        toPd.setNXButtonState(NXBUTTONINACTIVE);
        log.debug("[setMultiPointRoute] Done, from = {}, to = {}", fromPd.getSensor().getDisplayName(), toPd.getSensor().getDisplayName());
    }

    int refCounter = 0;

    /**
     * Get the reference for a new request to set a route.
     *
     * @return the reference
     */
    private synchronized int nextRef() {
        return ++refCounter;
    }

    /**
     * Add the SourceToDest sets of a request to routesToSet.
     *
     * @param routes the SourceToDest sets, in the order they are to be set
     */
    private synchronized void addRoutesToSet(List<SourceToDest> routes) {
        routesToSet.addAll(routes);
    }

    /**
     * List holding SourceToDest sets of routes between two points.
     */
    List<SourceToDest> routesToSet = new ArrayList<>();

    /**
     * Class to store NX sets consisting of a source point, a destination point,
     * a direction and a reference.
     */
    private static class SourceToDest {

        Source s = null;
        DestinationPoints dp = null;
        boolean direction = false;
        int ref = -1;

        /**
         * Constructor for a SourceToDest element.
         *
         * @param s   a source point
         * @param dp  a destination point
         * @param dir a direction
         * @param ref Integer used as reference
         */
        SourceToDest(Source s, DestinationPoints dp, boolean dir, int ref) {
            this.s = s;
            this.dp = dp;
            this.direction = dir;
            this.ref = ref;
        }
    }

    /**
     * The request each destination point is currently setting a route for.
     */
    private final Map<DestinationPoints, Integer> routesInProgress = new HashMap<>();

    /**
     * Activate the next SourceToDest set of a request in routesToSet.
     * <p>
     * The set is taken from the list under the lock, but it is activated
     * outside it, as activating it can show a dialog and locks the destination
     * point.
     *
     * @param ref the reference of the request
     */
    void processRoutesToSet(int ref) {
        SourceToDest next = null;
        synchronized (this) {
            if (log.isDebugEnabled()) {
                log.debug("[processRoutesToSet] Current routesToSet list");
                for (SourceToDest sd : routesToSet) {
                    String dpName = (sd.dp == null) ? "- null -" : sd.dp.getDestPoint().getSensor().getDisplayName();
                    log.debug("  from = {}, to = {}, ref = {}", sd.s.getPoint().getSensor().getDisplayName(), dpName, sd.ref);
                }
            }

            for (SourceToDest sd : routesToSet) {
                if (sd.ref == ref) {
                    next = sd;
                    break;
                }
            }
            if (next == null) {
                return;
            }
            routesToSet.remove(next);
            if (next.dp != null) {
                routesInProgress.put(next.dp, ref);
            }
        }
        if (next.dp == null) {
            removeRemainingRoute(ref);
            return;
        }
        next.s.activeBean(next.dp, next.direction);
    }

    /**
     * Remove remaining SourceToDest sets of a request in routesToSet
     *
     * @param ref the reference of the request
     */
    void removeRemainingRoute(int ref) {
        List<SourceToDest> toRemove = new ArrayList<>();
        synchronized (this) {
            for (SourceToDest rts : routesToSet) {
                if (rts.ref == ref) {
                    toRemove.add(rts);
                }
            }
            routesToSet.removeAll(toRemove);
        }
        for (SourceToDest rts : toRemove) {
            if (rts.dp != null) {
                rts.dp.getDestPoint().setNXButtonState(NXBUTTONINACTIVE);
            }
        }
    }

    /**
     * Called by a destination point when it has finished handling a request
     * to set or clear down its route. When the route is part of a route over
     * several NX pairs, the next pair is handled on the layout thread if this
     * route has been set or cleared down, otherwise the rest of the request is
     * dropped.
     *
     * @param dp      the destination point
     * @param success true if the route has been set or cleared down
     */
    void routeSettingDone(DestinationPoints dp, boolean success) {
        Integer ref;
        synchronized (this) {
            ref = routesInProgress.remove(dp);
        }
        if (ref == null) {
            return;
        }
        int request = ref;
        if (success) {
            ThreadingUtil.runOnLayoutEventually(() -> processRoutesToSet(request));
        } else {
            removeRemainingRoute(request);
        }
    }

    /**
     * Number of routes whose turnouts are being set.
     */
    private int routesBeingSet = 0;

    /**
     * NX button clicks held back until no route is being set.
     */
    private final List<Runnable> heldButtonClicks = new ArrayList<>();

    /**
     * Called by a destination point when it starts to set its route.
     */
    synchronized void routeSettingStarted() {
        routesBeingSet++;
    }

    /**
     * Called by a destination point when it has finished setting its route,
     * after the result has been reported with routeSettingDone. When no other
     * route is being set, the NX button clicks held back are handled on the
     * layout thread, in the order they happened.
     */
    void routeSettingFinished() {
        List<Runnable> held;
        synchronized (this) {
            routesBeingSet--;
            if (routesBeingSet > 0 || heldButtonClicks.isEmpty()) {
                return;
            }
            held = new ArrayList<>(heldButtonClicks);
            heldButtonClicks.clear();
        }
        ThreadingUtil.runOnLayoutEventually(() -> held.forEach(Runnable::run));
    }

    /**
     * With the old GUI behavior, hold back a click on an NX button while a
     * route is being set. The panel used to wait until the turnouts of a route
     * were set, so a second click on the destination button was handled after
     * the route had been set and started the next route instead of cancelling
     * this one. The turnouts are now set without making the panel wait, so the
     * click is held back until the route has been set. Held clicks are handled
     * in the order they happened.
     *
     * @param click the handling of the click, run later if it is held back
     * @return true if the click has been held back
     */
    synchronized boolean holdButtonClick(Runnable click) {
        if (!skipGuiFix || routesBeingSet == 0) {
            return false;
        }
        heldButtonClicks.add(click);
        return true;
    }

    /**
     * Check if a request to set a route is still being handled.
     *
     * @return true if a route is being set or a route over several NX pairs
     *         has pairs left to set
     */
    synchronized boolean isSettingRoutes() {
        return routesBeingSet > 0 || !routesInProgress.isEmpty() || !routesToSet.isEmpty();
    }

    private List<Object> destinationList = new ArrayList<>();

    // Need to sort out the presentation of the name here rather than using the point ID.
    // This is used for the creation and display of information in the table.
    // The presentation of the name might have to be done at the table level.
    public List<Object> getNxSource(LayoutEditor panel) {
        List<Object> source = new ArrayList<>();
        destinationList = new ArrayList<>();

        for (Entry<PointDetails, Source> e : nxpair.entrySet()) {
            PointDetails key = e.getKey();
            LayoutEditor pan = key.getPanel();
            if (pan == panel) {
                List<PointDetails> dest = nxpair.get(key).getDestinationPoints();
                for (int i = 0; i < dest.size(); i++) {
                    destinationList.add(dest.get(i).getRefObject());
                    source.add(key.getRefObject());
                }
            }
        }
        return source;
    }

    public List<Object> getNxDestination() {
        return destinationList;
    }

    public List<LayoutEditor> getSourcePanelList() {
        List<LayoutEditor> list = new ArrayList<>();

        for (Entry<PointDetails, Source> e : nxpair.entrySet()) {
            PointDetails key = e.getKey();
            LayoutEditor pan = key.getPanel();
            if (!list.contains(pan)) {
                list.add(pan);
            }
        }
        return list;
    }

    /**
     * Return a point if it already exists, or create a new one if not.
     */
    private PointDetails providePoint(LayoutBlock source, List<LayoutBlock> protecting, LayoutEditor panel) {
        PointDetails sourcePoint = getPointDetails(source, protecting, panel);
        if (sourcePoint == null) {
            sourcePoint = new PointDetails(source, protecting);
            sourcePoint.setPanel(panel);
        }
        return sourcePoint;
    }

    /**
     * @since 4.17.4
     */
    @Override
    public void propertyChange(PropertyChangeEvent evt) {
        firePropertyChange(PROPERTY_ACTIVE, evt.getOldValue(), evt.getNewValue());
    }


    public void addNXDestination(NamedBean source, NamedBean destination, LayoutEditor panel) {
        addNXDestination(source, destination, panel, null);
    }

    /**
     * @since 4.17.4
     * Register in Property Change Listener.
     * @param source the source bean.
     * @param destination the destination bean.
     * @param panel the layout editor panel.
     * @param id the points details id.
     */
    public void addNXDestination(NamedBean source, NamedBean destination, LayoutEditor panel, String id) {
        if (source == null) {
            log.error("no source Object provided");  // NOI18N
            return;
        }
        if (destination == null) {
            log.error("no destination Object provided");  // NOI18N
            return;
        }
        PointDetails sourcePoint = providePoint(source, panel);
        if (sourcePoint == null) {
            log.error("source point for {} not created addNXDes", source.getDisplayName());  // NOI18N
            return;
        }

        sourcePoint.setPanel(panel);
        sourcePoint.setRefObject(source);
        PointDetails destPoint = providePoint(destination, panel);
        if (destPoint != null) {
            destPoint.setPanel(panel);
            destPoint.setRefObject(destination);
            destPoint.getSignal();
            if (!nxpair.containsKey(sourcePoint)) {
                Source sp = new Source(sourcePoint);
                nxpair.put(sourcePoint, sp);
                sp.removePropertyChangeListener(this);
                sp.addPropertyChangeListener(this);
            }
            nxpair.get(sourcePoint).addDestination(destPoint, id);
        }

        firePropertyChange(PROPERTY_LENGTH, null, null);
    }

    public List<Object> getDestinationList(Object obj, LayoutEditor panel) {
        List<Object> list = new ArrayList<>();
        if (nxpair.containsKey(getPointDetails(obj, panel))) {
            List<PointDetails> from = nxpair.get(getPointDetails(obj, panel)).getDestinationPoints();
            for (int i = 0; i < from.size(); i++) {
                list.add(from.get(i).getRefObject());
            }
        }
        return list;
    }

    public void removeNXSensor(Sensor sensor) {
        log.info("panel maintenance has resulting in the request to remove a sensor: {}", sensor.getDisplayName());
    }

    // ============ NX Pair Delete Methods ============
    // The request will be for all NX Pairs containing a sensor or
    // a specific entry and exit sensor pair.

    /**
     * Entry point to delete all of the NX pairs for a specific sensor.
     * 1) Build a list of affected NX pairs.
     * 2) Check for Conditional references.
     * 3) If no references, do the delete process with user approval.
     * @since 4.11.2
     * @param sensor The sensor whose pairs should be deleted.
     * @return true if the delete was successful. False if prevented by
     * Conditional/LogixNG references or user choice.
     */
    public boolean deleteNxPair(NamedBean sensor) {
        if (sensor == null) {
            log.error("deleteNxPair: sensor is null");  // NOI18N
            return false;
        }
        createDeletePairList(sensor);
        if (checkNxPairs() && checkLogixNG()) {
            // No Conditional or LogixNG references.
            if (confirmDeletePairs()) {
                deleteNxPairs();
                return true;
            }
        }
        return false;
    }

    /**
     * Entry point to delete a specific NX pair.
     *
     * @since 4.11.2
     * @param entrySensor The sensor that acts as the entry point.
     * @param exitSensor The sensor that acts as the exit point.
     * @param panel The layout editor panel that contains the entry sensor.
     * @return true if the delete was successful. False if there are Conditional/LogixNG references.
     */
    public boolean deleteNxPair(NamedBean entrySensor, NamedBean exitSensor, LayoutEditor panel) {
        if (entrySensor == null || exitSensor == null || panel == null) {
            log.error("deleteNxPair: One or more null inputs");  // NOI18N
            return false;
        }

        deletePairList.clear();
        deletePairList.add(new DeletePair(entrySensor, exitSensor, panel));
        if (checkNxPairs() && checkLogixNG()) {
            // No Conditional or LogixNG references.
            deleteNxPairs();  // Delete with no prompt
            return true;
        }

        return false;
    }

    /**
     * Find Logix Conditionals that have Variables or Actions for the affected NX Pairs.
     * If any are found, display a dialog box listing the Conditionals and return false.
     * <p>
     * @since 4.11.2
     * @return true if there are no references.
     */
    private boolean checkNxPairs() {
        jmri.LogixManager mgr = InstanceManager.getDefault(jmri.LogixManager.class);
        List<String> conditionalReferences = new ArrayList<>();
        for (DeletePair dPair : deletePairList) {
            if (dPair.dp == null) {
                continue;
            }
            for (jmri.Logix lgx : mgr.getNamedBeanSet()) {
                for (int i = 0; i < lgx.getNumConditionals(); i++) {
                    String cdlName = lgx.getConditionalByNumberOrder(i);
                    jmri.implementation.DefaultConditional cdl = (jmri.implementation.DefaultConditional) lgx.getConditional(cdlName);
                    String cdlUserName = cdl.getUserName();
                    if (cdlUserName == null) {
                        cdlUserName = "";
                    }
                    for (jmri.ConditionalVariable var : cdl.getStateVariableList()) {
                        if (var.getBean() == dPair.dp) {
                            String refName = (cdlUserName.equals("")) ? cdlName : cdlName + "  ( " + cdlUserName + " )";
                            if (!conditionalReferences.contains(refName)) {
                                conditionalReferences.add(refName);
                            }
                        }
                    }
                    for (jmri.ConditionalAction act : cdl.getActionList()) {
                        if (act.getBean() == dPair.dp) {
                            String refName = (cdlUserName.equals("")) ? cdlName : cdlName + "  ( " + cdlUserName + " )";
                            if (!conditionalReferences.contains(refName)) {
                                conditionalReferences.add(refName);
                            }
                        }
                    }
                }
            }
        }
        if (conditionalReferences.isEmpty()) {
            return true;
        }

        conditionalReferences.sort(null);
        StringBuilder msg = new StringBuilder(Bundle.getMessage("DeleteReferences"));
        for (String ref : conditionalReferences) {
            msg.append("\n    " + ref);  // NOI18N
        }
        JmriJOptionPane.showMessageDialog(null,
                msg.toString(),
                Bundle.getMessage("WarningTitle"),  // NOI18N
                JmriJOptionPane.WARNING_MESSAGE);

        return false;
    }

    /**
     * Find LogixNG ConditionalNGs that have Expressions or Actions for the affected NX Pairs.
     * If any are found, display a dialog box listing the details and return false.
     * <p>
     * @since 5.5.7
     * @return true if there are no references.
     */
    private boolean checkLogixNG() {
        List<String> conditionalReferences = new ArrayList<>();
        for (DeletePair dPair : deletePairList) {
            if (dPair.dp == null) {
                continue;
            }
            var usage = jmri.jmrit.logixng.util.WhereUsed.whereUsed(dPair.dp);
            if (!usage.isEmpty()) {
                conditionalReferences.add(usage);
            }
        }
        if (conditionalReferences.isEmpty()) {
            return true;
        }

        conditionalReferences.sort(null);
        StringBuilder msg = new StringBuilder(Bundle.getMessage("DeleteReferences"));
        for (String ref : conditionalReferences) {
            msg.append("\n" + ref);  // NOI18N
        }
        JmriJOptionPane.showMessageDialog(null,
                msg.toString(),
                Bundle.getMessage("WarningTitle"),  // NOI18N
                JmriJOptionPane.WARNING_MESSAGE);

        return false;
    }

    /**
     * Display a list of pending deletes and ask for confirmation.
     * @since 4.11.2
     * @return true if deletion confirmation is Yes.
     */
    private boolean confirmDeletePairs() {
        if (!deletePairList.isEmpty()) {
            StringBuilder msg = new StringBuilder(Bundle.getMessage("DeletePairs"));  // NOI18N
            for (DeletePair dPair : deletePairList) {
                if (dPair.dp != null) {
                    msg.append("\n    ").append(dPair.dp.getDisplayName());  // NOI18N
                }
            }
            msg.append("\n").append(Bundle.getMessage("DeleteContinue"));  // NOI18N
            int resp = JmriJOptionPane.showConfirmDialog(null,
                    msg.toString(),
                    Bundle.getMessage("WarningTitle"),  // NOI18N
                    JmriJOptionPane.YES_NO_OPTION,
                    JmriJOptionPane.QUESTION_MESSAGE);
            if (resp != JmriJOptionPane.YES_OPTION ) {
                return false;
            }
        }
        return true;
    }

    /**
     * Delete the pairs in the delete pair list.
     * @since 4.11.2
     * @since 4.17.4
     * Remove from Change Listener.
     */
    private void deleteNxPairs() {
        for (DeletePair dp : deletePairList) {
            PointDetails sourcePoint = getPointDetails(dp.src, dp.pnl);
            PointDetails destPoint = getPointDetails(dp.dest, dp.pnl);
            nxpair.get(sourcePoint).removeDestination(destPoint);
            firePropertyChange(PROPERTY_LENGTH, null, null);
            if (nxpair.get(sourcePoint).getDestinationPoints().isEmpty()) {
                nxpair.get(sourcePoint).removePropertyChangeListener(this);
                nxpair.remove(sourcePoint);
            }
        }
    }

    /**
     * List of NX pairs that are scheduled for deletion.
     * @since 4.11.2
     */
    List<DeletePair> deletePairList = new ArrayList<>();

    /**
     * Class to store NX pair components.
     * @since 4.11.2
     */
    private class DeletePair {
        NamedBean src = null;
        NamedBean dest = null;
        LayoutEditor pnl = null;
        DestinationPoints dp = null;

        /**
         * Constructor for a DeletePair row.
         *
         * @param src  Source sensor bean
         * @param dest Ddestination sensor bean
         * @param pnl  The LayoutEditor panel for the source bean
         */
        DeletePair(NamedBean src, NamedBean dest, LayoutEditor pnl) {
            this.src = src;
            this.dest = dest;
            this.pnl = pnl;

            // Get the actual destination point, if any.
            PointDetails sourcePoint = getPointDetails(src, pnl);
            PointDetails destPoint = getPointDetails(dest, pnl);
            if (sourcePoint != null && destPoint != null) {
                if (nxpair.containsKey(sourcePoint)) {
                    this.dp = nxpair.get(sourcePoint).getDestForPoint(destPoint);
                }
            }
        }
    }

    /**
     * Rebuild the delete pair list based on the supplied sensor.
     * Find all of the NX pairs that use this sensor as either a source or
     * destination.  They will be candidates for deletion.
     *
     * @since 4.11.2
     * @param sensor The sensor being deleted,
     */
    void createDeletePairList(NamedBean sensor) {
        deletePairList.clear();
        nxpair.forEach((pdSrc, src) -> {
            Sensor sBean = pdSrc.getSensor();
            LayoutEditor sPanel = pdSrc.getPanel();
            for (PointDetails pdDest : src.getDestinationPoints()) {
                Sensor dBean = pdDest.getSensor();
                if (sensor == sBean || sensor == dBean) {
                    log.debug("Delete pair: {} to {}, panel = {}",  // NOI18N
                            sBean.getDisplayName(), dBean.getDisplayName(), sPanel.getLayoutName());
                    deletePairList.add(new DeletePair(sBean, dBean, sPanel));
                }
            }
        });
    }

    // ============ End NX Pair Delete Methods ============

    /**
     * Create a list of sensors that have the layout block as either
     * facing or protecting.
     * Called by {@link jmri.jmrit.display.layoutEditor.LayoutEditorDialogs.LayoutTrackEditor#hasNxSensorPairs}.
     * @since 4.11.2
     * @param layoutBlock The layout block to be checked.
     * @return the a list of sensors affected by the layout block or an empty list.
     */
    public List<String> layoutBlockSensors(@Nonnull LayoutBlock layoutBlock) {
        log.debug("layoutBlockSensors: {}", layoutBlock.getDisplayName());
        List<String> blockSensors = new ArrayList<>();
        nxpair.forEach((pdSrc, src) -> {
            Sensor sBean = pdSrc.getSensor();
            for (LayoutBlock sProtect : pdSrc.getProtecting()) {
                if (layoutBlock == pdSrc.getFacing() || layoutBlock == sProtect) {
                    log.debug("  Source = '{}', Facing = '{}', Protecting = '{}'         ",
                            sBean.getDisplayName(), pdSrc.getFacing().getDisplayName(), sProtect.getDisplayName());
                    blockSensors.add(sBean.getDisplayName());
                }
            }

            for (PointDetails pdDest : src.getDestinationPoints()) {
                Sensor dBean = pdDest.getSensor();
                for (LayoutBlock dProtect : pdDest.getProtecting()) {
                    if (layoutBlock == pdDest.getFacing() || layoutBlock == dProtect) {
                        log.debug("    Destination = '{}', Facing = '{}', Protecting = '{}'     ",
                                dBean.getDisplayName(), pdDest.getFacing().getDisplayName(), dProtect.getDisplayName());
                        blockSensors.add(dBean.getDisplayName());
                    }
                }
            }
        });
        return blockSensors;
    }

    public boolean isDestinationValid(Object source, Object dest, LayoutEditor panel) {
        if (nxpair.containsKey(getPointDetails(source, panel))) {
            return nxpair.get(getPointDetails(source, panel)).isDestinationValid(getPointDetails(dest, panel));
        }
        return false;
    }

    public boolean isUniDirection(Object source, LayoutEditor panel, Object dest) {
        if (nxpair.containsKey(getPointDetails(source, panel))) {
            return nxpair.get(getPointDetails(source, panel)).getUniDirection(dest, panel);
        }
        return false;
    }

    public void setUniDirection(Object source, LayoutEditor panel, Object dest, boolean set) {
        if (nxpair.containsKey(getPointDetails(source, panel))) {
            nxpair.get(getPointDetails(source, panel)).setUniDirection(dest, panel, set);
        }
    }

    public boolean canBeBiDirectional(Object source, LayoutEditor panel, Object dest) {
        if (nxpair.containsKey(getPointDetails(source, panel))) {
            return nxpair.get(getPointDetails(source, panel)).canBeBiDirection(dest, panel);
        }
        return false;
    }

    public boolean isEnabled(Object source, LayoutEditor panel, Object dest) {
        if (nxpair.containsKey(getPointDetails(source, panel))) {
            return nxpair.get(getPointDetails(source, panel)).isEnabled(dest, panel);
        }
        return false;
    }

    public void setEnabled(Object source, LayoutEditor panel, Object dest, boolean set) {
        if (nxpair.containsKey(getPointDetails(source, panel))) {
            nxpair.get(getPointDetails(source, panel)).setEnabled(dest, panel, set);
        }
    }

    public void setEntryExitType(Object source, LayoutEditor panel, Object dest, int set) {
        if (nxpair.containsKey(getPointDetails(source, panel))) {
            nxpair.get(getPointDetails(source, panel)).setEntryExitType(dest, panel, set);
        }
    }

    public int getEntryExitType(Object source, LayoutEditor panel, Object dest) {
        if (nxpair.containsKey(getPointDetails(source, panel))) {
            return nxpair.get(getPointDetails(source, panel)).getEntryExitType(dest, panel);
        }
        return 0x00;
    }

    public String getUniqueId(Object source, LayoutEditor panel, Object dest) {
        if (nxpair.containsKey(getPointDetails(source, panel))) {
            return nxpair.get(getPointDetails(source, panel)).getUniqueId(dest, panel);
        }
        return null;
    }

    public List<String> getEntryExitList() {
        List<String> destlist = new ArrayList<>();
        for (Source e : nxpair.values()) {
            destlist.addAll(e.getDestinationUniqueId());
        }
        return destlist;
    }

    // protecting helps us to determine which direction we are going.
    // validateOnly flag is used, if all we are doing is simply checking to see if the source/destpoints are valid
    // when creating the pairs in the user GUI
    public boolean isPathActive(Object sourceObj, Object destObj, LayoutEditor panel) {
        PointDetails pd = getPointDetails(sourceObj, panel);
        if (nxpair.containsKey(pd)) {
            Source source = nxpair.get(pd);
            return source.isRouteActive(getPointDetails(destObj, panel));
        }
        return false;
    }

    public void cancelInterlock(Object source, LayoutEditor panel, Object dest) {
        if (nxpair.containsKey(getPointDetails(source, panel))) {
            nxpair.get(getPointDetails(source, panel)).cancelInterlock(dest, panel);
        }

    }

    jmri.SignalMastLogicManager smlm = InstanceManager.getDefault(jmri.SignalMastLogicManager.class);

    public static final int CANCELROUTE = 0;
    public static final int CLEARROUTE = 1;
    public static final int EXITROUTE = 2;
    public static final int STACKROUTE = 4;

   /**
     * Return a point from a given LE Panel.
     *
     * @param obj The point object
     * @param panel The Layout Editor panel on which the point was placed
     * @return the point object, null if the point is not found
     */
    public PointDetails getPointDetails(Object obj, LayoutEditor panel) {
        for (int i = 0; i < pointDetails.size(); i++) {
            if ((pointDetails.get(i).getRefObject() == obj)) {
                return pointDetails.get(i);

            }
        }
        return null;
    }

    /**
     * Return either an existing point stored in pointDetails, or create a new one as required.
     *
     * @param source The Layout Block functioning as the source (origin)
     * @param destination A (list of) Layout Blocks functioning as destinations
     * @param panel The Layout Editor panel on which the point is to be placed
     * @return the point object
     */
    PointDetails getPointDetails(LayoutBlock source, List<LayoutBlock> destination, LayoutEditor panel) {
        PointDetails newPoint = new PointDetails(source, destination);
        newPoint.setPanel(panel);
        for (int i = 0; i < pointDetails.size(); i++) {
            if (pointDetails.get(i).equals(newPoint)) {
                return pointDetails.get(i);
            }
        }
        //Not found so will add
        pointDetails.add(newPoint);
        return newPoint;
    }

    //No point can have multiple copies of what is the same thing.
    static List<PointDetails> pointDetails = new ArrayList<PointDetails>();

    /**
     * Get the name of a destinationPoint on a LE Panel.
     *
     * @param obj the point object
     * @param panel The Layout Editor panel on which it is expected to be placed
     * @return the name of the point
     */
    public String getPointAsString(NamedBean obj, LayoutEditor panel) {
        if (obj == null) {
            return "null";  // NOI18N
        }
        PointDetails valid = getPointDetails(obj, panel);  //was just plain getPoint
        if (valid != null) {
            return valid.getDisplayName();
        }
        return "empty";  // NOI18N
    }

    List<StackDetails> stackList = new ArrayList<>();

    /**
     * If a route is requested but is currently blocked, ask user
     * if it should be added to stackList.
     *
     * @param dp DestinationPoints object
     * @param reverse true for a reversed running direction, mostly false
     */
    synchronized public void stackNXRoute(DestinationPoints dp, boolean reverse) {
        if (isRouteStacked(dp, reverse)) {
            return;
        }
        stackList.add(new StackDetails(dp, reverse));
        checkTimer.start();
        if (stackPanel == null) {
            stackPanel = new StackNXPanel();
        }
        if (stackDialog == null) {
            stackDialog = new JDialog();
            stackDialog.setTitle(Bundle.getMessage("WindowTitleStackRoutes"));  // NOI18N
            stackDialog.add(stackPanel);
        }
        stackPanel.updateGUI();

        stackDialog.pack();
        stackDialog.setModal(false);
        stackDialog.setVisible(true);
    }

    StackNXPanel stackPanel = null;
    JDialog stackDialog = null;

    /**
     * Get a list of all stacked routes from stackList.
     *
     * @return an List containing destinationPoint elements
     */
    public List<DestinationPoints> getStackedInterlocks() {
        List<DestinationPoints> dpList = new ArrayList<>();
        for (StackDetails st : stackList) {
            dpList.add(st.getDestinationPoint());
        }
        return dpList;
    }

    /**
     * Query if a stacked route is in stackList.
     *
     * @param dp DestinationPoints object
     * @param reverse true for a reversed running direction, mostly false
     * @return true if dp is in stackList
     */
    public boolean isRouteStacked(DestinationPoints dp, boolean reverse) {
        Iterator<StackDetails> iter = stackList.iterator();
        while (iter.hasNext()) {
            StackDetails st = iter.next();
            if (st.getDestinationPoint() == dp && st.getReverse() == reverse) {
                return true;
            }
        }
        return false;
    }

    /**
     * Remove a stacked route from stackList.
     *
     * @param dp DestinationPoints object
     * @param reverse true for a reversed running direction, mostly false
     */
    synchronized public void cancelStackedRoute(DestinationPoints dp, boolean reverse) {
        Iterator<StackDetails> iter = stackList.iterator();
        while (iter.hasNext()) {
            StackDetails st = iter.next();
            if (st.getDestinationPoint() == dp && st.getReverse() == reverse) {
                iter.remove();
            }
        }
        stackPanel.updateGUI();
        if (stackList.isEmpty()) {
            stackDialog.setVisible(false);
            checkTimer.stop();
        }
    }

    /**
     * Class to collect (stack) routes when they are requested but blocked.
     */
    static class StackDetails {

        DestinationPoints dp;
        boolean reverse;

        StackDetails(DestinationPoints dp, boolean reverse) {
            this.dp = dp;
            this.reverse = reverse;
        }

        boolean getReverse() {
            return reverse;
        }

        DestinationPoints getDestinationPoint() {
            return dp;
        }
    }

    javax.swing.Timer checkTimer = new javax.swing.Timer(10000, (java.awt.event.ActionEvent e) -> {
        checkRoute();
    });

    /**
     * Step through stackList and activate the first stacked route in line
     * if it is no longer blocked.
     */
    synchronized void checkRoute() {
        checkTimer.stop();
        StackDetails[] tmp = new StackDetails[stackList.size()];
        stackList.toArray(tmp);

        for (StackDetails st : tmp) {
            if (!st.getDestinationPoint().isActive()) {
                // If the route is not already active, then check.
                // If the route does get set, then the setting process will remove the route from the stack.
                st.getDestinationPoint().setInterlockRoute(st.getReverse());
            }
        }

        if (!stackList.isEmpty()) {
            checkTimer.start();
        } else {
            stackDialog.setVisible(false);
        }
    }

    public void removePropertyChangeListener(PropertyChangeListener list, NamedBean obj, LayoutEditor panel) {
        if (obj == null) {
            return;
        }
        PointDetails valid = getPointDetails(obj, panel);
        if (valid != null) {
            valid.removePropertyChangeListener(list);
        }
    }

    boolean runWhenStabilised = false;
    LayoutEditor toUseWhenStable;
    int interlockTypeToUseWhenStable;

    /**
     * Discover all possible valid source and destination Signal Mast Logic pairs
     * on all Layout Editor panels.
     *
     * @param editor The Layout Editor panel
     * @param interlockType Integer value representing the type of interlocking, one of
     *                      SETUPTURNOUTSONLY, SETUPSIGNALMASTLOGIC or FULLINTERLOCK
     * @throws JmriException when an error occurs during discovery
     */
    public void automaticallyDiscoverEntryExitPairs(LayoutEditor editor, int interlockType) throws JmriException {
        //This is almost a duplicate of that in the DefaultSignalMastLogicManager
        runWhenStabilised = false;
        jmri.jmrit.display.layoutEditor.LayoutBlockManager lbm = InstanceManager.getDefault(jmri.jmrit.display.layoutEditor.LayoutBlockManager.class);
        if (!lbm.isAdvancedRoutingEnabled()) {
            throw new JmriException("advanced routing not enabled");  // NOI18N
        }
        if (!lbm.routingStablised()) {
            runWhenStabilised = true;
            toUseWhenStable = editor;
            interlockTypeToUseWhenStable = interlockType;
            log.debug("Layout block routing has not yet stabilised, discovery will happen once it has");  // NOI18N
            return;
        }
        HashMap<NamedBean, List<NamedBean>> validPaths = lbm.getLayoutBlockConnectivityTools().
                discoverValidBeanPairs(null, Sensor.class, LayoutBlockConnectivityTools.Routing.SENSORTOSENSOR);
        EntryExitPairs eep = this;
        for (Entry<NamedBean, List<NamedBean>> entry : validPaths.entrySet()) {
            NamedBean key = entry.getKey();
            List<NamedBean> validDestMast = validPaths.get(key);
            if (!validDestMast.isEmpty()) {
                eep.addNXSourcePoint(key, editor);
                for (int i = 0; i < validDestMast.size(); i++) {
                    if (!eep.isDestinationValid(key, validDestMast.get(i), editor)) {
                        eep.addNXDestination(key, validDestMast.get(i), editor);
                        eep.setEntryExitType(key, editor, validDestMast.get(i), interlockType);
                    }
                }
            }
        }

        firePropertyChange(PROPERTY_AUTO_GENERATE_COMPLETE, null, null);
    }

    protected PropertyChangeListener propertyBlockManagerListener = new PropertyChangeListener() {
        @Override
        public void propertyChange(PropertyChangeEvent e) {
            if ( LayoutBlockManager.PROPERTY_TOPOLOGY.equals(e.getPropertyName())) {
                boolean newValue = (Boolean) e.getNewValue();
                if (newValue) {
                    if (runWhenStabilised) {
                        try {
                            automaticallyDiscoverEntryExitPairs(toUseWhenStable, interlockTypeToUseWhenStable);
                        } catch (JmriException je) {
                            //Considered normal if routing not enabled
                        }
                    }
                }
            }
        }
    };

    public void vetoableChange(PropertyChangeEvent evt) throws PropertyVetoException {

    }

    @Override
    public void deleteBean(@Nonnull DestinationPoints bean, @Nonnull String property) throws PropertyVetoException {

    }

    @Override
    @Nonnull
    public String getBeanTypeHandled(boolean plural) {
        return Bundle.getMessage(plural ? "BeanNameEntryExits" : "BeanNameEntryExit");  // NOI18N
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Class<DestinationPoints> getNamedBeanClass() {
        return DestinationPoints.class;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    @OverridingMethodsMustInvokeSuper
    public void setPropertyChangesSilenced(@Nonnull String propertyName, boolean silenced) {
        if (!Manager.PROPERTY_BEANS.equals(propertyName)) {
            throw new IllegalArgumentException("Property " + propertyName + " cannot be silenced.");
        }
        silencedProperties.put(propertyName, silenced);
        if (propertyName.equals(Manager.PROPERTY_BEANS) && !silenced) {
            fireIndexedPropertyChange(Manager.PROPERTY_BEANS, getNamedBeanSet().size(), null, null);
        }
    }

    /** {@inheritDoc} */
    @Override
    public void addDataListener(ManagerDataListener<DestinationPoints> e) {
        if (e != null) listeners.add(e);
    }

    /** {@inheritDoc} */
    @Override
    public void removeDataListener(ManagerDataListener<DestinationPoints> e) {
        if (e != null) listeners.remove(e);
    }

    final List<ManagerDataListener<DestinationPoints>> listeners = new ArrayList<>();

    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(EntryExitPairs.class);

}