package jmri.jmrit.entryexit;

import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.UUID;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

import jmri.*;
import jmri.jmrit.dispatcher.ActiveTrain;
import jmri.jmrit.dispatcher.DispatcherFrame;
import jmri.jmrit.display.layoutEditor.ConnectivityUtil;
import jmri.jmrit.display.layoutEditor.LayoutBlock;
import jmri.jmrit.display.layoutEditor.LayoutBlockConnectivityTools;
import jmri.jmrit.display.layoutEditor.LayoutBlockManager;
import jmri.jmrit.display.layoutEditor.LayoutSlip;
import jmri.jmrit.display.layoutEditor.LayoutTrackExpectedState;
import jmri.jmrit.display.layoutEditor.LayoutTurnout;
import jmri.util.swing.JmriJOptionPane;
import jmri.util.ThreadingUtil;

public class DestinationPoints extends jmri.implementation.AbstractNamedBean {

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

    /**
     * String constant for no change.
     */
    public static final String PROPERTY_NO_CHANGE = "noChange";

    /**
     * String constant for stacked.
     */
    public static final String PROPERTY_STACKED = "stacked";

    /**
     * String constant for failed.
     */
    public static final String PROPERTY_FAILED = "failed";

    @Override
    public String getBeanType() {
        return Bundle.getMessage("BeanNameDestination");  // NOI18N
    }

    transient PointDetails point = null;
    private boolean uniDirection = true;
    int entryExitType = EntryExitPairs.SETUPTURNOUTSONLY;//SETUPSIGNALMASTLOGIC;
    private boolean enabled = true;
    private boolean activeEntryExit = false;
    private boolean activeEntryExitReversed = false;
    private List<LayoutBlock> routeDetails = new ArrayList<>();
    private LayoutBlock destination;
    private boolean disposed = false;

    transient EntryExitPairs manager = InstanceManager.getDefault(jmri.jmrit.entryexit.EntryExitPairs.class);

    transient SignalMastLogic sml;

    static final int NXMESSAGEBOXCLEARTIMEOUT = 30;

    /**
     * public for testing purposes.
     * @return true if enabled, else false.
     */
    public boolean isEnabled() {
        return enabled;
    }

    public void setEnabled(boolean boo) {
        enabled = boo;

        // Modify source signal mast held state
        Sensor sourceSensor = src.getPoint().getSensor();
        if (sourceSensor == null) {
            return;
        }
        SignalMast sourceMast = src.getPoint().getSignalMast();
        if (sourceMast == null) {
            return;
        }
        if (enabled) {
            if (!manager.isAbsSignalMode()) {
                sourceMast.setHeld(true);
            }
        } else {
            // All destinations for the source must be disabled before the mast hold can be released
            for (PointDetails pd : src.getDestinationPoints()) {
                if (src.getDestForPoint(pd).isEnabled()) {
                    return;
                }
            }
            sourceMast.setHeld(false);
        }
    }

    transient Source src = null;

    protected DestinationPoints(PointDetails point, String id, Source src) {
        super(id != null ? id : "IN:" + UUID.randomUUID().toString());
        this.src = src;
        this.point = point;
        setUserName(src.getPoint().getDisplayName() + " to " + this.point.getDisplayName());

        propertyBlockListener = this::blockStateUpdated;
    }

    String getUniqueId() {
        return getSystemName();
    }

    public PointDetails getDestPoint() {
        return point;
    }

    /**
     * @since 4.17.4
     * Making the source object available for scripting in Jython.
     * @return source.
     */
    public Source getSource() {
        return src ;
    }

    boolean getUniDirection() {
        return uniDirection;
    }

    void setUniDirection(boolean uni) {
        uniDirection = uni;
    }

    NamedBean getSignal() {
        return point.getSignal();
    }

    void setRouteTo(boolean set) {
        if (set && getEntryExitType() == EntryExitPairs.FULLINTERLOCK) {
            point.setRouteTo(true);
            point.setNXButtonState(EntryExitPairs.NXBUTTONACTIVE);
        } else {
            point.setRouteTo(false);
            point.setNXButtonState(EntryExitPairs.NXBUTTONINACTIVE);
        }
    }

    void setRouteFrom(boolean set) {
        if (set && getEntryExitType() == EntryExitPairs.FULLINTERLOCK) {
            src.pd.setRouteFrom(true);
            src.pd.setNXButtonState(EntryExitPairs.NXBUTTONACTIVE);
        } else {
            src.pd.setRouteFrom(false);
            src.pd.setNXButtonState(EntryExitPairs.NXBUTTONINACTIVE);
        }
    }

    boolean isRouteToPointSet() {
        return point.isRouteToPointSet();
    }

    LayoutBlock getFacing() {
        return point.getFacing();
    }

    List<LayoutBlock> getProtecting() {
        return point.getProtecting();
    }

    int getEntryExitType() {
        return entryExitType;
    }

    void setEntryExitType(int type) {
        entryExitType = type;
        if ((type != EntryExitPairs.SETUPTURNOUTSONLY) && (getSignal() != null) && point.getSignal() != null) {
            uniDirection = true;
        }
    }

    @SuppressFBWarnings(value = "SE_TRANSIENT_FIELD_NOT_RESTORED",
            justification = "No auto serialization")
    transient protected PropertyChangeListener propertyBlockListener;

    protected void blockStateUpdated(PropertyChangeEvent e) {
        Block blk = (Block) e.getSource();
        if ( Block.PROPERTY_STATE.equals(e.getPropertyName())) {
            if (log.isDebugEnabled()) {
                log.debug("{}  We have a change of state on the block {}", getUserName(), blk.getDisplayName());  // NOI18N
            }
            int now = ((Integer) e.getNewValue());

            LayoutBlock lBlock = InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock(blk);
            if (lBlock == null){
                log.error("Unable to get layout block from block {}",blk);
                return;
            }

            if (now == Block.OCCUPIED) {
                //If the block was previously active or inactive then we will
                //reset the useExtraColor, but not if it was previously unknown or inconsistent.
                lBlock.setUseExtraColor(false);
                blk.removePropertyChangeListener(propertyBlockListener); //was this
                removeBlockFromRoute(lBlock);
            } else {
                if (src.getStart() == lBlock) {
                    // Remove listener when the start block becomes unoccupied.
                    // When the start block is occupied when the route is created, the normal
                    // removal does not occur.
                    lBlock.getBlock().removePropertyChangeListener(propertyBlockListener);
                    log.debug("Remove listener from start block {} for {}", lBlock.getDisplayName(), this.getDisplayName());
                } else {
                    log.debug("state was {} and did not go through reset",now);  // NOI18N
                }
            }
        }
    }

    Object lastSeenActiveBlockObject;

    synchronized void removeBlockFromRoute(LayoutBlock lBlock) {

        if (routeDetails != null) {
            if (routeDetails.indexOf(lBlock) == -1) {
                if (src.getStart() == lBlock) {
                    log.debug("Start block went active");  // NOI18N
                    lastSeenActiveBlockObject = src.getStart().getBlock().getValue();
                    lBlock.getBlock().removePropertyChangeListener(propertyBlockListener);
                    return;
                } else {
                    log.error("Block {} went active but it is not part of our NX path", lBlock.getDisplayName());  // NOI18N
                    return;
                }
            }
            if (routeDetails.indexOf(lBlock) != 0) {
                log.debug("A block has been skipped will set the value of the active block to that of the original one");  // NOI18N
                // Only give a value to a block that has none, and never clear one
                if (lastSeenActiveBlockObject != null && lBlock.getBlock().getValue() == null) {
                    lBlock.getBlock().setValue(lastSeenActiveBlockObject);
                }
                if (routeDetails.indexOf(lBlock) != -1) {
                    while (routeDetails.indexOf(lBlock) != 0) {
                        LayoutBlock tbr = routeDetails.get(0);
                        log.debug("Block skipped {} and removed from list", tbr.getDisplayName());  // NOI18N
                        tbr.getBlock().removePropertyChangeListener(propertyBlockListener);
                        tbr.setUseExtraColor(false);
                        routeDetails.remove(0);
                    }
                }
            }
            if (routeDetails.contains(lBlock)) {
                routeDetails.remove(lBlock);
                setRouteFrom(false);
                src.pd.setNXButtonState(EntryExitPairs.NXBUTTONINACTIVE);
                if (sml != null && getEntryExitType() == EntryExitPairs.FULLINTERLOCK) {
                    if (!manager.isAbsSignalMode()) {
                        sml.getSourceMast().setHeld(true);
                    }
                    SignalMast mast = (SignalMast) getSignal();
                    if (sml.getStoreState(mast) == SignalMastLogic.STORENONE) {
                        sml.removeDestination(mast);
                    }
                }
            } else {
                log.error("Block {} that went Occupied was not in the routeDetails list", lBlock.getDisplayName());  // NOI18N
            }
            if (log.isDebugEnabled()) {
                log.debug("Route details contents {}", routeDetails);  // NOI18N
                for (int i = 0; i < routeDetails.size(); i++) {
                    log.debug("    name: {}", routeDetails.get(i).getDisplayName());
                }
            }
            if ((routeDetails.size() == 1) && (routeDetails.contains(destination))) {
                routeDetails.get(0).getBlock().removePropertyChangeListener(propertyBlockListener);  // was set against block sensor
                routeDetails.remove(destination);
            }
        }
        lastSeenActiveBlockObject = lBlock.getBlock().getValue();

        if ((routeDetails == null) || (routeDetails.isEmpty())) {
            //At this point the route has cleared down/the last remaining block are now active.
            routeDetails = null;
            setRouteTo(false);
            setRouteFrom(false);
            setActiveEntryExit(false);
            lastSeenActiveBlockObject = null;
        }
    }

    //For a clear down we need to add a message, if it is a cancel, manual clear down or I didn't mean it.
    // For creating routes, the route is then set in steps on the layout thread.
    void setRoute(boolean state) {
        log.debug("[setRoute] Start, dp = {}", getUserName());

        if (disposed) {
            log.error("Set route called even though interlock has been disposed of");  // NOI18N
            manager.routeSettingDone(this, false);
            return;
        }

        if (routeDetails == null) {
            log.error("No route to set or clear down");  // NOI18N
            // Nothing is set, but there is nothing left to clear down either
            manager.routeSettingDone(this, !state);
            setActiveEntryExit(false);
            setRouteTo(false);
            setRouteFrom(false);
            if ((getSignal() instanceof SignalMast) && (getEntryExitType() != EntryExitPairs.FULLINTERLOCK)) {
                SignalMast mast = (SignalMast) getSignal();
                mast.setHeld(false);
            }
            synchronized (this) {
                destination = null;
            }
            return;
        }
        if (!state) {
            switch (manager.getClearDownOption()) {
                case EntryExitPairs.PROMPTUSER:
                    cancelClearOptionBox();
                    break;
                case EntryExitPairs.AUTOCANCEL:
                    cancelClearInterlock(EntryExitPairs.CANCELROUTE);
                    manager.routeSettingDone(this, true);
                    break;
                case EntryExitPairs.AUTOCLEAR:
                    cancelClearInterlock(EntryExitPairs.CLEARROUTE);
                    manager.routeSettingDone(this, true);
                    break;
                case EntryExitPairs.AUTOSTACK:
                    cancelClearInterlock(EntryExitPairs.STACKROUTE);
                    manager.routeSettingDone(this, false);
                    break;
                default:
                    cancelClearOptionBox();
                    break;
            }
            log.debug("[setRoute] Cancel/Clear/Stack route, dp = {}", getUserName());
            return;
        }
        if (manager.isRouteStacked(this, false)) {
            manager.cancelStackedRoute(this, false);
        }
        ActiveTrain tmpat = null;
        if (manager.getDispatcherIntegration() && InstanceManager.getNullableDefault(DispatcherFrame.class) != null) {
            DispatcherFrame df = InstanceManager.getDefault(DispatcherFrame.class);
            for (ActiveTrain atl : df.getActiveTrainsList()) {
                if (atl.getEndBlock() == src.getStart().getBlock()) {
                    if (atl.getLastAllocatedSection() == atl.getEndBlockSection()) {
                        if (!atl.getReverseAtEnd() && !atl.getResetWhenDone()) {
                            tmpat = atl;
                            break;
                        }
                        log.warn("Interlock will not be added to existing Active Train as it is set for back and forth operation");  // NOI18N
                    }
                }
            }
        }
        final ActiveTrain at = tmpat;
        // The start block is needed to find the turnouts of the first block, but when signal masts
        // protect the route it is not part of the route. Remove it before any block listener is
        // added, so that a train entering the start block now cannot remove a block of the route.
        final List<LayoutBlock> blocks;
        synchronized (this) {
            blocks = new ArrayList<>(routeDetails);
            if (getEntryExitType() != EntryExitPairs.SETUPTURNOUTSONLY
                    && (src.sourceSignal instanceof SignalMast) && (getSignal() instanceof SignalMast)
                    && !routeDetails.isEmpty()) {
                routeDetails.remove(0);
            }
        }
        /* The route is set in steps on the layout thread. Each step sets one turnout and schedules
         the next one, so nothing waits while the turnouts move and the panel, including the
         flashing of the NX buttons, carries on as normal. */
        RouteSetting setting = new RouteSetting(blocks, at);
        routeSetting = setting;
        manager.routeSettingStarted();
        ThreadingUtil.runOnLayoutEventually(setting::start);
        log.debug("[setRoute] Route setting started, dp = {}", getUserName());
    }

    /**
     * The route setting in progress, or the last one.
     */
    private volatile RouteSetting routeSetting = null;

    /**
     * Delay in milliseconds after which the hold on the source mast is removed
     * even if the turnouts have not reported their new state.
     */
    int mastReleaseTimeout = 10000;

    /**
     * Sets the route of this destination point on the layout thread.
     * <p>
     * The turnouts are set one at a time, 250 ms plus the turnout set delay
     * apart. Each step schedules the next one, and the last step completes the
     * route: signal mast logic, colours, Dispatcher and NX buttons. The result
     * is reported to the manager once, when the route has been set or setting
     * it has failed. If the route is cleared down, set again or disposed of
     * while its turnouts are being set, the remaining steps are not run.
     */
    private class RouteSetting {

        private final List<LayoutBlock> blocks;
        private final ActiveTrain at;
        private final Hashtable<Turnout, Integer> turnoutSettings = new Hashtable<>();
        private final List<Turnout> turnoutsToSet = new ArrayList<>();
        private final List<Color> realColorStd = new ArrayList<>();
        private final List<Color> realColorXtra = new ArrayList<>();
        private final List<LayoutBlock> routeBlocks = new ArrayList<>();
        private boolean ended = false;

        RouteSetting(List<LayoutBlock> blocks, ActiveTrain at) {
            this.blocks = blocks;
            this.at = at;
        }

        private boolean isCancelled() {
            return disposed || routeSetting != this || routeDetails == null;
        }

        /**
         * First step: show that the route is being set, add the block
         * listeners and find the turnouts to set.
         */
        void start() {
            if (isCancelled()) {
                cancelled();
                return;
            }
            try {
                if (manager.useDifferentColorWhenSetting()) {
                    boolean first = true;
                    for (LayoutBlock lbk : blocks) {
                        if (first) {
                            // Don't change the color for the facing block
                            first = false;
                            continue;
                        }
                        routeBlocks.add(lbk);
                        realColorXtra.add(lbk.getBlockExtraColor());
                        realColorStd.add(lbk.getBlockTrackColor());
                        lbk.setBlockExtraColor(manager.getSettingRouteColor());
                        lbk.setBlockTrackColor(manager.getSettingRouteColor());
                    }
                    //Force a redraw, to reflect color change
                    src.getPoint().getPanel().redrawPanel();
                }
                if (!manager.isSkipGuiFix()) {
                    // With the old GUI behavior clicks are held back instead, so that a second
                    // click on the destination can start the next route
                    src.getPoint().getPanel().getGlassPane().setVisible(true);
                }

                ConnectivityUtil connection = new ConnectivityUtil(point.getPanel());

                // Last block in the route is the one that we are protecting at the last sensor/signalmast
                for (int i = 0; i < blocks.size(); i++) {
                    //if we are not using the dispatcher and the signal logic is dynamic, then set the turnouts
                    if (at == null && isSignalLogicDynamic()) {
                        if (i > 0) {
                            List<LayoutTrackExpectedState<LayoutTurnout>> turnoutlist;
                            int nxtBlk = i + 1;
                            int preBlk = i - 1;
                            if (i < blocks.size() - 1) {
                                turnoutlist = connection.getTurnoutList(blocks.get(i).getBlock(), blocks.get(preBlk).getBlock(), blocks.get(nxtBlk).getBlock());
                                for (int x = 0; x < turnoutlist.size(); x++) {
                                    if (turnoutlist.get(x).getObject() instanceof LayoutSlip) {
                                        int slipState = turnoutlist.get(x).getExpectedState();
                                        LayoutSlip ls = (LayoutSlip) turnoutlist.get(x).getObject();
                                        int taState = ls.getTurnoutState(slipState);
                                        Turnout t = ls.getTurnout();
                                        if (t==null) {
                                            log.warn("Found unexpected Turnout reference at {}: {}",i,ls);
                                            continue; // not sure what else do to here
                                        }
                                        turnoutSettings.put(t, taState);

                                        int tbState = ls.getTurnoutBState(slipState);
                                        ls.getTurnoutB().setCommandedState(tbState);
                                        turnoutSettings.put(ls.getTurnoutB(), tbState);
                                    } else {
                                        String t = turnoutlist.get(x).getObject().getTurnoutName();
                                        Turnout turnout = InstanceManager.turnoutManagerInstance().getTurnout(t);
                                        if (turnout != null) {
                                            turnoutSettings.put(turnout, turnoutlist.get(x).getExpectedState());
                                            if (turnoutlist.get(x).getObject().getSecondTurnout() != null) {
                                                turnoutSettings.put(turnoutlist.get(x).getObject().getSecondTurnout(),
                                                        turnoutlist.get(x).getExpectedState());
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    if ((getEntryExitType() == EntryExitPairs.FULLINTERLOCK)) {
                        blocks.get(i).getBlock().addPropertyChangeListener(propertyBlockListener); // was set against occupancy sensor
                        if (i > 0) {
                            blocks.get(i).setUseExtraColor(true);
                        }
                    } else {
                        blocks.get(i).getBlock().removePropertyChangeListener(propertyBlockListener); // was set against occupancy sensor
                    }
                }
                if (at == null) {
                    if (!isSignalLogicDynamic()) {
                        SignalMastLogic tmSml = InstanceManager.getDefault(SignalMastLogicManager.class).getSignalMastLogic((SignalMast) src.sourceSignal);
                        for (Turnout t : tmSml.getAutoTurnouts((SignalMast) getSignal())) {
                            turnoutSettings.put(t, tmSml.getAutoTurnoutState(t, (SignalMast) getSignal()));
                        }
                    }
                    turnoutsToSet.addAll(turnoutSettings.keySet());
                }
            } catch (RuntimeException ex) {
                failed(ex);
                return;
            }
            setTurnout(0);
        }

        /**
         * Set one turnout and schedule the next step after the turnout delay.
         * When all turnouts are set, complete the route.
         *
         * @param index the index of the turnout to set
         */
        private void setTurnout(int index) {
            if (index >= turnoutsToSet.size()) {
                complete();
                return;
            }
            if (isCancelled()) {
                cancelled();
                return;
            }
            try {
                Turnout turnout = turnoutsToSet.get(index);
                turnout.setCommandedState(turnoutSettings.get(turnout));
            } catch (RuntimeException ex) {
                failed(ex);
                return;
            }
            ThreadingUtil.runOnLayoutDelayed(() -> setTurnout(index + 1), 250 + manager.turnoutSetDelay);
        }

        /**
         * Last step: set up the signal mast logic and the Dispatcher, and
         * update the colours and NX buttons.
         */
        private void complete() {
            if (isCancelled()) {
                cancelled();
                return;
            }
            try {
                src.getPoint().getPanel().redrawPanel();
                if (getEntryExitType() != EntryExitPairs.SETUPTURNOUTSONLY) {
                    if (getEntryExitType() == EntryExitPairs.FULLINTERLOCK) {
                        //If our start block is already active we will set it as our lastSeenActiveBlock.
                        if (src.getStart().getState() == Block.OCCUPIED) {
                            src.getStart().getBlock().removePropertyChangeListener(propertyBlockListener);
                            lastSeenActiveBlockObject = src.getStart().getBlock().getValue();
                            log.debug("Last seen value {}", lastSeenActiveBlockObject);
                        }
                    }
                    if ((src.sourceSignal instanceof SignalMast) && (getSignal() instanceof SignalMast)) {
                        SignalMast smSource = (SignalMast) src.sourceSignal;
                        SignalMast smDest = (SignalMast) getSignal();
                        synchronized (DestinationPoints.this) {
                            sml = InstanceManager.getDefault(SignalMastLogicManager.class).newSignalMastLogic(smSource);
                            if (!sml.isDestinationValid(smDest)) {
                                //if no signalmastlogic existed then created it, but set it not to be stored.
                                sml.setDestinationMast(smDest);
                                sml.setStore(SignalMastLogic.STORENONE, smDest);
                            }
                        }

                        releaseMast(smSource, turnoutSettings);
                        //Only change the block and turnout details if this a temp signalmast logic
                        if (sml.getStoreState(smDest) == SignalMastLogic.STORENONE) {
                            LinkedHashMap<Block, Integer> blks = new LinkedHashMap<>();
                            for (int i = 0; i < routeDetails.size(); i++) {
                                if (routeDetails.get(i).getBlock().getState() == Block.UNKNOWN) {
                                    routeDetails.get(i).getBlock().setState(Block.UNOCCUPIED);
                                }
                                blks.put(routeDetails.get(i).getBlock(), Block.UNOCCUPIED);
                            }
                            sml.setAutoBlocks(blks, smDest);
                            sml.setAutoTurnouts(turnoutSettings, smDest);
                            sml.initialise(smDest);
                        }
                        smSource.addPropertyChangeListener(new PropertyChangeListener() {
                            @Override
                            public void propertyChange(PropertyChangeEvent e) {
                                SignalMast source = (SignalMast) e.getSource();
                                source.removePropertyChangeListener(this);
                                setRouteFrom(true);
                                setRouteTo(true);
                            }
                        });
                        src.pd.extendedtime = true;
                        point.extendedtime = true;
                    } else {
                        if (src.sourceSignal instanceof SignalMast) {
                            SignalMast mast = (SignalMast) src.sourceSignal;
                            releaseMast(mast, turnoutSettings);
                        } else if (src.sourceSignal instanceof SignalHead) {
                            SignalHead head = (SignalHead) src.sourceSignal;
                            head.setHeld(false);
                        }
                        setRouteFrom(true);
                        setRouteTo(true);
                    }
                }
                if (manager.useDifferentColorWhenSetting()) {
                    javax.swing.Timer resetColorBack = new javax.swing.Timer(manager.getSettingTimer(), new java.awt.event.ActionListener() {
                        @Override
                        public void actionPerformed(java.awt.event.ActionEvent e) {
                            restoreColors();
                            src.getPoint().getPanel().redrawPanel();
                        }
                    });
                    resetColorBack.setRepeats(false);
                    resetColorBack.start();
                }

                if (at != null) {
                    Section sec;
                    if (sml != null && sml.getAssociatedSection((SignalMast) getSignal()) != null) {
                        sec = sml.getAssociatedSection((SignalMast) getSignal());
                    } else {
                        String secUserName = src.getPoint().getDisplayName() + ":" + point.getDisplayName();
                        sec = InstanceManager.getDefault(SectionManager.class).getSection(secUserName);
                        if (sec == null) {
                            sec = InstanceManager.getDefault(SectionManager.class).createNewSection(secUserName);
                            sec.setSectionType(Section.DYNAMICADHOC);
                        }
                        if (sec.getSectionType() == Section.DYNAMICADHOC) {
                            sec.removeAllBlocksFromSection();
                            for (LayoutBlock key : routeDetails) {
                                if (key != src.getStart()) {
                                    sec.addBlock(key.getBlock());
                                }
                            }
                            String dir = Path.decodeDirection(src.getStart().getNeighbourDirection(routeDetails.get(0).getBlock()));
                            EntryPoint ep = new EntryPoint(routeDetails.get(0).getBlock(), src.getStart().getBlock(), dir);
                            ep.setTypeForward();
                            sec.addToForwardList(ep);

                            LayoutBlock proDestLBlock = point.getProtecting().get(0);
                            if (proDestLBlock != null) {
                                dir = Path.decodeDirection(proDestLBlock.getNeighbourDirection(point.getFacing()));
                                ep = new EntryPoint(point.getFacing().getBlock(), proDestLBlock.getBlock(), dir);
                                ep.setTypeReverse();
                                sec.addToReverseList(ep);
                            }
                        }
                    }
                    InstanceManager.getDefault(DispatcherFrame.class).extendActiveTrainsPath(sec, at, src.getPoint().getPanel());
                }

                src.pd.setNXButtonState(EntryExitPairs.NXBUTTONINACTIVE);
                point.setNXButtonState(EntryExitPairs.NXBUTTONINACTIVE);
            } catch (RuntimeException ex) {
                failed(ex);
                return;
            }
            try {
                src.getPoint().getPanel().getGlassPane().setVisible(false);
                log.debug("[setRoute] Done, dp = {}", getUserName());
            } finally {
                end(true, true);
            }
        }

        private void failed(RuntimeException ex) {
            try {
                log.error("An error occurred while setting the route", ex);  // NOI18N
                src.pd.setNXButtonState(EntryExitPairs.NXBUTTONINACTIVE);
                point.setNXButtonState(EntryExitPairs.NXBUTTONINACTIVE);
                restoreColors();
                src.getPoint().getPanel().redrawPanel();
                src.getPoint().getPanel().getGlassPane().setVisible(false);
            } finally {
                // Always report, so that a route over several pairs and held clicks are not left waiting
                end(false, true);
            }
        }

        private void cancelled() {
            // When the route has been set again, the new route setting reports the result
            boolean current = routeSetting == this;
            try {
                log.debug("[setRoute] Route setting stopped, dp = {}", getUserName());
                if (current) {
                    src.pd.setNXButtonState(EntryExitPairs.NXBUTTONINACTIVE);
                    point.setNXButtonState(EntryExitPairs.NXBUTTONINACTIVE);
                }
                restoreColors();
                src.getPoint().getPanel().redrawPanel();
                src.getPoint().getPanel().getGlassPane().setVisible(false);
            } finally {
                end(false, current);
            }
        }

        private void restoreColors() {
            for (int i = 0; i < routeBlocks.size(); i++) {
                LayoutBlock lbk = routeBlocks.get(i);
                lbk.setBlockExtraColor(realColorXtra.get(i));
                lbk.setBlockTrackColor(realColorStd.get(i));
            }
        }

        private void end(boolean success, boolean report) {
            if (ended) {
                return;
            }
            ended = true;
            if (report) {
                manager.routeSettingDone(DestinationPoints.this, success);
            }
            manager.routeSettingFinished();
        }
    }

    /**
     * Remove the hold on the mast when all of the turnouts have completed moving.
     * This only applies to turnouts using ONESENSOR feedback.  TWOSENSOR has an
     * intermediate inconsistent state which prevents erroneous signal aspects.
     * The maximum wait time is 10 seconds.
     * <p>
     * The turnouts are watched with a listener and the hold is removed on the
     * layout thread.
     *
     * @since 4.11.1
     * @param mast The signal mast that will be released.
     * @param turnoutSettings The turnouts that are being set for the current NX route.
     */
    private void releaseMast(SignalMast mast, Hashtable<Turnout, Integer> turnoutSettings) {
        new MastRelease(mast, turnoutSettings).start();
    }

    /**
     * Removes the hold on a signal mast when the ONESENSOR turnouts of a route
     * have reached their commanded state, or after the time out.
     */
    private class MastRelease implements PropertyChangeListener {

        private final SignalMast mast;
        private final List<Turnout> turnouts = new ArrayList<>();
        private boolean released = false;

        MastRelease(SignalMast mast, Hashtable<Turnout, Integer> turnoutSettings) {
            this.mast = mast;
            for (Turnout tout : turnoutSettings.keySet()) {
                if (tout.getFeedbackMode() == Turnout.ONESENSOR) {
                    turnouts.add(tout);
                }
            }
        }

        void start() {
            for (Turnout tout : turnouts) {
                tout.addPropertyChangeListener(this);
            }
            ThreadingUtil.runOnLayoutDelayed(this::release, mastReleaseTimeout);
            ThreadingUtil.runOnLayoutEventually(this::check);
        }

        @Override
        public void propertyChange(PropertyChangeEvent e) {
            if (Turnout.PROPERTY_KNOWN_STATE.equals(e.getPropertyName())
                    || Turnout.PROPERTY_COMMANDED_STATE.equals(e.getPropertyName())) {
                ThreadingUtil.runOnLayoutEventually(this::check);
            }
        }

        private void check() {
            for (Turnout tout : turnouts) {
                if (tout.getKnownState() != tout.getCommandedState()) {
                    return;
                }
            }
            release();
        }

        private void release() {
            if (released) {
                return;
            }
            released = true;
            for (Turnout tout : turnouts) {
                tout.removePropertyChangeListener(this);
            }
            log.debug("[releaseMast] mast = {}", mast.getDisplayName());
            mast.setHeld(false);
        }
    }

    private boolean isSignalLogicDynamic() {
        if ((src.sourceSignal instanceof SignalMast) && (getSignal() instanceof SignalMast)) {
            SignalMast smSource = (SignalMast) src.sourceSignal;
            SignalMast smDest = (SignalMast) getSignal();
            if (InstanceManager.getDefault(SignalMastLogicManager.class).getSignalMastLogic(smSource) != null
                    && InstanceManager.getDefault(SignalMastLogicManager.class).getSignalMastLogic(smSource).getStoreState(smDest) != SignalMastLogic.STORENONE) {
                return false;
            }
        }
        return true;

    }

    private JFrame cancelClearFrame;
    transient private Thread threadAutoClearFrame = null;
    JButton jButton_Stack = new JButton(Bundle.getMessage("Stack"));  // NOI18N

    void cancelClearOptionBox() {
        if (cancelClearFrame == null) {
            JButton jButton_Clear = new JButton(Bundle.getMessage("ClearDown"));  // NOI18N
            JButton jButton_Cancel = new JButton(Bundle.getMessage("ButtonCancel"));  // NOI18N

            JButton jButton_Exit = new JButton(Bundle.getMessage("Exit"));  // NOI18N
            JLabel jLabel = new JLabel(Bundle.getMessage("InterlockPrompt"));  // NOI18N
            JLabel jIcon = new JLabel(javax.swing.UIManager.getIcon("OptionPane.questionIcon"));  // NOI18N
            cancelClearFrame = new JFrame(Bundle.getMessage("Interlock"));  // NOI18N
            Container cont = cancelClearFrame.getContentPane();
            JPanel qPanel = new JPanel();
            qPanel.add(jIcon);
            qPanel.add(jLabel);
            cont.add(qPanel, BorderLayout.CENTER);
            JPanel buttonsPanel = new JPanel();
            buttonsPanel.add(jButton_Cancel);
            buttonsPanel.add(jButton_Clear);
            buttonsPanel.add(jButton_Stack);
            buttonsPanel.add(jButton_Exit);
            cont.add(buttonsPanel, BorderLayout.SOUTH);
            cancelClearFrame.pack();

            jButton_Clear.addActionListener( e -> {
                cancelClearFrame.setVisible(false);
                threadAutoClearFrame.interrupt();
                cancelClearInterlock(EntryExitPairs.CLEARROUTE);
                manager.routeSettingDone(this, true);
            });
            jButton_Cancel.addActionListener( e -> {
                cancelClearFrame.setVisible(false);
                threadAutoClearFrame.interrupt();
                cancelClearInterlock(EntryExitPairs.CANCELROUTE);
                manager.routeSettingDone(this, true);
            });
            jButton_Stack.addActionListener( e -> {
                cancelClearFrame.setVisible(false);
                threadAutoClearFrame.interrupt();
                cancelClearInterlock(EntryExitPairs.STACKROUTE);
                manager.routeSettingDone(this, false);
            });
            jButton_Exit.addActionListener( e -> {
                cancelClearFrame.setVisible(false);
                threadAutoClearFrame.interrupt();
                cancelClearInterlock(EntryExitPairs.EXITROUTE);
                manager.routeSettingDone(this, false);
                firePropertyChange(PROPERTY_NO_CHANGE, null, null);
            });
            src.getPoint().getPanel().setGlassPane(manager.getGlassPane());

        }
        cancelClearFrame.setTitle(getUserName());
        jButton_Stack.setEnabled(!(manager.isRouteStacked(this, false)));

        if (cancelClearFrame.isVisible()) {
            return;
        }
        src.pd.extendedtime = true;
        point.extendedtime = true;

        class MessageTimeOut implements Runnable {

            MessageTimeOut() {
            }

            @Override
            public void run() {
                try {
                    //Set a timmer before this window is automatically closed to 30 seconds
                    Thread.sleep(NXMESSAGEBOXCLEARTIMEOUT * 1000);
                    cancelClearFrame.setVisible(false);
                    cancelClearInterlock(EntryExitPairs.EXITROUTE);
                    manager.routeSettingDone(DestinationPoints.this, false);
                } catch (InterruptedException ex) {
                    log.debug("Flash timer cancelled");  // NOI18N
                }
            }
        }
        MessageTimeOut mt = new MessageTimeOut();
        threadAutoClearFrame = ThreadingUtil.newThread(mt, "NX Button Clear Message Timeout ");  // NOI18N
        threadAutoClearFrame.start();
        cancelClearFrame.setAlwaysOnTop(true);
        src.getPoint().getPanel().getGlassPane().setVisible(true);
        int w = cancelClearFrame.getSize().width;
        int h = cancelClearFrame.getSize().height;
        int x = (int) src.getPoint().getPanel().getLocation().getX() + ((src.getPoint().getPanel().getSize().width - w) / 2);
        int y = (int) src.getPoint().getPanel().getLocation().getY() + ((src.getPoint().getPanel().getSize().height - h) / 2);
        cancelClearFrame.setLocation(x, y);
        cancelClearFrame.setVisible(true);
    }

    void cancelClearInterlock(int cancelClear) {
        if ((cancelClear == EntryExitPairs.EXITROUTE) || (cancelClear == EntryExitPairs.STACKROUTE)) {
            src.pd.setNXButtonState(EntryExitPairs.NXBUTTONINACTIVE);
            point.setNXButtonState(EntryExitPairs.NXBUTTONINACTIVE);
            src.getPoint().getPanel().getGlassPane().setVisible(false);
            if (cancelClear == EntryExitPairs.STACKROUTE) {
                manager.stackNXRoute(this, false);
            }
            return;
        }

        if (cancelClear == EntryExitPairs.CANCELROUTE) {
            if (manager.getDispatcherIntegration() && InstanceManager.getNullableDefault(DispatcherFrame.class) != null) {
                DispatcherFrame df = InstanceManager.getDefault(DispatcherFrame.class);
                ActiveTrain at = null;
                for (ActiveTrain atl : df.getActiveTrainsList()) {
                    if (atl.getEndBlock() == point.getFacing().getBlock()) {
                        if (atl.getLastAllocatedSection() == atl.getEndBlockSection()) {
                            at = atl;
                            break;
                        }
                    }
                }
                if (at != null) {
                    Section sec;
                    synchronized (this) {
                        if (sml != null && sml.getAssociatedSection((SignalMast) getSignal()) != null) {
                            sec = sml.getAssociatedSection((SignalMast) getSignal());
                        } else {
                            sec = InstanceManager.getDefault(SectionManager.class).getSection(src.getPoint().getDisplayName() + ":" + point.getDisplayName());
                        }
                    }
                    if (sec != null) {
                        if (!df.removeFromActiveTrainPath(sec, at, src.getPoint().getPanel())) {
                            log.error("Unable to remove allocation from dispathcer, leave interlock in place");  // NOI18N
                            src.pd.cancelNXButtonTimeOut();
                            point.cancelNXButtonTimeOut();
                            src.getPoint().getPanel().getGlassPane().setVisible(false);
                            return;
                        }
                        if (sec.getSectionType() == Section.DYNAMICADHOC) {
                            sec.removeAllBlocksFromSection();
                        }
                    }
                }
            }
        }
        src.setMenuEnabled(false);
        if (src.sourceSignal instanceof SignalMast) {
            SignalMast mast = (SignalMast) src.sourceSignal;
            mast.setAspect(mast.getAppearanceMap().getSpecificAppearance(SignalAppearanceMap.DANGER));
            if (!manager.isAbsSignalMode()) {
                mast.setHeld(true);
            }
        } else if (src.sourceSignal instanceof SignalHead) {
            SignalHead head = (SignalHead) src.sourceSignal;
            if (!manager.isAbsSignalMode()) {
                head.setHeld(true);
            }
        } else {
            log.debug("No signal found");  // NOI18N
        }

        //Get rid of the signal mast logic to the destination mast.
        synchronized (this) {
            if ((getSignal() instanceof SignalMast) && (sml != null)) {
                SignalMast mast = (SignalMast) getSignal();
                if (sml.getStoreState(mast) == SignalMastLogic.STORENONE) {
                    sml.removeDestination(mast);
                }
            }
            sml = null;
        }

        if (routeDetails == null) {
            return;
        }

        // The block list for an interlocking NX still has the facing block if there are no signals.
        LayoutBlock facing = getSource().getStart();
        for (LayoutBlock blk : routeDetails) {
            if (blk == facing) {
                // Skip the facing block if it is still in the block list.
                continue;
            }
            if ((getEntryExitType() == EntryExitPairs.FULLINTERLOCK)) {
                blk.setUseExtraColor(false);
            }
            blk.getBlock().removePropertyChangeListener(propertyBlockListener); // was set against occupancy sensor
        }

        if (cancelClear == EntryExitPairs.CLEARROUTE) {
            if (routeDetails.isEmpty()) {
                if (log.isDebugEnabled()) {
                    log.debug("{}  all blocks have automatically been cleared down", getUserName());  // NOI18N
                }
            } else {
                if (log.isDebugEnabled()) {
                    log.debug("{}  No blocks were cleared down {}", getUserName(), routeDetails.size());  // NOI18N
                }
                try {
                    if (log.isDebugEnabled()) {
                        log.debug("{}  set first block as active so that we can manually clear this down {}", getUserName(), routeDetails.get(0).getBlock().getUserName());  // NOI18N
                    }
                    if (routeDetails.get(0).getOccupancySensor() != null) {
                        routeDetails.get(0).getOccupancySensor().setState(Sensor.ACTIVE);
                    } else {
                        routeDetails.get(0).getBlock().goingActive();
                    }

                    if (src.getStart().getOccupancySensor() != null) {
                        src.getStart().getOccupancySensor().setState(Sensor.INACTIVE);
                    } else {
                        src.getStart().getBlock().goingInactive();
                    }
                } catch (java.lang.NullPointerException e) {
                    log.error("error in clear route A", e);  // NOI18N
                } catch (JmriException e) {
                    log.error("error in clear route A", e);  // NOI18N
                }
                if (log.isDebugEnabled()) {
                    log.debug("{}  Going to clear routeDetails down {}", getUserName(), routeDetails.size());  // NOI18N
                    for (int i = 0; i < routeDetails.size(); i++) {
                        log.debug("Block at {} {}", i, routeDetails.get(i).getDisplayName());
                    }
                }
                if (routeDetails.size() > 1) {
                    //We will remove the propertychange listeners on the sensors as we will now manually clear things down.
                    //Should we just be usrc.pdating the block status and not the sensor
                    for (int i = 1; i < routeDetails.size() - 1; i++) {
                        if (log.isDebugEnabled()) {
                            log.debug("{} in loop Set active {} {}", getUserName(), routeDetails.get(i).getDisplayName(), routeDetails.get(i).getBlock().getSystemName());  // NOI18N
                        }
                        try {
                            if (routeDetails.get(i).getOccupancySensor() != null) {
                                routeDetails.get(i).getOccupancySensor().setState(Sensor.ACTIVE);
                            } else {
                                routeDetails.get(i).getBlock().goingActive();
                            }

                            if (log.isDebugEnabled()) {
                                log.debug("{} in loop Set inactive {} {}", getUserName(), routeDetails.get(i - 1).getDisplayName(), routeDetails.get(i - 1).getBlock().getSystemName());  // NOI18N
                            }
                            if (routeDetails.get(i - 1).getOccupancySensor() != null) {
                                routeDetails.get(i - 1).getOccupancySensor().setState(Sensor.INACTIVE);
                            } else {
                                routeDetails.get(i - 1).getBlock().goingInactive();
                            }
                        } catch (NullPointerException | JmriException e) {
                            log.error("error in clear route b ", e);  // NOI18N
                        }
                        // NOI18N

                    }
                    try {
                        if (log.isDebugEnabled()) {
                            log.debug("{} out of loop Set active {} {}", getUserName(), routeDetails.get(routeDetails.size() - 1).getDisplayName(), routeDetails.get(routeDetails.size() - 1).getBlock().getSystemName());  // NOI18N
                        }
                        //Get the last block an set it active.
                        if (routeDetails.get(routeDetails.size() - 1).getOccupancySensor() != null) {
                            routeDetails.get(routeDetails.size() - 1).getOccupancySensor().setState(Sensor.ACTIVE);
                        } else {
                            routeDetails.get(routeDetails.size() - 1).getBlock().goingActive();
                        }
                        if (log.isDebugEnabled()) {
                            log.debug("{} out of loop Set inactive {} {}", getUserName(), routeDetails.get(routeDetails.size() - 2).getUserName(), routeDetails.get(routeDetails.size() - 2).getBlock().getSystemName());  // NOI18N
                        }
                        if (routeDetails.get(routeDetails.size() - 2).getOccupancySensor() != null) {
                            routeDetails.get(routeDetails.size() - 2).getOccupancySensor().setState(Sensor.INACTIVE);
                        } else {
                            routeDetails.get(routeDetails.size() - 2).getBlock().goingInactive();
                        }
                    } catch (java.lang.NullPointerException e) {
                        log.error("error in clear route c", e);  // NOI18N
                    } catch (java.lang.ArrayIndexOutOfBoundsException e) {
                        log.error("error in clear route c", e);  // NOI18N
                    } catch (JmriException e) {
                        log.error("error in clear route c", e);  // NOI18N
                    }
                }
            }
        }
        setActiveEntryExit(false);
        setRouteFrom(false);
        setRouteTo(false);
        synchronized (this) {
            routeDetails = null;
            lastSeenActiveBlockObject = null;
        }
        src.pd.cancelNXButtonTimeOut();
        point.cancelNXButtonTimeOut();
        src.getPoint().getPanel().getGlassPane().setVisible(false);

    }

    public void setInterlockRoute(boolean reverseDirection) {
        if (activeEntryExit) {
            return;
        }
        activeBean(reverseDirection, false);
    }

    void activeBean(boolean reverseDirection) {
        activeBean(reverseDirection, true);
    }

    synchronized void activeBean(boolean reverseDirection, boolean showMessage) {
        routeChangeStarted = false;
        setOrClearRoute(reverseDirection, showMessage);
        if (!routeChangeStarted) {
            // The route is neither being set nor cleared down, so a route over several pairs
            // must not go on to its next pair
            manager.routeSettingDone(this, false);
        }
    }

    /**
     * True when the route is being set or cleared down. The result is then
     * reported to the manager when that has finished.
     */
    private boolean routeChangeStarted = false;

    private void setOrClearRoute(boolean reverseDirection, boolean showMessage) {
        // Clear any previous memory message
        MemoryManager mgr = InstanceManager.getDefault(MemoryManager.class);
        Memory nxMem = mgr.getMemory(manager.getMemoryOption());
        if (nxMem != null) {
            nxMem.setValue("");
        }

        if (!isEnabled()) {
            JmriJOptionPane.showMessageDialog(null, Bundle.getMessage("RouteDisabled", getDisplayName()));  // NOI18N
            src.pd.setNXButtonState(EntryExitPairs.NXBUTTONINACTIVE);
            point.setNXButtonState(EntryExitPairs.NXBUTTONINACTIVE);
            return;
        }
        if (activeEntryExit) {
            // log.debug(getUserName() + "  Our route is active so this would go for a clear down but we need to check that the we can clear it down" + activeEndPoint);
            if (!isEnabled()) {
                log.debug("A disabled entry exit has been called will bomb out");  // NOI18N
                return;
            }
            log.debug("{}  We have a valid match on our end point so we can clear down", getUserName());  // NOI18N
            //setRouteTo(false);
            //src.pd.setRouteFrom(false);
            routeChangeStarted = true;
            setRoute(false);
        } else {
            if (isRouteToPointSet()) {
                log.debug("{}  route to this point is set therefore can not set another to it ", getUserName());  // NOI18N
                if (showMessage && !manager.isRouteStacked(this, false)) {
                    handleNoCurrentRoute(reverseDirection, "Route already set to the destination point");  // NOI18N
                }
                src.pd.setNXButtonState(EntryExitPairs.NXBUTTONINACTIVE);
                point.setNXButtonState(EntryExitPairs.NXBUTTONINACTIVE);
                return;
            } else {
                LayoutBlock startlBlock = src.getStart();

                List<BestPath> pathList = new ArrayList<>(2);
                LayoutBlock protectLBlock;
                LayoutBlock destinationLBlock;
                //Need to work out around here the best one.
                for (LayoutBlock srcProLBlock : src.getSourceProtecting()) {
                    protectLBlock = srcProLBlock;
                    if (!reverseDirection) {
                        //We have a problem, the destination point is already setup with a route, therefore we would need to
                        //check some how that a route hasn't been set to it.
                        destinationLBlock = getFacing();
                        List<LayoutBlock> blocks = new ArrayList<>();
                        String errorMessage = null;
                        try {
                            blocks = InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlockConnectivityTools().getLayoutBlocks(startlBlock, destinationLBlock, protectLBlock, false, LayoutBlockConnectivityTools.Routing.SENSORTOSENSOR);
                        } catch (Exception e) {
                            errorMessage = e.getMessage();
                            //can be considered normal if no free route is found
                        }
                        BestPath toadd = new BestPath(startlBlock, protectLBlock, destinationLBlock, blocks);
                        toadd.setErrorMessage(errorMessage);
                        pathList.add(toadd);
                    } else {
                        // Handle reversed direction - Only used when Both Way is enabled.
                        // The controlling block references are flipped
                        startlBlock = point.getProtecting().get(0);
                        protectLBlock = point.getFacing();

                        destinationLBlock = src.getSourceProtecting().get(0);
                        if (log.isDebugEnabled()) {
                            log.debug("reverse set destination is set going for {} {} {}", startlBlock.getDisplayName(), destinationLBlock.getDisplayName(), protectLBlock.getDisplayName());  // NOI18N
                        }
                        try {
                            LayoutBlock srcPro = src.getSourceProtecting().get(0);  //Don't care what block the facing is protecting
                            //Need to add a check for the lengths of the returned lists, then choose the most appropriate
                            if (!InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlockConnectivityTools().checkValidDest(startlBlock, protectLBlock, srcPro, src.getStart(), LayoutBlockConnectivityTools.Routing.SENSORTOSENSOR)) {
                                startlBlock = getFacing();
                                protectLBlock = srcProLBlock;
                                if (log.isDebugEnabled()) {
                                    log.debug("That didn't work so try  {} {} {}", startlBlock.getDisplayName(), destinationLBlock.getDisplayName(), protectLBlock.getDisplayName());  // NOI18N
                                }
                                if (!InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlockConnectivityTools().checkValidDest(startlBlock, protectLBlock, srcPro, src.getStart(), LayoutBlockConnectivityTools.Routing.SENSORTOSENSOR)) {
                                    log.error("No route found");  // NOI18N
                                    JmriJOptionPane.showMessageDialog(null, "No Valid path found");  // NOI18N
                                    src.pd.setNXButtonState(EntryExitPairs.NXBUTTONINACTIVE);
                                    point.setNXButtonState(EntryExitPairs.NXBUTTONINACTIVE);
                                    return;
                                } else {
                                    List<LayoutBlock> blocks = new ArrayList<>();
                                    String errorMessage = null;
                                    try {
                                        blocks = InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlockConnectivityTools().getLayoutBlocks(startlBlock, destinationLBlock, protectLBlock, false, LayoutBlockConnectivityTools.Routing.SENSORTOSENSOR);
                                    } catch (Exception e) {
                                        errorMessage = e.getMessage();
                                        //can be considered normal if no free route is found
                                    }
                                    BestPath toadd = new BestPath(startlBlock, protectLBlock, destinationLBlock, blocks);
                                    toadd.setErrorMessage(errorMessage);
                                    pathList.add(toadd);
                                }
                            } else if (InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlockConnectivityTools().checkValidDest(getFacing(), srcProLBlock, srcPro, src.getStart(), LayoutBlockConnectivityTools.Routing.SENSORTOSENSOR)) {
                                //Both paths are valid, so will go for setting the shortest
                                int distance = startlBlock.getBlockHopCount(destinationLBlock.getBlock(), protectLBlock.getBlock());
                                int distance2 = getFacing().getBlockHopCount(destinationLBlock.getBlock(), srcProLBlock.getBlock());
                                if (distance > distance2) {
                                    //The alternative route is shorter we shall use that
                                    startlBlock = getFacing();
                                    protectLBlock = srcProLBlock;
                                }
                                List<LayoutBlock> blocks = new ArrayList<>();
                                String errorMessage = "";
                                try {
                                    blocks = InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlockConnectivityTools().getLayoutBlocks(startlBlock, destinationLBlock, protectLBlock, false, LayoutBlockConnectivityTools.Routing.NONE);
                                } catch (Exception e) {
                                    //can be considered normal if no free route is found
                                    errorMessage = e.getMessage();
                                }
                                BestPath toadd = new BestPath(startlBlock, protectLBlock, destinationLBlock, blocks);
                                toadd.setErrorMessage(errorMessage);
                                pathList.add(toadd);
                            } else {
                                List<LayoutBlock> blocks = new ArrayList<>();
                                String errorMessage = "";
                                try {
                                    blocks = InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlockConnectivityTools().getLayoutBlocks(startlBlock, destinationLBlock, protectLBlock, false, LayoutBlockConnectivityTools.Routing.NONE);
                                } catch (Exception e) {
                                    //can be considered normal if no free route is found
                                    errorMessage = e.getMessage();
                                }
                                BestPath toadd = new BestPath(startlBlock, protectLBlock, destinationLBlock, blocks);
                                toadd.setErrorMessage(errorMessage);
                                pathList.add(toadd);
                            }
                        } catch (JmriException ex) {
                            log.error("Exception {}", ex.getMessage());  // NOI18N
                            if (showMessage) {
                                JmriJOptionPane.showMessageDialog(null, ex.getMessage());
                            }
                            src.pd.setNXButtonState(EntryExitPairs.NXBUTTONINACTIVE);
                            point.setNXButtonState(EntryExitPairs.NXBUTTONINACTIVE);
                            return;
                        }
                    }
                }
                if (pathList.isEmpty()) {
                    log.debug("Path list empty so exiting");  // NOI18N
                    return;
                }
                BestPath pathToUse = null;
                if (pathList.size() == 1) {
                    if (!pathList.get(0).getListOfBlocks().isEmpty()) {
                        pathToUse = pathList.get(0);
                    }
                } else {
                    /*Need to filter out the remaining routes, in theory this should only ever be two.
                     We simply pick at this stage the one with the least number of blocks as being preferred.
                     This could be expanded at some stage to look at either the length or the metric*/
                    int noOfBlocks = 0;
                    for (BestPath bp : pathList) {
                        if (!bp.getListOfBlocks().isEmpty()) {
                            if (noOfBlocks == 0 || bp.getListOfBlocks().size() < noOfBlocks) {
                                noOfBlocks = bp.getListOfBlocks().size();
                                pathToUse = bp;
                            }
                        }
                    }
                }
                if (pathToUse == null) {
                    //No valid paths found so will quit
                    if (pathList.get(0).getListOfBlocks().isEmpty()) {
                        if (showMessage) {
                            //Considered normal if not a valid through path, provide an option to stack
                            handleNoCurrentRoute(reverseDirection, pathList.get(0).getErrorMessage());
                            src.pd.setNXButtonState(EntryExitPairs.NXBUTTONINACTIVE);
                            point.setNXButtonState(EntryExitPairs.NXBUTTONINACTIVE);
                        }
                        return;
                    }
                    pathToUse = pathList.get(0);
                }
                startlBlock = pathToUse.getStartBlock();
                protectLBlock = pathToUse.getProtectingBlock();
                destinationLBlock = pathToUse.getDestinationBlock();
                routeDetails = pathToUse.getListOfBlocks();

                synchronized (this) {
                    destination = destinationLBlock;
                }

                if (log.isDebugEnabled()) {
                    log.debug("[activeBean] Path chosen start = {}, dest = {}, protect = {}", startlBlock.getDisplayName(),  // NOI18N
                            destinationLBlock.getDisplayName(), protectLBlock.getDisplayName());
                    for (LayoutBlock blk : routeDetails) {
                        log.debug("  block {}", blk.getDisplayName());
                    }
                }

                if (getEntryExitType() == EntryExitPairs.FULLINTERLOCK) {
                    setActiveEntryExit(true, reverseDirection);
                }

                routeChangeStarted = true;
                // The route is set in steps on the layout thread, so this does not wait for the turnouts
                log.debug("[activeBean] Start setRoute, dp = {}", getUserName());
                try {
                    setRoute(true);
                } catch (Exception e) {
                    log.error("[activeBean] setRoute exception: {}", e.getMessage());
                    manager.routeSettingDone(this, false);
                }
            }
        }
    }

    private static class BestPath {

        LayoutBlock srcProtecting = null;
        LayoutBlock srcStart = null;
        LayoutBlock destination = null;

        BestPath(LayoutBlock startPro, LayoutBlock sourceProtecting, LayoutBlock destinationBlock, List<LayoutBlock> blocks) {
            srcStart = startPro;
            srcProtecting = sourceProtecting;
            destination = destinationBlock;
            listOfBlocks = blocks;
        }

        LayoutBlock getStartBlock() {
            return srcStart;
        }

        LayoutBlock getProtectingBlock() {
            return srcProtecting;
        }

        LayoutBlock getDestinationBlock() {
            return destination;
        }

        List<LayoutBlock> listOfBlocks = new ArrayList<>(0);
        String errorMessage = "";

        List<LayoutBlock> getListOfBlocks() {
            return listOfBlocks;
        }

        void setErrorMessage(String msg) {
            errorMessage = msg;
        }

        String getErrorMessage() {
            return errorMessage;
        }
    }

    void handleNoCurrentRoute(boolean reverse, String message) {
        int opt = manager.getOverlapOption();

        if (opt == EntryExitPairs.PROMPTUSER) {
            Object[] options = {
                    Bundle.getMessage("ButtonYes"),  // NOI18N
                    Bundle.getMessage("ButtonNo")};  // NOI18N
            int ans = JmriJOptionPane.showOptionDialog(null,
                    message + "\n" + Bundle.getMessage("StackRouteAsk"), Bundle.getMessage("RouteNotClear"), // NOI18N
                    JmriJOptionPane.DEFAULT_OPTION,
                    JmriJOptionPane.QUESTION_MESSAGE,
                    null,
                    options,
                    options[1]);
            if (ans == 0) { // array position 0 Yes
                opt = EntryExitPairs.OVERLAP_STACK;
            } else { // array position 1 or Dialog closed
                opt = EntryExitPairs.OVERLAP_CANCEL;
            }
        }

        if (opt == EntryExitPairs.OVERLAP_STACK) {
            manager.stackNXRoute(this, reverse);
            firePropertyChange(PROPERTY_STACKED, null, null);
        } else {
            firePropertyChange(PROPERTY_FAILED, null, null);
        }

        // Set memory value if requested
        MemoryManager mgr = InstanceManager.getDefault(MemoryManager.class);
        Memory nxMem = mgr.getMemory(manager.getMemoryOption());
        if (nxMem != null) {
            String optString = (opt == EntryExitPairs.OVERLAP_STACK)
                    ? Bundle.getMessage("StackRoute")       // NOI18N
                    : Bundle.getMessage("CancelRoute");     // NOI18N
            nxMem.setValue(Bundle.getMessage("MemoryMessage", message, optString));  // NOI18N

            // Check for auto memory clear delay
            int delay = manager.getMemoryClearDelay() * 1000;
            if (delay > 0) {
                javax.swing.Timer memoryClear = new javax.swing.Timer(delay, new java.awt.event.ActionListener() {
                    @Override
                    public void actionPerformed(java.awt.event.ActionEvent e) {
                        nxMem.setValue("");
                    }
                });
                memoryClear.setRepeats(false);
                memoryClear.start();
            }
        }
    }

    @Override
    public void dispose() {
        enabled = false;
        setActiveEntryExit(false);
        cancelClearInterlock(EntryExitPairs.CANCELROUTE);
        setRouteFrom(false);
        setRouteTo(false);
        point.removeDestination(this);
        synchronized (this) {
            lastSeenActiveBlockObject = null;
        }
        disposed = true;
        super.dispose();
    }

    @Override
    public int getState() {
        if (activeEntryExit) {
            return 0x02;
        }
        return 0x04;
    }

    public boolean isActive() {
        return activeEntryExit;
    }

    public boolean isReversed() {
        return activeEntryExitReversed;
    }

    public boolean isUniDirection() {
        return uniDirection;
    }

    @Override
    public void setState(int state) {
    }

    protected void setActiveEntryExit(boolean boo) {
        setActiveEntryExit(boo, false);
    }

    protected void setActiveEntryExit(boolean boo, boolean reversed) {
        int oldvalue = getState();
        activeEntryExit = boo;
        activeEntryExitReversed = reversed;
        src.setMenuEnabled(boo);
        firePropertyChange(PROPERTY_ACTIVE, oldvalue, getState());
    }

    @Override
    public List<NamedBeanUsageReport> getUsageReport(NamedBean bean) {
        List<NamedBeanUsageReport> report = new ArrayList<>();
        if (bean != null) {
            if (bean.equals(getSource().getPoint().getSensor())) {
                report.add(new NamedBeanUsageReport("EntryExitSourceSensor"));  // NOI18N
            }
            if (bean.equals(getSource().getPoint().getSignal())) {
                report.add(new NamedBeanUsageReport("EntryExitSourceSignal"));  // NOI18N
            }
            if (bean.equals(getDestPoint().getSensor())) {
                report.add(new NamedBeanUsageReport("EntryExitDestinationSensor"));  // NOI18N
            }
            if (bean.equals(getDestPoint().getSignal())) {
                report.add(new NamedBeanUsageReport("EntryExitDesinationSignal"));  // NOI18N
            }
        }
        return report;
    }

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

}