package jmri.implementation;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyVetoException;
import java.beans.VetoableChangeListener;
import java.util.*;

import javax.annotation.CheckForNull;
import javax.annotation.Nonnull;

import jmri.*;
import jmri.jmrit.display.EditorManager;
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.LayoutEditor;
import jmri.jmrit.display.layoutEditor.LayoutSlip;
import jmri.jmrit.display.layoutEditor.LayoutTrackExpectedState;
import jmri.jmrit.display.layoutEditor.LayoutTurnout;
import jmri.jmrit.display.layoutEditor.LayoutTraverser;
import jmri.jmrit.display.layoutEditor.LayoutTurntable;
import jmri.jmrit.display.layoutEditor.LevelXing;
import jmri.util.ThreadingUtil;

/**
 * Default implementation of {@link jmri.SignalMastLogic}.
 *
 * @author Kevin Dickerson Copyright (C) 2011
 */
public class DefaultSignalMastLogic extends AbstractNamedBean implements SignalMastLogic, VetoableChangeListener {

    SignalMast source;
    SignalMast destination;
    String stopAspect;

    Hashtable<SignalMast, DestinationMast> destList = new Hashtable<>();
    LayoutEditor editor;

    LayoutBlock facingBlock = null;
    LayoutBlock remoteProtectingBlock = null;

    boolean disposing = false;

    /**
     * Initialise a Signal Mast Logic for a given source Signal Mast.
     *
     * @param source  The Signal Mast we are configuring an SML for
     */
    public DefaultSignalMastLogic(@Nonnull SignalMast source) {
        super(source.toString()); // default system name
        this.source = source;
        try {
            this.stopAspect = source.getAppearanceMap().getSpecificAppearance(SignalAppearanceMap.DANGER);
            this.source.addPropertyChangeListener(propertySourceMastListener);
            if (source.getAspect() == null) {
                source.setAspect(stopAspect);
            }
        } catch (Exception ex) {
            log.error("Error while creating Signal Logic", ex);
        }
    }

    // Most of the following methods will inherit Javadoc from SignalMastLogic.java
    /**
     * {@inheritDoc }
     */
    @Override
    public void setFacingBlock(LayoutBlock facing) {
        facingBlock = facing;
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public LayoutBlock getFacingBlock() {
        return facingBlock;
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public LayoutBlock getProtectingBlock(@Nonnull SignalMast dest) {
        if (!destList.containsKey(dest)) {
            return null;
        }
        return destList.get(dest).getProtectingBlock();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public SignalMast getSourceMast() {
        return source;
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void replaceSourceMast(SignalMast oldMast, SignalMast newMast) {
        if (oldMast != source) {
            // Old mast does not match new mast so will exit replace
            return;
        }
        source.removePropertyChangeListener(propertySourceMastListener);
        source = newMast;
        stopAspect = source.getAppearanceMap().getSpecificAppearance(SignalAppearanceMap.DANGER);
        source.addPropertyChangeListener(propertySourceMastListener);
        if (source.getAspect() == null) {
            source.setAspect(stopAspect);
        }
        getDestinationList().forEach(sm -> {
            DestinationMast destMast = destList.get(sm);
            if (destMast.getAssociatedSection() != null) {
                String oldUserName = destMast.getAssociatedSection().getUserName();
                String newUserName = source.getDisplayName() + ":" + sm.getDisplayName();
                if (oldUserName != null) {
                    InstanceManager.getDefault(NamedBeanHandleManager.class)
                        .renameBean(oldUserName, newUserName, ((NamedBean) destMast.getAssociatedSection()));
                } else {
                    log.warn("AssociatedSection oldUserName null for destination mast {}, skipped",
                        destMast.getDisplayName());
                }
            }
        });
        firePropertyChange(PROPERTY_UPDATED_SOURCE, oldMast, newMast);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void replaceDestinationMast(SignalMast oldMast, SignalMast newMast) {
        if (!destList.containsKey(oldMast)) {
            return;
        }
        DestinationMast destMast = destList.get(oldMast);
        destMast.updateDestinationMast(newMast);
        if (destination == oldMast) {
            oldMast.removePropertyChangeListener(propertyDestinationMastListener);
            newMast.addPropertyChangeListener(propertyDestinationMastListener);
            destination = newMast;
            setSignalAppearance();
        }
        destList.remove(oldMast);
        if (destMast.getAssociatedSection() != null) {
            String oldUserName = destMast.getAssociatedSection().getUserName();
            String newUserName = source.getDisplayName() + ":" + newMast.getDisplayName();
            if (oldUserName != null) {
                InstanceManager.getDefault(NamedBeanHandleManager.class)
                    .renameBean(oldUserName, newUserName, destMast.getAssociatedSection());
            } else {
                log.warn("AssociatedSection oldUserName null for destination mast {}, skipped",
                    destMast.getDisplayName());
            }
        }
        destList.put(newMast, destMast);
        firePropertyChange(PROPERTY_UPDATED_DESTINATION, oldMast, newMast);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void setDestinationMast(SignalMast dest) {
        if (destList.containsKey(dest)) {
            // if already present, not a change
            log.debug("Destination mast '{}' was already defined in SML with this source mast", dest.getDisplayName());
            return;
        }
        int oldSize = destList.size();
        destList.put(dest, new DestinationMast(dest));
        //InstanceManager.getDefault(SignalMastLogicManager.class).addDestinationMastToLogic(this, dest);
        firePropertyChange(PROPERTY_LENGTH, oldSize, destList.size());
        // make new dest mast appear in (update of) SignallingSourcePanel Table by having that table listen to PropertyChange Events from SML TODO
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public boolean isDestinationValid(SignalMast dest) {
        if (dest == null) {
            return false;
        }
        return destList.containsKey(dest);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public List<SignalMast> getDestinationList() {
        List<SignalMast> out = new ArrayList<>();
        Enumeration<SignalMast> en = destList.keys();
        while (en.hasMoreElements()) {
            out.add(en.nextElement());
        }
        return out;
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public String getComment(SignalMast dest) {
        if (!destList.containsKey(dest)) {
            return "";
        }
        return destList.get(dest).getComment();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void setComment(String comment, SignalMast dest) {
        if (!destList.containsKey(dest)) {
            return;
        }
        destList.get(dest).setComment(comment);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void setStore(int store, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return;
        }
        destList.get(destination).setStore(store);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public int getStoreState(SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return STORENONE;
        }
        return destList.get(destination).getStoreState();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void setEnabled(SignalMast dest) {
        if (!destList.containsKey(dest)) {
            return;
        }
        destList.get(dest).setEnabled();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void setDisabled(SignalMast dest) {
        if (!destList.containsKey(dest)) {
            return;
        }
        destList.get(dest).setDisabled();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public boolean isEnabled(SignalMast dest) {
        if (!destList.containsKey(dest)) {
            return false;
        }
        return destList.get(dest).isEnabled();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public boolean isActive(SignalMast dest) {
        if (!destList.containsKey(dest)) {
            return false;
        }
        return destList.get(dest).isActive();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public SignalMast getActiveDestination() {
        for (SignalMast sm : getDestinationList()) {
            if (destList.get(sm).isActive()) {
                return sm;
            }
        }
        return null;
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public boolean removeDestination(SignalMast dest) {
        int oldSize = destList.size();
        if (destList.containsKey(dest)) {
            //InstanceManager.getDefault(SignalMastLogicManager.class).removeDestinationMastToLogic(this, dest);
            destList.get(dest).dispose();
            destList.remove(dest);
            firePropertyChange(PROPERTY_LENGTH, oldSize, destList.size());
        }
        return destList.isEmpty();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void disableLayoutEditorUse() {
        destList.values().forEach(dest -> {
            try {
                dest.useLayoutEditor(false);
            } catch (JmriException e) {
                log.error("Could not disable LayoutEditor ",  e);
            }
        });
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void useLayoutEditor(boolean boo, SignalMast destination) throws JmriException {
        if (!destList.containsKey(destination)) {
            return;
        }
        if (boo) {
            log.debug("Set use layout editor");
            Set<LayoutEditor> layout = InstanceManager.getDefault(EditorManager.class).getAll(LayoutEditor.class);
            /*We don't care which layout editor panel the signalmast is on, just so long as
             the routing is done via layout blocks*/
            // TODO: what is this?
            log.debug("userLayoutEditor finds layout list size is {}", layout.size());
            for (LayoutEditor findeditor : layout) {
                log.debug("layouteditor {}", findeditor.getLayoutName());
                if (facingBlock == null) {
                    facingBlock = InstanceManager.getDefault(LayoutBlockManager.class)
                        .getFacingBlockByMast(getSourceMast(), findeditor);
                }
            }
        }
        destList.get(destination).useLayoutEditor(boo);
    }

    /**
     * Add direction sensors to SML
     *
     * @return number of errors
     */
    @Override
    public int setupDirectionSensors() {
        // iterrate over the signal masts
        int errorCount = 0;
        for (SignalMast sm : getDestinationList()) {
            String displayName = sm.getDisplayName();
            Section sec = getAssociatedSection(sm);
            if (sec != null) {
                Block thisFacingBlock;
                Sensor fwd = sec.getForwardBlockingSensor();
                Sensor rev = sec.getReverseBlockingSensor();
                LayoutBlock lBlock = getFacingBlock();
                if (lBlock == null) {
                    try {
                        useLayoutEditor(true, sm); // force a refind
                    } catch (JmriException ex) {
                        continue;
                    }
                }
                if (lBlock != null) {
                    thisFacingBlock = lBlock.getBlock();
                    EntryPoint fwdEntryPoint = sec.getEntryPointFromBlock(thisFacingBlock, Section.FORWARD);
                    EntryPoint revEntryPoint = sec.getEntryPointFromBlock(thisFacingBlock, Section.REVERSE);
                    log.debug("Mast[{}] Sec[{}] Fwd[{}] Rev [{}]",
                            displayName, sec, fwd, rev);
                    if (fwd != null && fwdEntryPoint != null) {
                        addSensor(fwd.getUserName(), Sensor.INACTIVE, sm);
                        log.debug("Mast[{}] Sec[{}] Fwd[{}] fwdEP[{}]",
                                displayName, sec, fwd,
                                fwdEntryPoint.getBlock().getUserName());

                    } else if (rev != null && revEntryPoint != null) {
                        addSensor(rev.getUserName(), Sensor.INACTIVE, sm);
                        log.debug("Mast[{}] Sec[{}] Rev [{}] revEP[{}]",
                                displayName, sec, rev,
                                revEntryPoint.getBlock().getUserName());

                    } else {
                        log.error("Mast[{}] Cannot Establish entry point to protected section", displayName);
                        errorCount += 1;
                    }
                } else {
                    log.error("Mast[{}] No Facing Block", displayName);
                    errorCount += 1;
                }
            } else {
                log.error("Mast[{}] No Associated Section", displayName);
                errorCount += 1;
            }
        }
        return errorCount;
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void removeDirectionSensors() {
        //TODO find aaway of easilty identifying the ones we added.
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public boolean useLayoutEditor(SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return false;
        }
        return destList.get(destination).useLayoutEditor();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void useLayoutEditorDetails(boolean turnouts, boolean blocks, SignalMast destination) throws JmriException {
        if (!destList.containsKey(destination)) {
            return;
        }
        destList.get(destination).useLayoutEditorDetails(turnouts, blocks);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public boolean useLayoutEditorBlocks(SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return false;
        }
        return destList.get(destination).useLayoutEditorBlocks();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public boolean useLayoutEditorTurnouts(SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return false;
        }
        return destList.get(destination).useLayoutEditorTurnouts();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public Section getAssociatedSection(SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return null;
        }
        return destList.get(destination).getAssociatedSection();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void setAssociatedSection(Section sec, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return;
        }
        destList.get(destination).setAssociatedSection(sec);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public boolean allowAutoMaticSignalMastGeneration(SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return false;
        }
        return destList.get(destination).allowAutoSignalMastGen();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void allowAutoMaticSignalMastGeneration(boolean allow, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return;
        }
        destList.get(destination).allowAutoSignalMastGen(allow);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void allowTurnoutLock(boolean lock, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return;
        }
        destList.get(destination).allowTurnoutLock(lock);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public boolean isTurnoutLockAllowed(SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return false;
        }
        return destList.get(destination).isTurnoutLockAllowed();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void setTurnouts(Hashtable<NamedBeanHandle<Turnout>, Integer> turnouts, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return;
        }
        destList.get(destination).setTurnouts(turnouts);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void setAutoTurnouts(Hashtable<Turnout, Integer> turnouts, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return;
        }
        destList.get(destination).setAutoTurnouts(turnouts);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void setBlocks(Hashtable<Block, Integer> blocks, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return;
        }
        destList.get(destination).setBlocks(blocks);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void setAutoBlocks(LinkedHashMap<Block, Integer> blocks, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return;
        }
        destList.get(destination).setAutoBlocks(blocks);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void setMasts(Hashtable<SignalMast, String> masts, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return;
        }
        destList.get(destination).setMasts(masts);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void setAutoMasts(Hashtable<SignalMast, String> masts, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return;
        }
        destList.get(destination).setAutoMasts(masts, true);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void setSensors(Hashtable<NamedBeanHandle<Sensor>, Integer> sensors, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return;
        }
        destList.get(destination).setSensors(sensors);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void addSensor(String sensorName, int state, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return;
        }
        Sensor sen = InstanceManager.sensorManagerInstance().getSensor(sensorName);
        if (sen != null) {
            NamedBeanHandle<Sensor> namedSensor = InstanceManager.getDefault(NamedBeanHandleManager.class)
                .getNamedBeanHandle(sensorName, sen);
            destList.get(destination).addSensor(namedSensor, state);
        }
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void removeSensor(String sensorName, SignalMast destination) {
        Sensor sen = InstanceManager.sensorManagerInstance().getSensor(sensorName);
        removeSensor(sen, destination);
    }

    public void removeSensor(Sensor sen, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return;
        }
        if (sen != null) {
            destList.get(destination).removeSensor(sen);
        }
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public List<Block> getBlocks(SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return new ArrayList<>();
        }
        return destList.get(destination).getBlocks();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public List<Block> getAutoBlocks(SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return new ArrayList<>();
        }
        return destList.get(destination).getAutoBlocks();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public List<Block> getAutoBlocksBetweenMasts(SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return new ArrayList<>();
        }
        return destList.get(destination).getAutoBlocksBetweenMasts();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public List<Turnout> getTurnouts(SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return new ArrayList<>();
        }
        return destList.get(destination).getTurnouts();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public List<NamedBeanHandle<Turnout>> getNamedTurnouts(SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return new ArrayList<>();
        }
        return destList.get(destination).getNamedTurnouts();
    }

    public void removeTurnout(Turnout turn, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return;
        }

        if (turn != null) {
            destList.get(destination).removeTurnout(turn);
        }
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public List<Turnout> getAutoTurnouts(SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return new ArrayList<>();
        }
        return destList.get(destination).getAutoTurnouts();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public List<Sensor> getSensors(SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return new ArrayList<>();
        }
        return destList.get(destination).getSensors();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public List<NamedBeanHandle<Sensor>> getNamedSensors(SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return new ArrayList<>();
        }
        return destList.get(destination).getNamedSensors();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public List<SignalMast> getSignalMasts(SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return new ArrayList<>();
        }
        return destList.get(destination).getSignalMasts();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public List<SignalMast> getAutoMasts(SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return new ArrayList<>();
        }
        return destList.get(destination).getAutoSignalMasts();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void initialise() {
        Enumeration<SignalMast> en = destList.keys();
        while (en.hasMoreElements()) {
            destList.get(en.nextElement()).initialise();
        }
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void initialise(SignalMast destination) {
        if (disposing) {
            return;
        }

        if (!destList.containsKey(destination)) {
            return;
        }
        destList.get(destination).initialise();
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public LinkedHashMap<Block, Integer> setupLayoutEditorTurnoutDetails(List<LayoutBlock> blks, SignalMast destination) {
        if (disposing) {
            return new LinkedHashMap<>();
        }

        if (!destList.containsKey(destination)) {
            return new LinkedHashMap<>();
        }
        return destList.get(destination).setupLayoutEditorTurnoutDetails(blks);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void setupLayoutEditorDetails() {
        if (disposing) {
            return;
        }
        Enumeration<SignalMast> en = destList.keys();
        while (en.hasMoreElements()) {
            try {
                destList.get(en.nextElement()).setupLayoutEditorDetails();
            } catch (JmriException e) {
                //Considered normal if no route is valid on a Layout Editor panel
            }
        }
    }

    /**
     * Check if routes to the destination Signal Mast are clear.
     *
     * @return true if the path to the next signal is clear
     */
    boolean checkStates() {
        SignalMast oldActiveMast = destination;
        SignalMast newActiveMast = null;
        boolean pairChanged = false;

        Enumeration<SignalMast> en = destList.keys();
        log.debug("checkStates enumerates over {} mast(s)", destList.size());
        while (en.hasMoreElements()) {
            SignalMast key = en.nextElement();
            DestinationMast dm = destList.get(key);
            log.debug("  Destination mast {}", key.getDisplayName());
            log.debug("    isEnabled: {}", dm.isEnabled());
            log.debug("    isActive: {}", dm.active);

            if (dm.active != dm.reportedActive) {
                dm.reportedActive = dm.active;
                pairChanged = true;
            }
            if (newActiveMast == null && dm.isEnabled() && dm.isActive()) {
                newActiveMast = key;
            }
        }
        if (newActiveMast == oldActiveMast) {
            // no change, so leave the listener, the turnout locks and the state as they are
            if (pairChanged) {
                // but let listeners such as the signalling tables show the pair that changed
                firePropertyChange(PROPERTY_STATE, null, newActiveMast);
            }
            return newActiveMast != null;
        }

        if (oldActiveMast != null) {
            log.debug("Remove listener from destination");
            oldActiveMast.removePropertyChangeListener(propertyDestinationMastListener);
            if (destList.containsKey(oldActiveMast)) {
                destList.get(oldActiveMast).clearTurnoutLock();
            }
        }
        destination = newActiveMast;
        if (newActiveMast == null) {
            firePropertyChange(PROPERTY_STATE, oldActiveMast, null);
            return false;
        }
        log.debug("      Add listener to destination");
        newActiveMast.addPropertyChangeListener(propertyDestinationMastListener);
        log.debug("      firePropertyChange: \"state\"");
        firePropertyChange(PROPERTY_STATE, oldActiveMast, newActiveMast);
        destList.get(newActiveMast).lockTurnouts();
        return true;
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public boolean areBlocksIncluded(List<Block> blks) {
        Enumeration<SignalMast> en = destList.keys();
        while (en.hasMoreElements()) {
            SignalMast dm = en.nextElement();
            boolean included;
            for (int i = 0; i < blks.size(); i++) {
                included = destList.get(dm).isBlockIncluded(blks.get(i));
                if (included) {
                    return true;
                }
                included = destList.get(dm).isAutoBlockIncluded(blks.get(i));
                if (included) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public int getBlockState(Block block, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return -1;
        }
        return destList.get(destination).getBlockState(block);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public boolean isBlockIncluded(Block block, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return false;
        }
        return destList.get(destination).isBlockIncluded(block);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public boolean isTurnoutIncluded(Turnout turnout, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return false;
        }
        return destList.get(destination).isTurnoutIncluded(turnout);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public boolean isSensorIncluded(Sensor sensor, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return false;
        }
        return destList.get(destination).isSensorIncluded(sensor);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public boolean isSignalMastIncluded(SignalMast signal, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return false;
        }
        return destList.get(destination).isSignalMastIncluded(signal);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public int getAutoBlockState(Block block, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return -1;
        }
        return destList.get(destination).getAutoBlockState(block);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public int getSensorState(Sensor sensor, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return -1;
        }
        return destList.get(destination).getSensorState(sensor);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public int getTurnoutState(Turnout turnout, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return -1;
        }
        return destList.get(destination).getTurnoutState(turnout);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public int getAutoTurnoutState(Turnout turnout, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return -1;
        }
        return destList.get(destination).getAutoTurnoutState(turnout);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public String getSignalMastState(SignalMast mast, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return null;
        }
        return destList.get(destination).getSignalMastState(mast);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public String getAutoSignalMastState(SignalMast mast, SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return null;
        }
        return destList.get(destination).getAutoSignalMastState(mast);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public float getMaximumSpeed(SignalMast destination) {
        if (!destList.containsKey(destination)) {
            return -1;
        }
        return destList.get(destination).getMinimumSpeed();
    }

    /**
     * True from when a job to set the source mast aspect is scheduled until
     * it, and any repeat of it, has finished.
     */
    volatile boolean inWait = false;

    /**
     * True while the scheduled job is working out and setting the aspect.
     * Guarded by this.
     */
    private boolean appearanceJobRunning = false;

    /**
     * True if a change arrived while the job was running, so the job must run
     * again to take it into account. Guarded by this.
     */
    private boolean appearanceJobRepeat = false;

    /**
     * Before going active or checking that we can go active, wait half the
     * signal logic delay for things to settle down to help prevent a race
     * condition.
     * <p>
     * A change that arrives while a job is waiting to start needs nothing
     * more, as the job will see it. A change that arrives while the job is
     * running may come after the job has read the state it changed, so the
     * job then runs again.
     */
    synchronized void setSignalAppearance() {
        log.debug("setMastAppearance (Aspect) called for {}", source.getDisplayName());
        if (inWait) {
            if (appearanceJobRunning) {
                log.debug("setMastAppearance (Aspect) called while the aspect is being set, will run again");
                appearanceJobRepeat = true;
            } else {
                log.debug("setMastAppearance (Aspect) called with inWait set, returning");
            }
            return;
        }
        inWait = true;
        scheduleAppearanceJob();
    }

    /**
     * Schedule the job that sets the source mast aspect. Called with this
     * locked.
     */
    private void scheduleAppearanceJob() {
        // The next line forces a single initialization of InstanceManager.getDefault(SignalSpeedMap.class)
        // before launching parallel threads
        InstanceManager.getDefault(SignalSpeedMap.class);

        // The next line forces a single initialization of InstanceManager.getDefault(SignalMastLogicManager.class)
        // before launching delay
        int tempDelay = InstanceManager.getDefault(SignalMastLogicManager.class).getSignalLogicDelay() / 2;
        log.debug("SignalMastLogicManager started (delay)");
        ThreadingUtil.runOnLayoutDelayed(this::runAppearanceJob, tempDelay);
    }

    private void runAppearanceJob() {
        synchronized (this) {
            appearanceJobRunning = true;
            appearanceJobRepeat = false;
        }
        try {
            setMastAppearance();
        } finally {
            synchronized (this) {
                appearanceJobRunning = false;
                boolean repeat = appearanceJobRepeat && !disposing;
                appearanceJobRepeat = false;
                if (repeat) {
                    try {
                        scheduleAppearanceJob();
                    } catch (RuntimeException ex) {
                        inWait = false;
                        log.error("Could not set the aspect of {} again", source.getDisplayName(), ex);
                    }
                } else {
                    inWait = false;
                }
            }
        }
    }

    /**
     * Evaluate the destination signal mast Aspect and set ours accordingly.
     */
    void setMastAppearance() {
        log.debug("Set source Signal Mast Aspect");
        if (disposing) {
            // a delayed check can still run after the logic has been disposed
            return;
        }
        if (getSourceMast().getHeld()) {
            log.debug("Signal is at a Held state so will set to the aspect defined for Held or Danger");

            String heldAspect = getSourceMast().getAppearanceMap().getSpecificAppearance(SignalAppearanceMap.HELD);
            if (heldAspect != null && !getSourceMast().isAspectDisabled(heldAspect)) {
                log.debug("  Setting to HELD value of {}", heldAspect);
            } else {
                heldAspect = getSourceMast().getAppearanceMap().getSpecificAppearance(SignalAppearanceMap.DANGER);
                log.debug("  Setting to DANGER value of {}", heldAspect);
            }
            String aspectSet = heldAspect; // for lambda
            try {
                ThreadingUtil.runOnLayout(() -> {
                    getSourceMast().setAspect(aspectSet);
                });
            } catch (RuntimeException ex) {
                log.error("Could not set held aspect {} on {}", aspectSet, getSourceMast().getDisplayName(), ex);
            }
            return;
        }
        if (!checkStates()) {
            log.debug("Advanced routes not clear, set Stop aspect");
            setSourceAspect(stopAspect);
            return;
        }
        String[] advancedAspect;
        if (destination.getHeld()) {
            if (destination.getAppearanceMap().getSpecificAppearance(SignalAppearanceMap.HELD) != null) {
                advancedAspect = getSourceMast().getAppearanceMap().getValidAspectsForAdvancedAspect(destination.getAppearanceMap().getSpecificAppearance(SignalAppearanceMap.HELD));
            } else {
                advancedAspect = getSourceMast().getAppearanceMap().getValidAspectsForAdvancedAspect(destination.getAppearanceMap().getSpecificAppearance(SignalAppearanceMap.DANGER));
            }
        } else {
            advancedAspect = getSourceMast().getAppearanceMap().getValidAspectsForAdvancedAspect(destination.getAspect());
        }

        log.debug("distant aspect is {}", destination.getAspect());
        log.debug("advanced aspect is {}", advancedAspect != null ? advancedAspect : "<null>");

        if (advancedAspect != null) {
            String aspect = stopAspect;
            if (destList.get(destination).permissiveBlock) {
                if (!getSourceMast().isPermissiveSmlDisabled()) {
                    //if a block is in a permissive state then we set the permissive appearance
                    aspect = getSourceMast().getAppearanceMap().getSpecificAppearance(SignalAppearanceMap.PERMISSIVE);
                }
            } else {
                for (String advancedAspect1 : advancedAspect) {
                    if (!getSourceMast().isAspectDisabled(advancedAspect1)) {
                        aspect = advancedAspect1;
                        break;
                    }
                }
                List<Integer> divergAspects = new ArrayList<>();
                List<Integer> nonDivergAspects = new ArrayList<>();
                List<Integer> eitherAspects = new ArrayList<>();
                if (advancedAspect.length > 1) {
                    float maxSigSpeed = -1;
                    float maxPathSpeed = destList.get(destination).getMinimumSpeed();
                    boolean divergRoute = destList.get(destination).turnoutThrown;

                    log.debug("Diverging route? {}", divergRoute);
                    boolean divergFlagsAvailable = false;
                    //We split the aspects into two lists, one with diverging flag set, the other without.
                    for (int i = 0; i < advancedAspect.length; i++) {
                        String div = null;
                        if (!getSourceMast().isAspectDisabled(advancedAspect[i])) {
                            div = (String) getSourceMast().getSignalSystem().getProperty(advancedAspect[i], "route");
                        }
                        if (div != null) {
                            if (div.equals("Diverging")) {
                                log.debug("Aspect {} added as Diverging Route", advancedAspect[i]);
                                divergAspects.add(i);
                                divergFlagsAvailable = true;
                                log.debug("Using Diverging Flag");
                            } else if (div.equals("Either")) {
                                log.debug("Aspect {} added as both Diverging and Normal Route", advancedAspect[i]);
                                nonDivergAspects.add(i);
                                divergAspects.add(i);
                                divergFlagsAvailable = true;
                                eitherAspects.add(i);
                                log.debug("Using Diverging Flag");
                            } else {
                                log.debug("Aspect {} added as Normal Route", advancedAspect[i]);
                                nonDivergAspects.add(i);
                                log.debug("Aspect {} added as Normal Route", advancedAspect[i]);
                            }
                        } else {
                            nonDivergAspects.add(i);
                            log.debug("Aspect {} added as Normal Route", advancedAspect[i]);
                        }
                    }
                    if ((eitherAspects.equals(divergAspects)) && (divergAspects.size() < nonDivergAspects.size())) {
                        //There are no unique diverging aspects
                        log.debug("'Either' aspects equals divergAspects and is less than non-diverging aspects");
                        divergFlagsAvailable = false;
                    }
                    log.debug("path max speed : {}", maxPathSpeed);
                    for (int i = 0; i < advancedAspect.length; i++) {
                        if (!getSourceMast().isAspectDisabled(advancedAspect[i])) {
                            String strSpeed = (String) getSourceMast().getSignalSystem().getProperty(advancedAspect[i], "speed");
                            log.debug("Aspect Speed = {} for aspect {}", strSpeed, advancedAspect[i]);
                            /*  if the diverg flags available is set and the diverg aspect
                             array contains the entry then we will check this aspect.

                             If the diverg flag has not been set then we will check.
                             */
                            log.debug("advanced aspect {}",advancedAspect[i]);
                            if ((divergRoute && (divergFlagsAvailable) && (divergAspects.contains(i))) || ((divergRoute && !divergFlagsAvailable) || (!divergRoute)) && (nonDivergAspects.contains(i))) {
                                log.debug("In list");
                                if ((strSpeed != null) && (!strSpeed.isEmpty())) {
                                    float speed = 0.0f;
                                    try {
                                        speed = Float.parseFloat(strSpeed);
                                    } catch (NumberFormatException nx) {
                                        // not a number, perhaps a name?
                                        try {
                                            speed = InstanceManager.getDefault(SignalSpeedMap.class).getSpeed(strSpeed);
                                        } catch (IllegalArgumentException ex) {
                                            // not a name either
                                            log.warn("Using speed = 0.0 because could not understand \"{}\"", strSpeed);
                                        }
                                    }
                                    //Integer state = Integer.parseInt(strSpeed);
                                    /* This pics out either the highest speed signal if there
                                     * is no block speed specified or the highest speed signal
                                     * that is under the minimum block speed.
                                     */
                                    log.debug("{} signal state speed {} maxSigSpeed {} maxPathSpeed {}", destination.getDisplayName(), speed, maxSigSpeed, maxPathSpeed);
                                    if (maxPathSpeed == 0) {
                                        if (maxSigSpeed == -1) {
                                            log.debug("min speed on this route is equal to 0 so will set this as our max speed");
                                            maxSigSpeed = speed;
                                            aspect = advancedAspect[i];
                                            log.debug("Aspect to set is {}", aspect);
                                        } else if (speed > maxSigSpeed) {
                                            log.debug("new speed is faster than old will use this");
                                            maxSigSpeed = speed;
                                            aspect = advancedAspect[i];
                                            log.debug("Aspect to set is {}", aspect);
                                        }
                                    } else if ((speed > maxSigSpeed) && (maxSigSpeed < maxPathSpeed) && (speed <= maxPathSpeed)) {
                                        //Only set the speed to the lowest if the max speed is greater than the path speed
                                        //and the new speed is less than the last max speed
                                        log.debug("our minimum speed on this route is less than our state speed, we will set this as our max speed");
                                        maxSigSpeed = speed;
                                        aspect = advancedAspect[i];
                                        log.debug("Aspect to set is {}", aspect);
                                    } else if ((maxSigSpeed > maxPathSpeed) && (speed < maxSigSpeed)) {
                                        log.debug("our max signal speed is greater than our path speed on this route, our speed is less that the maxSigSpeed");
                                        maxSigSpeed = speed;
                                        aspect = advancedAspect[i];
                                        log.debug("Aspect to set is {}", aspect);

                                    } else if (maxSigSpeed == -1) {
                                        log.debug("maxSigSpeed returned as -1");
                                        maxSigSpeed = speed;
                                        aspect = advancedAspect[i];
                                        log.debug("Aspect to set is {}", aspect);
                                    }
                                }
                            }
                        } else {
                            log.debug("Aspect has been disabled {}", advancedAspect[i]);
                        }
                    }
                }
            }
            if ((aspect != null) && (!aspect.isEmpty())) {
                log.debug("setMastAppearance setting aspect \"{}\"", aspect);
                String aspectSet = aspect; // for lambda
                try {
                    ThreadingUtil.runOnLayout(() -> {
                        setSourceAspect(aspectSet);
                    });
                } catch (Exception ex) {
                    log.error("Exception while setting Signal Logic", ex);
                }
                return;
            }
        }
        log.debug("Aspect returned is not valid, setting stop");
        ThreadingUtil.runOnLayout(() -> {
            setSourceAspect(stopAspect);
        });
    }

    /**
     * Set the aspect of the source mast, unless it already shows that aspect.
     * Hardware masts send a command to the layout every time their aspect is
     * set, so an unchanged aspect is not sent again.
     *
     * A null aspect, for example a mast whose appearance map has no Danger
     * aspect, is not passed to the mast.
     *
     * @param aspect the aspect to show
     */
    private void setSourceAspect(@CheckForNull String aspect) {
        SignalMast mast = getSourceMast();
        if (aspect == null) {
            log.warn("No aspect to set on source mast {}", mast.getDisplayName());
            return;
        }
        if (aspect.equals(mast.getAspect())) {
            log.debug("Source mast {} already shows {}", mast.getDisplayName(), aspect);
            return;
        }
        mast.setAspect(aspect);
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void setConflictingLogic(SignalMast sm, LevelXing lx) {
        if (sm == null) {
            return;
        }
        log.debug("setConflicting logic mast {}", sm.getDisplayName());
        if (sm == source) {
            log.debug("source is us so exit");
            return;
        }
        Enumeration<SignalMast> en = destList.keys();
        while (en.hasMoreElements()) {
            SignalMast dm = en.nextElement();
            if (destList.get(dm).isBlockIncluded(lx.getLayoutBlockAC())) {
                destList.get(dm).addAutoSignalMast(sm);
            } else if (destList.get(dm).isBlockIncluded(lx.getLayoutBlockBD())) {
                destList.get(dm).addAutoSignalMast(sm);
            } else if (destList.get(dm).isAutoBlockIncluded(lx.getLayoutBlockAC())) {
                destList.get(dm).addAutoSignalMast(sm);
            } else if (destList.get(dm).isAutoBlockIncluded(lx.getLayoutBlockBD())) {
                destList.get(dm).addAutoSignalMast(sm);
            } else {
                log.debug("Block not found");
            }
        }
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public void removeConflictingLogic(SignalMast sm, LevelXing lx) {
        if (sm == source) {
            return;
        }
        Enumeration<SignalMast> en = destList.keys();
        while (en.hasMoreElements()) {
            SignalMast dm = en.nextElement();
            if (destList.get(dm).isBlockIncluded(lx.getLayoutBlockAC())) {
                destList.get(dm).removeAutoSignalMast(sm);
            } else if (destList.get(dm).isBlockIncluded(lx.getLayoutBlockBD())) {
                destList.get(dm).removeAutoSignalMast(sm);
            }
        }
    }

    /**
     * Class to store SML properties for a destination mast paired with this
     * source mast.
     */
    private class DestinationMast {

        LayoutBlock destinationBlock = null;
        LayoutBlock protectingBlock = null; //this is the block that the source signal is protecting

        List<NamedBeanSetting> userSetTurnouts = new ArrayList<>(0);
        Hashtable<Turnout, Integer> autoTurnouts = new Hashtable<>(0);
        //Hashtable<Turnout, Boolean> turnoutThroats = new Hashtable<Turnout, Boolean>(0);
        //Hashtable<Turnout, Boolean> autoTurnoutThroats = new Hashtable<Turnout, Boolean>(0);

        List<NamedBeanSetting> userSetMasts = new ArrayList<>(0);
        Hashtable<SignalMast, String> autoMasts = new Hashtable<>(0);
        List<NamedBeanSetting> userSetSensors = new ArrayList<>(0);
        List<NamedBeanSetting> userSetBlocks = new ArrayList<>(0);
        boolean turnoutThrown = false;
        boolean permissiveBlock = false;
        boolean disposed = false;

        List<LevelXing> blockInXings = new ArrayList<>();

        //autoBlocks are for those automatically generated by the system.
        LinkedHashMap<Block, Integer> autoBlocks = new LinkedHashMap<>(0);

        List<Block> xingAutoBlocks = new ArrayList<>(0);
        List<Block> dblCrossoverAutoBlocks = new ArrayList<>(0);
        SignalMast destinationSignalMast;
        volatile boolean active = false;
        boolean reportedActive = false; // active state last reported by checkStates
        boolean destMastInit = false;

        float minimumBlockSpeed = 0.0f;

        boolean useLayoutEditor = false;
        boolean useLayoutEditorTurnouts = false;
        boolean useLayoutEditorBlocks = false;
        boolean lockTurnouts = false;

        NamedBeanHandle<Section> associatedSection = null;

        DestinationMast(SignalMast destination) {
            this.destinationSignalMast = destination;
            if (destination.getAspect() == null) {
                try {
                    destination.setAspect(destination.getAppearanceMap().getSpecificAppearance(SignalAppearanceMap.DANGER));
                } catch (Exception ex) {
                    log.error("Error while creating Signal Logic", ex);
                }
            }
        }

        void updateDestinationMast(SignalMast newMast) {
            destinationSignalMast = newMast;
            if (destinationSignalMast.getAspect() == null) {
                try {
                    destinationSignalMast.setAspect(destinationSignalMast.getAppearanceMap().getSpecificAppearance(SignalAppearanceMap.DANGER));
                } catch (Exception ex) {
                    log.error("Error while creating Signal Logic", ex);
                }
            }
        }

        LayoutBlock getProtectingBlock() {
            return protectingBlock;
        }

        String getDisplayName() {
            return destinationSignalMast.getDisplayName();
        }

        String comment;

        String getComment() {
            return comment;
        }

        void setComment(String comment) {
            String old = this.comment;
            this.comment = comment;
            firePropertyChange(PROPERTY_COMMENT, old, comment);
        }

        boolean isActive() {
            if (disposed) {
                log.error("checkState called even though this has been disposed of");
                return false;
            }
            return active;
        }

        float getMinimumSpeed() {
            return minimumBlockSpeed;
        }

        boolean enable = true;

        void setEnabled() {
            enable = true;
            firePropertyChange(PROPERTY_ENABLED, false, this.destinationSignalMast);
        }

        void setDisabled() {
            enable = false;
            firePropertyChange(PROPERTY_ENABLED, true, this.destinationSignalMast);
        }

        boolean isEnabled() {
            return enable;
        }

        int store = STOREALL;

        void setStore(int store) {
            this.store = store;
        }

        int getStoreState() {
            return store;
        }

        void setAssociatedSection(Section section) {
            if (section != null && (!useLayoutEditor || !useLayoutEditorBlocks)) {
                log.warn("This Logic {} to {} is not using the Layout Editor or its Blocks, the associated Section will not be populated correctly", source.getDisplayName(), destinationSignalMast.getDisplayName());
            }
            if (section == null) {
                associatedSection = null;
                return;
            }
            associatedSection = InstanceManager.getDefault(NamedBeanHandleManager.class).getNamedBeanHandle(section.getDisplayName(), section);
            if (!autoBlocks.isEmpty()) { // associatedSection is guaranteed to exist
                createSectionDetails();
            }
        }

        Section getAssociatedSection() {
            if (associatedSection != null) {
                return associatedSection.getBean();
            }
            return null;
        }

        void createSectionDetails() {
            getAssociatedSection().removeAllBlocksFromSection();
            getAutoBlocksBetweenMasts().forEach(key -> {
                getAssociatedSection().addBlock(key);
            });
            String dir = Path.decodeDirection(getFacingBlock().getNeighbourDirection(getProtectingBlock()));
            EntryPoint ep = new EntryPoint(getProtectingBlock().getBlock(), getFacingBlock().getBlock(), dir);
            ep.setTypeForward();
            getAssociatedSection().addToForwardList(ep);

            LayoutBlock proDestLBlock = InstanceManager.getDefault(LayoutBlockManager.class).getProtectedBlockByNamedBean(destinationSignalMast, destinationBlock.getMaxConnectedPanel());
            if (proDestLBlock != null) {
                log.debug("Add protecting Block {}", proDestLBlock.getDisplayName());
                dir = Path.decodeDirection(proDestLBlock.getNeighbourDirection(destinationBlock));
                ep = new EntryPoint(destinationBlock.getBlock(), proDestLBlock.getBlock(), dir);
                ep.setTypeReverse();
                getAssociatedSection().addToReverseList(ep);
            } else {
                log.debug(" ### Protecting Block not found ### ");
            }
        }

        boolean isTurnoutLockAllowed() {
            return lockTurnouts;
        }

        void allowTurnoutLock(boolean lock) {
            if (lockTurnouts == lock) {
                return;
            }
            if (!lock) {
                clearTurnoutLock();
            }
            lockTurnouts = lock;
        }

        void setTurnouts(Hashtable<NamedBeanHandle<Turnout>, Integer> turnouts) {
            if (this.userSetTurnouts != null) {
                userSetTurnouts.forEach(nbh ->
                    nbh.getBean().removePropertyChangeListener(propertyTurnoutListener));
            }
            destMastInit = false;
            if (turnouts == null) {
                userSetTurnouts = new ArrayList<>(0);
            } else {
                userSetTurnouts = new ArrayList<>();
                Enumeration<NamedBeanHandle<Turnout>> e = turnouts.keys();
                while (e.hasMoreElements()) {
                    NamedBeanHandle<Turnout> nbh = e.nextElement();
                    NamedBeanSetting nbs = new NamedBeanSetting(nbh, turnouts.get(nbh));
                    userSetTurnouts.add(nbs);
                }
            }
            firePropertyChange(PROPERTY_TURNOUTS, null, this.destinationSignalMast);
        }

        void setAutoTurnouts(Hashtable<Turnout, Integer> turnouts) {
            log.debug("{} called setAutoTurnouts with {}", destinationSignalMast.getDisplayName(),
                (turnouts != null ? "" + turnouts.size() + " turnouts in hash table" : "null hash table reference"));
            if (this.autoTurnouts != null) {
                Enumeration<Turnout> keys = this.autoTurnouts.keys();
                while (keys.hasMoreElements()) {
                    Turnout key = keys.nextElement();
                    key.removePropertyChangeListener(propertyTurnoutListener);
                }
                //minimumBlockSpeed = 0;
            }
            destMastInit = false;
            if (turnouts == null) {
                this.autoTurnouts = new Hashtable<>(0);
            } else {
                this.autoTurnouts = new Hashtable<>(turnouts);
            }
            firePropertyChange(PROPERTY_AUTO_TURNOUTS, null, this.destinationSignalMast);
        }

        void setBlocks(Hashtable<Block, Integer> blocks) {
            log.debug("{} Set blocks called", destinationSignalMast.getDisplayName());
            if (this.userSetBlocks != null) {
                userSetBlocks.forEach( nbh ->
                    nbh.getBean().removePropertyChangeListener(propertyBlockListener));
            }
            destMastInit = false;

            userSetBlocks = new ArrayList<>(0);
            if (blocks != null) {
                userSetBlocks = new ArrayList<>();
                Enumeration<Block> e = blocks.keys();
                while (e.hasMoreElements()) {
                    Block blk = e.nextElement();
                    NamedBeanHandle<?> nbh = InstanceManager.getDefault(NamedBeanHandleManager.class).getNamedBeanHandle(blk.getDisplayName(), blk);
                    NamedBeanSetting nbs = new NamedBeanSetting(nbh, blocks.get(blk));
                    userSetBlocks.add(nbs);
                }
            }
            firePropertyChange(PROPERTY_BLOCKS, null, this.destinationSignalMast);
        }

        public void setAutoBlocks(LinkedHashMap<Block, Integer> blocks) {
            if (log.isDebugEnabled()) {
                log.debug("{} called setAutoBlocks with {}", destinationSignalMast.getDisplayName(),
                    (blocks != null ? "" + blocks.size() + " blocks in hash table" : "null hash table reference"));
            }
            if (this.autoBlocks != null) {
                autoBlocks.keySet().forEach( key ->
                    key.removePropertyChangeListener(propertyBlockListener));
            }
            destMastInit = false;
            if (blocks == null) {
                this.autoBlocks = new LinkedHashMap<>(0);

            } else {
                this.autoBlocks = new LinkedHashMap<>(blocks);
                //We shall remove the facing block in the list.
                if (facingBlock != null && autoBlocks.containsKey(facingBlock.getBlock())) {
                    autoBlocks.remove(facingBlock.getBlock());
                }
                if (getAssociatedSection() != null) {
                    createSectionDetails();
                }
            }
            firePropertyChange(PROPERTY_AUTO_BLOCKS, null, this.destinationSignalMast);
        }

        void setMasts(Hashtable<SignalMast, String> masts) {
            if (this.userSetMasts != null) {
                userSetMasts.forEach( nbh ->
                    nbh.getBean().removePropertyChangeListener(propertySignalMastListener));
            }

            destMastInit = false;

            if (masts == null) {
                userSetMasts = new ArrayList<>(0);
            } else {
                userSetMasts = new ArrayList<>();
                Enumeration<SignalMast> e = masts.keys();
                while (e.hasMoreElements()) {
                    SignalMast mast = e.nextElement();
                    NamedBeanHandle<?> nbh = InstanceManager.getDefault(NamedBeanHandleManager.class)
                        .getNamedBeanHandle(mast.getDisplayName(), mast);
                    NamedBeanSetting nbs = new NamedBeanSetting(nbh, masts.get(mast));
                    userSetMasts.add(nbs);
                }
            }
            firePropertyChange(PROPERTY_MASTS, null, this.destinationSignalMast);
        }

        /**
         *
         * @param newAutoMasts Hashtable of signal masts and set to Aspects
         * @param overwrite    When true, replace an existing autoMasts list in
         *                     the SML
         */
        void setAutoMasts(Hashtable<SignalMast, String> newAutoMasts, boolean overwrite) {
            log.debug("{} setAutoMast Called", destinationSignalMast.getDisplayName());
            if (this.autoMasts != null) {
                Enumeration<SignalMast> keys = this.autoMasts.keys();
                while (keys.hasMoreElements()) {
                    SignalMast key = keys.nextElement();
                    key.removePropertyChangeListener(propertySignalMastListener);
                }
                //minimumBlockSpeed = 0;
            }
            destMastInit = false;
            if (overwrite) {
                if (newAutoMasts == null) {
                    this.autoMasts = new Hashtable<>(0);
                } else {
                    this.autoMasts = new Hashtable<>(newAutoMasts);
                }
            } else {
                if (newAutoMasts == null) {
                    this.autoMasts = new Hashtable<>(0);
                } else {
                    Enumeration<SignalMast> keys = newAutoMasts.keys();
                    while (keys.hasMoreElements()) {
                        SignalMast key = keys.nextElement();
                        this.autoMasts.put(key, newAutoMasts.get(key));
                    }
                }
            }
            //kick off the process to add back in signal masts at crossings.
            for (int i = 0; i < blockInXings.size(); i++) {
                blockInXings.get(i).addSignalMastLogic(source);
            }

            firePropertyChange(PROPERTY_AUTO_MASTS, null, this.destinationSignalMast);
        }

        void setSensors(Hashtable<NamedBeanHandle<Sensor>, Integer> sensors) {
            if (this.userSetSensors != null) {
                userSetSensors.forEach(nbh ->
                    nbh.getBean().removePropertyChangeListener(propertySensorListener));
            }
            destMastInit = false;

            if (sensors == null) {
                userSetSensors = new ArrayList<>(0);
            } else {
                userSetSensors = new ArrayList<>();
                Enumeration<NamedBeanHandle<Sensor>> e = sensors.keys();
                while (e.hasMoreElements()) {
                    NamedBeanHandle<Sensor> nbh = e.nextElement();
                    NamedBeanSetting nbs = new NamedBeanSetting(nbh, sensors.get(nbh));
                    userSetSensors.add(nbs);
                }
            }
            firePropertyChange(PROPERTY_SENSORS, null, this.destinationSignalMast);
        }

        void addSensor(NamedBeanHandle<Sensor> sen, int state) {
            for (NamedBeanSetting nbh : userSetSensors) {
                if (nbh.getBean().equals(sen.getBean())) {
                    return;
                }
            }
            sen.getBean().addPropertyChangeListener(propertySensorListener);
            NamedBeanSetting nbs = new NamedBeanSetting(sen, state);
            userSetSensors.add(nbs);
            firePropertyChange(PROPERTY_SENSORS, null, this.destinationSignalMast);
        }

// not used now, preserved for later use
//         void removeSensor(NamedBeanHandle<Sensor> sen) {
//             for (NamedBeanSetting nbh : userSetSensors) {
//                 if (nbh.getBean().equals(sen.getBean())) {
//                     sen.getBean().removePropertyChangeListener(propertySensorListener);
//                     userSetSensors.remove(nbh);
//                     firePropertyChange("sensors", null, this.destination);
//                     return;
//                 }
//             }
//         }

        void removeSensor(Sensor sen) {
            for (NamedBeanSetting nbh : userSetSensors) {
                if (nbh.getBean().equals(sen)) {
                    sen.removePropertyChangeListener(propertySensorListener);
                    userSetSensors.remove(nbh);
                    firePropertyChange(PROPERTY_SENSORS, null, this.destinationSignalMast);
                    return;
                }
            }
        }

        List<Block> getBlocks() {
            List<Block> out = new ArrayList<>();
            userSetBlocks.forEach( nbh -> out.add((Block) nbh.getBean()));
            return out;
        }

        List<Block> getAutoBlocks() {
            List<Block> out = new ArrayList<>();
            Set<Block> blockKeys = autoBlocks.keySet();
            blockKeys.forEach(key -> out.add(key));
            return out;
        }

        List<Block> getAutoBlocksBetweenMasts() {
            if (destList.get(destinationSignalMast).xingAutoBlocks.isEmpty()
                    && destList.get(destinationSignalMast).dblCrossoverAutoBlocks.isEmpty()) {
                return getAutoBlocks();
            }
            List<Block> returnList = getAutoBlocks();
            for (Block blk : getAutoBlocks()) {
                if (xingAutoBlocks.contains(blk)) {
                    returnList.remove(blk);
                }
                if (dblCrossoverAutoBlocks.contains(blk)) {
                    returnList.remove(blk);
                }
            }

            return returnList;
        }

        List<Turnout> getTurnouts() {
            List<Turnout> out = new ArrayList<>();
            userSetTurnouts.forEach( nbh -> out.add((Turnout) nbh.getBean()));
            return out;
        }

        void removeTurnout(Turnout turn) {
            Iterator<NamedBeanSetting> nbh = userSetTurnouts.iterator();
            while (nbh.hasNext()) {
                NamedBeanSetting i = nbh.next();
                if (i.getBean().equals(turn)) {
                    turn.removePropertyChangeListener(propertyTurnoutListener);
                    nbh.remove();
                    firePropertyChange(PROPERTY_TURNOUTS, null, this.destinationSignalMast);
                }
            }
        }

        @SuppressWarnings("unchecked") // (NamedBeanHandle<Turnout>) nbh.getNamedBean() is unchecked cast
        List<NamedBeanHandle<Turnout>> getNamedTurnouts() {
            List<NamedBeanHandle<Turnout>> out = new ArrayList<>();
            userSetTurnouts.forEach(nbh ->
                out.add((NamedBeanHandle<Turnout>) nbh.getNamedBean()));
            return out;
        }

        List<Turnout> getAutoTurnouts() {
            List<Turnout> out = new ArrayList<>();
            Enumeration<Turnout> en = autoTurnouts.keys();
            while (en.hasMoreElements()) {
                out.add(en.nextElement());
            }
            return out;
        }

        List<SignalMast> getSignalMasts() {
            List<SignalMast> out = new ArrayList<>();
            userSetMasts.forEach( nbh -> out.add((SignalMast) nbh.getBean()));
            return out;
        }

        List<SignalMast> getAutoSignalMasts() {
            List<SignalMast> out = new ArrayList<>();
            Enumeration<SignalMast> en = autoMasts.keys();
            while (en.hasMoreElements()) {
                out.add(en.nextElement());
            }
            return out;
        }

        List<Sensor> getSensors() {
            List<Sensor> out = new ArrayList<>();
            userSetSensors.forEach( nbh -> out.add((Sensor) nbh.getBean()));
            return out;
        }

        @SuppressWarnings("unchecked") // (NamedBeanHandle<Sensor>) nbh.getNamedBean() is unchecked cast
        List<NamedBeanHandle<Sensor>> getNamedSensors() {
            List<NamedBeanHandle<Sensor>> out = new ArrayList<>();
            userSetSensors.forEach( nbh -> out.add((NamedBeanHandle<Sensor>) nbh.getNamedBean()));
            return out;
        }

        boolean isBlockIncluded(Block block) {
            return userSetBlocks.stream().anyMatch(nbh -> (nbh.getBean().equals(block)));
        }

        boolean isAutoBlockIncluded(LayoutBlock block) {
            if (block != null) {
                return autoBlocks.containsKey(block.getBlock());
            }
            return false;
        }

        boolean isAutoBlockIncluded(Block block) {
            return autoBlocks.containsKey(block);
        }

        boolean isBlockIncluded(LayoutBlock block) {
            return userSetBlocks.stream().anyMatch(nbh -> (nbh.getBean().equals(block.getBlock())));
        }

        boolean isTurnoutIncluded(Turnout turnout) {
            return userSetTurnouts.stream().anyMatch(nbh -> (nbh.getBean().equals(turnout)));
        }

        boolean isSensorIncluded(Sensor sensor) {
            return userSetSensors.stream().anyMatch(nbh -> (nbh.getBean().equals(sensor)));
        }

        boolean isSignalMastIncluded(SignalMast signal) {
            return userSetMasts.stream().anyMatch(nbh -> (nbh.getBean().equals(signal)));
        }

        int getAutoBlockState(Block block) {
            if (autoBlocks == null) {
                return -1;
            }
            return autoBlocks.get(block);
        }

        int getBlockState(Block block) {
            if (userSetBlocks == null) {
                return -1;
            }
            for (NamedBeanSetting nbh : userSetBlocks) {
                if (nbh.getBean().equals(block)) {
                    return nbh.getSetting();
                }
            }
            return -1;
        }

        int getSensorState(Sensor sensor) {
            if (userSetSensors == null) {
                return -1;
            }
            for (NamedBeanSetting nbh : userSetSensors) {
                if (nbh.getBean().equals(sensor)) {
                    return nbh.getSetting();
                }
            }
            return -1;
        }

        int getTurnoutState(Turnout turnout) {
            if (userSetTurnouts == null) {
                return -1;
            }
            for (NamedBeanSetting nbh : userSetTurnouts) {
                if (nbh.getBean().equals(turnout)) {
                    return nbh.getSetting();
                }
            }
            return -1;
        }

        int getAutoTurnoutState(Turnout turnout) {
            if (autoTurnouts == null) {
                return -1;
            }
            if (autoTurnouts.containsKey(turnout)) {
                return autoTurnouts.get(turnout);
            }
            return -1;
        }

        String getSignalMastState(SignalMast mast) {
            if (userSetMasts == null) {
                return null;
            }
            for (NamedBeanSetting nbh : userSetMasts) {
                if (nbh.getBean().equals(mast)) {
                    return nbh.getStringSetting();
                }
            }
            return null;
        }

        String getAutoSignalMastState(SignalMast mast) {
            if (autoMasts == null) {
                return null;
            }
            return autoMasts.get(mast);
        }

        /**
         * True from when a check of this pair is scheduled until it, and any
         * repeat of it, has finished.
         */
        volatile boolean inWait = false;

        /**
         * The number of checks of this pair running now: a scheduled one, and
         * the first one, which {@link #initialise()} runs on its own thread.
         * Guarded by this.
         */
        private int checksRunning = 0;

        /**
         * True if something on the route changed while a check was running,
         * so what it found may be out of date and the check must run again.
         * Guarded by this.
         */
        private boolean checkRepeat = false;

        /*
         * Before going active or checking that we can go active, wait
         * for things to settle down to help prevent a race condition.
         * A change that arrives while a check is running may come after the
         * check has read the item that changed, so the check then runs again.
         */
        synchronized void checkState() {
            if (disposed) {
                log.error("checkState called even though this has been disposed of {}",
                    getSourceMast().getDisplayName());
                return;
            }

            if (!enable) {
                return;
            }
            if (checksRunning > 0) {
                checkRepeat = true;
            }
            if (inWait) {
                return;
            }

            log.debug("check Signal Dest State called");
            inWait = true;
            scheduleCheck();
        }

        /**
         * Schedule the check of this pair. Called with this locked.
         */
        private void scheduleCheck() {
            // The next line forces a single initialization of InstanceManager.getDefault(SignalMastLogicManager.class)
            // before launching parallel threads
            int tempDelay = InstanceManager.getDefault(SignalMastLogicManager.class).getSignalLogicDelay();

            ThreadingUtil.runOnLayoutDelayed(() -> runCheck(true), tempDelay);
        }

        /**
         * Check this pair, as a scheduled check or straight away.
         *
         * @param scheduled true for the check scheduled by
         *                  {@link #checkState()}, which clears
         *                  {@link #inWait} when it has finished
         */
        private void runCheck(boolean scheduled) {
            synchronized (this) {
                if (checksRunning == 0) {
                    checkRepeat = false;
                }
                checksRunning++;
            }
            try {
                // a delayed check can still run after this pair has been disposed
                if (!disposed) {
                    checkStateDetails();
                }
            } finally {
                synchronized (this) {
                    checksRunning--;
                    boolean repeat = false;
                    if (checksRunning == 0) {
                        // a scheduled check that has not started yet will see the change anyway
                        repeat = checkRepeat && !disposed && enable && (scheduled || !inWait);
                        checkRepeat = false;
                    }
                    if (repeat) {
                        inWait = true;
                        try {
                            scheduleCheck();
                        } catch (RuntimeException ex) {
                            inWait = false;
                            log.error("Could not check {} to {} again", getSourceMast().getDisplayName(),
                                destinationSignalMast.getDisplayName(), ex);
                        }
                    } else if (scheduled) {
                        inWait = false;
                    }
                }
            }
        }

        /**
         * A bean on the route has changed so that the route is no longer
         * set: go to danger at once. A check that is running may already have
         * read that bean, so it must not put back what it found; it runs
         * again instead. Called by the bean listeners, on whatever thread the
         * bean reports its change on.
         */
        private void routeNoLongerSet() {
            boolean wasActive;
            synchronized (this) {
                if (checksRunning > 0) {
                    checkRepeat = true;
                }
                wasActive = active;
                active = false;
            }
            if (wasActive) {
                setSignalAppearance();
            }
        }

        /**
         * Check the details of this source-destination signal mast logic pair.
         * Steps through every sensor, turnout etc. before setting the SML
         * Aspect on the source mast via {
         *
         * @see #setSignalAppearance } and {
         * @see #setMastAppearance }
         */
        private void checkStateDetails() {
            turnoutThrown = false;
            permissiveBlock = false;
            if (disposed) {
                log.error("checkStateDetails called even though this has been disposed of {} {}",
                    getSourceMast().getDisplayName(), destinationSignalMast.getDisplayName());
                return;
            }
            if (!enable) {
                return;
            }
            log.debug("From {} to {} internal check state", getSourceMast().getDisplayName(),
                destinationSignalMast.getDisplayName());
            boolean wasActive = active;
            active = false;
            if ((useLayoutEditor) && (autoTurnouts.isEmpty()) && (autoBlocks.isEmpty())) {
                return;
            }
            boolean state = true;
            Enumeration<Turnout> keys = autoTurnouts.keys();
            while (keys.hasMoreElements()) {
                Turnout key = keys.nextElement();
                if (key.getKnownState() != autoTurnouts.get(key)) {
                    if (key.getState() != autoTurnouts.get(key)) {
                        if (isTurnoutIncluded(key)) {
                            if (key.getState() != getTurnoutState(key)) {
                                state = false;
                            } else if (key.getState() == Turnout.THROWN) {
                                turnoutThrown = true;
                            }
                        } else {
                            state = false;
                        }
                    }
                } else if (key.getState() == Turnout.THROWN) {
                    turnoutThrown = true;
                }
            }

            for (NamedBeanSetting nbh : userSetTurnouts) {
                Turnout key = (Turnout) nbh.getBean();
                if (key.getKnownState() != nbh.getSetting()) {
                    state = false;
                } else if (key.getState() == Turnout.THROWN) {
                    turnoutThrown = true;
                }
            }

            Enumeration<SignalMast> mastKeys = autoMasts.keys();
            while (mastKeys.hasMoreElements()) {
                SignalMast key = mastKeys.nextElement();
                String aspect = key.getAspect();
                log.debug("key {} {} {}", key.getDisplayName(), aspect, autoMasts.get(key));
                if ((aspect != null) && (!aspect.equals(autoMasts.get(key)))) {
                    if (isSignalMastIncluded(key)) {
                        //Basically if we have a blank aspect, we don't care about the state of the signalmast
                        if (!getSignalMastState(key).isEmpty()) {
                            if (!aspect.equals(getSignalMastState(key))) {
                                state = false;
                            }
                        }
                    } else {
                        state = false;
                    }
                }
            }
            for (NamedBeanSetting nbh : userSetMasts) {
                SignalMast key = (SignalMast) nbh.getBean();
                String aspect = key.getAspect();
                if ((aspect == null) || (!aspect.equals(nbh.getStringSetting()))) {
                    state = false;
                }
            }

            for (NamedBeanSetting nbh : userSetSensors) {
                Sensor key = (Sensor) nbh.getBean();
                if (key.getKnownState() != nbh.getSetting()) {
                    state = false;
                }
            }

            for (Map.Entry<Block, Integer> entry : this.autoBlocks.entrySet()) {
                log.debug(" entry {} {} {}", entry.getKey().getDisplayName(),
                    entry.getKey().getState(), entry.getValue());
                if (entry.getKey().getState() != autoBlocks.get(entry.getKey())) {
                    if (isBlockIncluded(entry.getKey())) {
                        if (getBlockState(entry.getKey()) != 0x03) {
                            if (entry.getKey().getState() != getBlockState(entry.getKey())) {
                                if (entry.getKey().getState() == Block.OCCUPIED && entry.getKey().getPermissiveWorking()) {
                                    permissiveBlock = true;
                                } else {
                                    state = false;
                                }
                            }
                        }
                    } else {
                        if (entry.getKey().getState() == Block.OCCUPIED && entry.getKey().getPermissiveWorking()) {
                            permissiveBlock = true;
                        } else if (entry.getKey().getState() == Block.UNDETECTED) {
                            log.debug("Block {} is UNDETECTED so treat as unoccupied", entry.getKey().getDisplayName());
                        } else {
                            state = false;
                        }
                    }
                }
            }

            for (NamedBeanSetting nbh : userSetBlocks) {
                Block key = (Block) nbh.getBean();
                if (nbh.getSetting() != 0x03) {
                    if (key.getState() != nbh.getSetting()) {
                        if (key.getState() == Block.OCCUPIED && key.getPermissiveWorking()) {
                            permissiveBlock = true;
                        } else {
                            state = false;
                        }
                    }
                }
            }
            if (permissiveBlock
                /*If a block has been found to be permissive, but the source signalmast
                 does not support a call-on/permissive aspect then the route can not be set*/
                && getSourceMast().getAppearanceMap().getSpecificAppearance(SignalAppearanceMap.PERMISSIVE) == null) {
                    state = false;
            }

            /*This check is purely for use with the dispatcher. A block set to "useExtraColor" has been
             allocated; if it is held by a train other than the one approaching this mast, the signal
             is set to danger.*/
            if (state && getAssociatedSection() != null
                    && InstanceManager.isInitialized(jmri.jmrit.dispatcher.DispatcherFrame.class)
                    && InstanceManager.getNullableDefault(LayoutBlockManager.class) != null) {

                LayoutBlockManager lbm = InstanceManager.getDefault(LayoutBlockManager.class);
                List<Block> routeBlocks = new ArrayList<>(autoBlocks.keySet());
                for (NamedBeanSetting nbh : userSetBlocks) {
                    routeBlocks.add((Block) nbh.getBean());
                }
                if (isRouteHeldByAnotherTrain(routeBlocks, lbm)) {
                    state = false;
                }
            }

            synchronized (this) {
                if (checkRepeat) {
                    // something on the route changed while this check ran, so
                    // what it found may be out of date: stay at danger until
                    // the check has run again
                    state = false;
                }
                if (!state) {
                    turnoutThrown = false;
                    permissiveBlock = false;
                }
                active = state;
            }
            // The source mast only needs setting again if this pair has changed
            // or it is the pair the source mast is currently showing.
            if (state != wasActive || destination == destinationSignalMast) {
                ThreadingUtil.runOnLayout(() -> {
                    setSignalAppearance();
                });
            }
        }

        /**
         * Set up this source-destination signal mast logic pair. Steps through
         * every list defined on the source mast.
         */
        void initialise() {
            if ((destMastInit) || (disposed)) {
                return;
            }

            active = false;
            turnoutThrown = false;
            permissiveBlock = false;
            if ((useLayoutEditor) && (autoTurnouts.isEmpty()) && (autoBlocks.isEmpty()) && (autoMasts.isEmpty())) {
                return;
            }

            calculateSpeed();

            // Each listener is removed before it is added, so that initialising
            // again (e.g. after one list has been changed) does not add it twice.
            Enumeration<Turnout> keys = autoTurnouts.keys();
            while (keys.hasMoreElements()) {
                Turnout key = keys.nextElement();
                key.removePropertyChangeListener(propertyTurnoutListener);
                key.addPropertyChangeListener(propertyTurnoutListener);
            }

            for (NamedBeanSetting nbh : userSetTurnouts) {
                Turnout key = (Turnout) nbh.getBean();
                key.removePropertyChangeListener(propertyTurnoutListener);
                key.addPropertyChangeListener(propertyTurnoutListener, nbh.getBeanName(),
                    "Signal Mast Logic:" + source.getDisplayName() + " to " + destinationSignalMast.getDisplayName());
            }

            Enumeration<SignalMast> mastKeys = autoMasts.keys();
            while (mastKeys.hasMoreElements()) {
                SignalMast key = mastKeys.nextElement();
                log.debug("{} auto mast add list {}", destinationSignalMast.getDisplayName(), key.getDisplayName());
                key.removePropertyChangeListener(propertySignalMastListener);
                key.addPropertyChangeListener(propertySignalMastListener);
            }

            for (NamedBeanSetting nbh : userSetMasts) {
                SignalMast key = (SignalMast) nbh.getBean();
                key.removePropertyChangeListener(propertySignalMastListener);
                key.addPropertyChangeListener(propertySignalMastListener);
            }
            for (NamedBeanSetting nbh : userSetSensors) {
                Sensor sensor = (Sensor) nbh.getBean();
                sensor.removePropertyChangeListener(propertySensorListener);
                sensor.addPropertyChangeListener(propertySensorListener, nbh.getBeanName(),
                    "Signal Mast Logic:" + source.getDisplayName() + " to " + destinationSignalMast.getDisplayName());
            }

            for (Block key : autoBlocks.keySet()) {
                log.debug("{} auto block add list {}", destinationSignalMast.getDisplayName(), key.getDisplayName());
                key.removePropertyChangeListener(propertyBlockListener);
                key.addPropertyChangeListener(propertyBlockListener);
            }

            for (NamedBeanSetting nbh : userSetBlocks) {
                Block key = (Block) nbh.getBean();
                key.removePropertyChangeListener(propertyBlockListener);
                key.addPropertyChangeListener(propertyBlockListener);
            }
            listenForSectionHolders();
            destMastInit = true;

            // Use the same checks as when one of these beans changes.
            runCheck(false);
        }

        void useLayoutEditor(boolean boo) throws JmriException {
            log.debug("{} called useLayoutEditor({}), is {}",
                destinationSignalMast.getDisplayName(), boo, useLayoutEditor);
            if (useLayoutEditor == boo) {
                return;
            }
            useLayoutEditor = boo;
            if ((boo) && (InstanceManager.getDefault(LayoutBlockManager.class).routingStablised())) {
                // JmriException considered normal if there is no valid path using the layout editor.
                setupLayoutEditorDetails();
            } else {
                destinationBlock = null;
                // the facing block belongs to the source mast, so keep it while
                // another destination still uses the Layout Editor
                if (destList.values().stream().noneMatch(DestinationMast::useLayoutEditor)) {
                    facingBlock = null;
                }
                protectingBlock = null;
                setAutoBlocks(null);
                setAutoTurnouts(null);
            }
        }

        void useLayoutEditorDetails(boolean turnouts, boolean blocks) throws JmriException {
            log.debug("{} use layout editor details called {}",
                destinationSignalMast.getDisplayName(), useLayoutEditor);
            useLayoutEditorTurnouts = turnouts;
            useLayoutEditorBlocks = blocks;
            if ((useLayoutEditor) && (InstanceManager.getDefault(LayoutBlockManager.class).routingStablised())) {
                // JmriException considered normal if there is no valid path using the Layout Editor.
                setupLayoutEditorDetails();
            }
        }

        void setupLayoutEditorDetails() throws JmriException {
            log.debug("setupLayoutEditorDetails: useLayoutEditor={} disposed={}", useLayoutEditor, disposed);
            if ((!useLayoutEditor) || (disposed)) {
                return;
            }
            LayoutBlockManager lbm = InstanceManager.getDefault(LayoutBlockManager.class);
            if ( destinationBlock != null) {
                log.debug("{} Set use layout editor", destinationSignalMast.getDisplayName());
            }
            Set<LayoutEditor> layout = InstanceManager.getDefault(EditorManager.class).getAll(LayoutEditor.class);
            List<LayoutBlock> protectingBlocks = new ArrayList<>();
            // We don't care which Layout Editor panel the signal mast is on, just so long as
            // the routing is done via layout blocks.
            remoteProtectingBlock = null;
            for (LayoutEditor panel : layout) {
                log.debug("{} Layout name {}", destinationSignalMast.getDisplayName(), panel.getLayoutName());
                if (facingBlock == null) {
                    facingBlock = lbm.getFacingBlockByNamedBean(getSourceMast(), panel);
                }
                if (protectingBlock == null && protectingBlocks.isEmpty()) {
                    //This is wrong
                    protectingBlocks = lbm.getProtectingBlocksByNamedBean(getSourceMast(), panel);
                }
                if (destinationBlock == null) {
                    destinationBlock = lbm.getFacingBlockByNamedBean(destinationSignalMast, panel);
                }
                if (remoteProtectingBlock == null) {
                    remoteProtectingBlock = lbm.getProtectedBlockByNamedBean(destinationSignalMast, panel);
                }
            }
            // At this point, if we are not using the Layout Editor turnout or block
            // details then there is no point in trying to gather them.
            if ((!useLayoutEditorTurnouts) && (!useLayoutEditorBlocks)) {
                return;
            }
            if (facingBlock == null) {
                log.error("No facing block found for source mast {}", getSourceMast().getDisplayName());
                throw new JmriException("No facing block found for source mast " + getSourceMast().getDisplayName());
            }
            if (destinationBlock == null) {
                log.error("No facing block found for destination mast {}", destinationSignalMast.getDisplayName());
                throw new JmriException("No facing block found for destination mast " + destinationSignalMast.getDisplayName());
            }
            List<LayoutBlock> lblks = new ArrayList<>();
            if (protectingBlock == null) {
                log.debug("protecting block is null");
                String pBlkNames = "";
                StringBuffer lBlksNamesBuf = new StringBuffer();
                for (LayoutBlock pBlk : protectingBlocks) {
                    log.debug("checking layoutBlock {}", pBlk.getDisplayName());
                    pBlkNames = pBlkNames + pBlk.getDisplayName() + " (" + lbm.getLayoutBlockConnectivityTools().checkValidDest(facingBlock, pBlk, destinationBlock, remoteProtectingBlock, LayoutBlockConnectivityTools.Routing.MASTTOMAST) + "), ";
                    if (lbm.getLayoutBlockConnectivityTools().checkValidDest(facingBlock, pBlk, destinationBlock, remoteProtectingBlock, LayoutBlockConnectivityTools.Routing.MASTTOMAST)) {
                        try {
                            lblks = lbm.getLayoutBlockConnectivityTools().getLayoutBlocks(facingBlock, destinationBlock, pBlk, true, LayoutBlockConnectivityTools.Routing.MASTTOMAST);
                            protectingBlock = pBlk;
                            log.debug("building path names...");
                            for (LayoutBlock lBlk : lblks) {
                                lBlksNamesBuf.append(" ");
                                lBlksNamesBuf.append(lBlk.getDisplayName());
                            }
                            break;
                        } catch (JmriException ee) {
                            log.debug("path not found this time");
                        }
                    }
                }
                String lBlksNames = new String(lBlksNamesBuf);

                if (protectingBlock == null) {
                    throw new JmriException("Path not valid, protecting block is null. Protecting block: " + pBlkNames
                        + " not connected to " + facingBlock.getDisplayName() + ". Layout block names: " + lBlksNames);
                }
            }
            if (!lbm.getLayoutBlockConnectivityTools().checkValidDest(facingBlock,protectingBlock,
                destinationBlock, remoteProtectingBlock, LayoutBlockConnectivityTools.Routing.MASTTOMAST)) {
                throw new JmriException("Path not valid, destination check failed.");
            }
            if (log.isDebugEnabled()) {
                log.debug("{} face {}", destinationSignalMast.getDisplayName(), facingBlock);
                log.debug("{} prot {}", destinationSignalMast.getDisplayName(), protectingBlock);
                log.debug("{} dest {}", destinationSignalMast.getDisplayName(), destinationBlock);
            }

            if (destinationBlock != null && protectingBlock != null && facingBlock != null) {
                setAutoMasts(null, true);
                if (log.isDebugEnabled()) {
                    log.debug("{} face {}", destinationSignalMast.getDisplayName(), facingBlock.getDisplayName());
                    log.debug("{} prot {}", destinationSignalMast.getDisplayName(), protectingBlock.getDisplayName());
                    log.debug("{} dest {}", destinationSignalMast.getDisplayName(), destinationBlock.getDisplayName());
                }

                try {
                    lblks = lbm.getLayoutBlockConnectivityTools().getLayoutBlocks(
                        facingBlock, destinationBlock, protectingBlock,
                            true, LayoutBlockConnectivityTools.Routing.MASTTOMAST);
                } catch (JmriException ee) {
                    log.error("No blocks found by the layout editor for pair {}-{}",
                        source.getDisplayName(), destinationSignalMast.getDisplayName());
                }
                LinkedHashMap<Block, Integer> block = setupLayoutEditorTurnoutDetails(lblks);

                for (int i = 0; i < blockInXings.size(); i++) {
                    blockInXings.get(i).removeSignalMastLogic(source);
                }
                blockInXings = new ArrayList<>(0);
                xingAutoBlocks = new ArrayList<>(0);
                for (LayoutEditor lay : layout) {
                    for (LevelXing levelXing : lay.getLevelXings()) {
                        //Looking for a crossing that both layout blocks defined and they are individual.
                        if ((levelXing.getLayoutBlockAC() != null)
                                && (levelXing.getLayoutBlockBD() != null)
                                && (levelXing.getLayoutBlockAC() != levelXing.getLayoutBlockBD())) {
                            if (lblks.contains(levelXing.getLayoutBlockAC()) &&
                                    levelXing.getLayoutBlockAC() != facingBlock) {  // Don't include the facing xing blocks
                                block.put(levelXing.getLayoutBlockBD().getBlock(), Block.UNOCCUPIED);
                                xingAutoBlocks.add(levelXing.getLayoutBlockBD().getBlock());
                                blockInXings.add(levelXing);
                            } else if (lblks.contains(levelXing.getLayoutBlockBD()) &&
                                    levelXing.getLayoutBlockBD() != facingBlock) {  // Don't include the facing xing blocks
                                block.put(levelXing.getLayoutBlockAC().getBlock(), Block.UNOCCUPIED);
                                xingAutoBlocks.add(levelXing.getLayoutBlockAC().getBlock());
                                blockInXings.add(levelXing);
                            }
                        }
                    }
                }
                if (useLayoutEditorBlocks) {
                    setAutoBlocks(block);
                } else {
                    setAutoBlocks(null);
                }
                if (!useLayoutEditorTurnouts) {
                    setAutoTurnouts(null);
                }

                setupAutoSignalMast(null, false);
            }
            initialise();
        }

        /**
         * From a list of Layout Blocks, search for included Turnouts and their
         * Set To state.
         *
         * @param lblks List of Layout Blocks
         * @return a list of block - turnout state pairs
         */
        LinkedHashMap<Block, Integer> setupLayoutEditorTurnoutDetails(List<LayoutBlock> lblks) {
            ConnectivityUtil connection;
            List<LayoutTrackExpectedState<LayoutTurnout>> turnoutList;
            Hashtable<Turnout, Integer> turnoutSettings = new Hashtable<>();
            LinkedHashMap<Block, Integer> block = new LinkedHashMap<>();
            for (int i = 0; i < lblks.size(); i++) {
                log.debug("layoutblock {}",lblks.get(i).getDisplayName());
                block.put(lblks.get(i).getBlock(), Block.UNOCCUPIED);
                if ((i > 0)) {
                    int nxtBlk = i + 1;
                    int preBlk = i - 1;
                    if (i == lblks.size() - 1) {
                        nxtBlk = i;
                    }
                    //We use the best connectivity for the current block.
                    connection = new ConnectivityUtil(lblks.get(i).getMaxConnectedPanel());
                    if (i == lblks.size() - 1 && remoteProtectingBlock != null) {
                        turnoutList = connection.getTurnoutList(lblks.get(i)
                            .getBlock(), lblks.get(preBlk).getBlock(), remoteProtectingBlock.getBlock());
                    }else{
                        turnoutList = connection.getTurnoutList(lblks.get(i)
                            .getBlock(), lblks.get(preBlk).getBlock(), lblks.get(nxtBlk).getBlock());
                    }
                    for (int x = 0; x < turnoutList.size(); x++) {
                        LayoutTurnout lt = turnoutList.get(x).getObject();
                        if (lt instanceof LayoutSlip) {
                            LayoutSlip ls = (LayoutSlip) lt;
                            int slipState = turnoutList.get(x).getExpectedState();
                            int taState = ls.getTurnoutState(slipState);
                            Turnout tTemp = ls.getTurnout();
                            if (tTemp == null ) {
                                log.error("Unexpected null Turnout in {}, skipped", ls);
                                continue; // skip this one in loop, what else can you do?
                            }
                            turnoutSettings.put(ls.getTurnout(), taState);
                            int tbState = ls.getTurnoutBState(slipState);
                            turnoutSettings.put(ls.getTurnoutB(), tbState);
                        } else if ( lt != null ) {
                            String t = lt.getTurnoutName();
                            // temporary = why is this looking up the Turnout instead of using getTurnout()?
                            Turnout turnout = InstanceManager.turnoutManagerInstance().getTurnout(t);
                            if (log.isDebugEnabled()) {
                                if (    (lt.getTurnoutType() == LayoutTurnout.TurnoutType.RH_TURNOUT ||
                                         lt.getTurnoutType() == LayoutTurnout.TurnoutType.LH_TURNOUT ||
                                         lt.getTurnoutType() == LayoutTurnout.TurnoutType.WYE_TURNOUT)
                                        && (!lt.getBlockName().isEmpty())) {
                                    log.debug("turnout in list is straight left/right wye");
                                    log.debug("turnout block Name {}", lt.getBlockName());
                                    log.debug("current {} - pre {}", lblks.get(i).getBlock().getDisplayName(), lblks.get(preBlk).getBlock().getDisplayName());
                                    log.debug("A {}", lt.getConnectA());
                                    log.debug("B {}", lt.getConnectB());
                                    log.debug("C {}", lt.getConnectC());
                                    log.debug("D {}", lt.getConnectD());
                                }
                            }
                            if (turnout != null ) {
                                turnoutSettings.put(turnout, turnoutList.get(x).getExpectedState());
                            }
                            Turnout tempT;
                            if ((tempT = lt.getSecondTurnout()) != null) {
                                turnoutSettings.put(tempT, turnoutList.get(x).getExpectedState());
                            }
                            /* TODO: We could do with a more intelligent way to deal with double crossovers, other than
                                just looking at the state of the other conflicting blocks, such as looking at Signalmasts
                                that protect the other blocks and the settings of any other turnouts along the way.
                             */
                            if (lt.getTurnoutType() == LayoutTurnout.TurnoutType.DOUBLE_XOVER) {
                                LayoutBlock tempLB;
                                if (turnoutList.get(x).getExpectedState() == Turnout.THROWN) {
                                    if (lt.getLayoutBlock() == lblks.get(i) || lt.getLayoutBlockC() == lblks.get(i)) {
                                        // A or C, add B and D to remove list unless A=B or C=D
                                        if ((tempLB = lt.getLayoutBlockB()) != null) {
                                            if (!tempLB.equals(lt.getLayoutBlock())) {
                                                dblCrossoverAutoBlocks.add(tempLB.getBlock());
                                            }
                                            block.put(tempLB.getBlock(), Block.UNOCCUPIED);
                                        }
                                        if ((tempLB = lt.getLayoutBlockD()) != null) {
                                            if (!tempLB.equals(lt.getLayoutBlockC())) {
                                                dblCrossoverAutoBlocks.add(tempLB.getBlock());
                                            }
                                            block.put(tempLB.getBlock(), Block.UNOCCUPIED);
                                        }
                                    } else if (lt.getLayoutBlockB() == lblks.get(i) || lt.getLayoutBlockD() == lblks.get(i)) {
                                        // B or D, add A and C to remove list unless A=B or C=D
                                        if ((tempLB = lt.getLayoutBlock()) != null) {
                                            if (!tempLB.equals(lt.getLayoutBlockB())) {
                                                dblCrossoverAutoBlocks.add(tempLB.getBlock());
                                            }
                                            block.put(tempLB.getBlock(), Block.UNOCCUPIED);
                                        }
                                        if ((tempLB = lt.getLayoutBlockC()) != null) {
                                            if (!tempLB.equals(lt.getLayoutBlockD())) {
                                                dblCrossoverAutoBlocks.add(tempLB.getBlock());
                                            }
                                            block.put(tempLB.getBlock(), Block.UNOCCUPIED);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            // ----- Begin Turntable Alignment Check -----
            // For paths onto a turntable, we must add a condition for the turntable's alignment. The
            // turnout that controls the turntable position is associated with the specific ray track.
            // Each ray track can have a control turnout assigned. Setting this turnout to a specific
            // state (usually THROWN) is the command to align the turntable to that ray.
            // The following logic adds a CONDITION to the Signal Mast Logic, requiring that the
            // correct ray's turnout is in its required state before the signal will clear.
            // This does NOT command the turnout to move; it only checks its state for the interlocking.
            Set<LayoutEditor> layout = InstanceManager.getDefault(EditorManager.class).getAll(LayoutEditor.class);
            for (LayoutEditor lay : layout) {
                for (LayoutTurntable turntable : lay.getLayoutTurntables()) {
                    // Check for a path from an Approach Mast to the Buffer Mast (Path 3).
                    // The destination block is the turntable block, and the destination mast is the buffer mast.
                    if (turntable.getLayoutBlock() == destinationBlock && turntable.getBufferMast() == destinationSignalMast) {
                        // The source mast's facing block is the ray block for this path.
                        for (LayoutTurntable.RayTrack ray : turntable.getRayTrackList()) {
                            if (ray.getConnect() != null && ray.getConnect().getLayoutBlock() == DefaultSignalMastLogic.this.facingBlock) {
                                // This is the correct ray. Get its control turnout and required state.
                                Turnout rayTurnout = ray.getTurnout();
                                int requiredState = ray.getTurnoutState();
                                if (rayTurnout != null) {
                                    turnoutSettings.put(rayTurnout, requiredState);
                                }
                                break; // Found the ray, no need to check others.
                            }
                        }
                    }
                    // Check for a path from the Exit Mast to a remote mast (Path 1).
                    // The source mast is the turntable's exit mast.
                    if (turntable.getExitSignalMast() == getSourceMast()) {
                        // The protecting block is the ray block for this path.
                        for (LayoutTurntable.RayTrack ray : turntable.getRayTrackList()) {
                            if (ray.getConnect() != null && ray.getConnect().getLayoutBlock() == protectingBlock) {
                                // This is the correct ray. Get its control turnout and required state.
                                Turnout rayTurnout = ray.getTurnout();
                                int requiredState = ray.getTurnoutState();
                                if (rayTurnout != null) {
                                    turnoutSettings.put(rayTurnout, requiredState);
                                }
                                break; // Found the ray, no need to check others.
                            }
                        }
                    }
                }
            }
            // ----- End Turntable Alignment Check -----
            // ----- Begin Traverser Alignment Check -----
            for (LayoutEditor lay : layout) {
                for (LayoutTraverser traverser : lay.getLayoutTraversers()) {
                    // Check for a path from an Approach Mast to the Buffer Mast (Path 3).
                    // The destination block is the traverser block, and the destination mast is the buffer mast.
                    if (traverser.getLayoutBlock() == destinationBlock && traverser.getBufferMast() == destinationSignalMast) {
                        // The source mast's facing block is the slot block for this path.
                        for (LayoutTraverser.SlotTrack slot : traverser.getSlotList()) {
                            if (slot.getConnect() != null && slot.getConnect().getLayoutBlock() == DefaultSignalMastLogic.this.facingBlock) {
                                // This is the correct slot. Get its control turnout and required state.
                                Turnout slotTurnout = slot.getTurnout();
                                int requiredState = slot.getTurnoutState();
                                if (slotTurnout != null) {
                                    turnoutSettings.put(slotTurnout, requiredState);
                                }
                                break; // Found the slot, no need to check others.
                            }
                        }
                    }
                    // Check for a path from the Exit Mast to a remote mast (Path 1).
                    // The source mast is the traverser's exit mast.
                    if (traverser.getExitSignalMast() == getSourceMast()) {
                        // The protecting block is the slot block for this path.
                        for (LayoutTraverser.SlotTrack slot : traverser.getSlotList()) {
                            if (slot.getConnect() != null && slot.getConnect().getLayoutBlock() == protectingBlock) {
                                // This is the correct slot. Get its control turnout and required state.
                                Turnout slotTurnout = slot.getTurnout();
                                int requiredState = slot.getTurnoutState();
                                if (slotTurnout != null) {
                                    turnoutSettings.put(slotTurnout, requiredState);
                                }
                                break; // Found the slot, no need to check others.
                            }
                        }
                    }
                }
            }
            // ----- End Traverser Alignment Check -----
            if (useLayoutEditorTurnouts) {
                setAutoTurnouts(turnoutSettings);
            }
            return block;
        }

        /**
         * Generate auto signalmast for a given SML. Looks through all the other
         * logics to see if there are any blocks that are in common and thus
         * will add the other signal mast protecting that block.
         *
         * @param sml       The Signal Mast Logic for which to set up
         *                  autoSignalMasts
         * @param overwrite When true, replace an existing autoMasts list in the
         *                  SML
         */
        void setupAutoSignalMast(SignalMastLogic sml, boolean overwrite) {
            if (!allowAutoSignalMastGeneration) {
                return;
            }
            List<SignalMastLogic> smlList = InstanceManager.getDefault(SignalMastLogicManager.class)
                .getLogicsByDestination(destinationSignalMast);
            List<Block> allBlock = new ArrayList<>();

            userSetBlocks.forEach(nbh -> allBlock.add((Block) nbh.getBean()));

            Set<Block> blockKeys = autoBlocks.keySet();
            blockKeys.stream().filter(key -> (!allBlock.contains(key))).forEachOrdered(key ->
                allBlock.add(key));
            Hashtable<SignalMast, String> masts;
            if (sml != null) {
                masts = autoMasts;
                if (sml.areBlocksIncluded(allBlock)) {
                    SignalMast mast = sml.getSourceMast();
                    String danger = mast.getAppearanceMap().getSpecificAppearance(SignalAppearanceMap.DANGER);
                    masts.put(mast, danger);
                } else {
                    //No change so will leave.
                    return;
                }
            } else {
                masts = new Hashtable<>();
                for (int i = 0; i < smlList.size(); i++) {
                    if (smlList.get(i).areBlocksIncluded(allBlock)) {
                        SignalMast mast = smlList.get(i).getSourceMast();
                        String danger = mast.getAppearanceMap().getSpecificAppearance(SignalAppearanceMap.DANGER);
                        masts.put(mast, danger);
                    }
                }
            }
            setAutoMasts(masts, overwrite);
        }

        /**
         * Add a certain Signal Mast to the list of AutoSignalMasts for this
         * SML.
         *
         * @param mast The Signal Mast to be added
         */
        void addAutoSignalMast(SignalMast mast) {
            log.debug("{} add mast to auto list {}", destinationSignalMast.getDisplayName(), mast);
            String danger = mast.getAppearanceMap().getSpecificAppearance(SignalAppearanceMap.DANGER);
            if (danger == null) {
                log.error("Can not add SignalMast {} to logic for {} to {} "
                    + "as it does not have a Danger appearance configured",
                        mast.getDisplayName(), source.getDisplayName(), destinationSignalMast.getDisplayName());
                return;
            }
            this.autoMasts.put(mast, danger);
            if (destMastInit) {
                mast.addPropertyChangeListener(propertySignalMastListener);
            }
            firePropertyChange(PROPERTY_AUTO_MASTS, null, this.destinationSignalMast);
        }

        /**
         * Remove a certain Signal Mast from the list of AutoSignalMasts for
         * this SML.
         *
         * @param mast The Signal Mast to be removed
         */
        void removeAutoSignalMast(SignalMast mast) {
            this.autoMasts.remove(mast);
            if (destMastInit) {
                mast.removePropertyChangeListener(propertySignalMastListener);
            }
            firePropertyChange(PROPERTY_AUTO_MASTS, this.destinationSignalMast, null);
        }

        boolean useLayoutEditor() {
            return useLayoutEditor;
        }

        boolean useLayoutEditorBlocks() {
            return useLayoutEditorBlocks;
        }

        boolean useLayoutEditorTurnouts() {
            return useLayoutEditorTurnouts;
        }

        boolean allowAutoSignalMastGeneration = false;

        boolean allowAutoSignalMastGen() {
            return allowAutoSignalMastGeneration;
        }

        void allowAutoSignalMastGen(boolean gen) {
            if (allowAutoSignalMastGeneration == gen) {
                return;
            }
            allowAutoSignalMastGeneration = gen;
        }

        /**
         * Remove references from this Destination Mast and clear lists, so that
         * it can eventually be garbage-collected.
         * <p>
         * Note: This does not stop any delayed operations that might be queued.
         */
        void dispose() {
            disposed = true;
            stopListeningForSectionHolders();
            clearTurnoutLock();
            destinationSignalMast.removePropertyChangeListener(propertyDestinationMastListener);
            setBlocks(null);
            setAutoBlocks(null);
            setTurnouts(null);
            setAutoTurnouts(null);
            setSensors(null);
            setMasts(null);
            setAutoMasts(null, true);
        }

        void lockTurnouts() {
            // We do not allow the turnouts to be locked if we are disposing the logic,
            // if the logic is not active, or if we do not allow the turnouts to be locked.
            if ((disposed) || (!lockTurnouts) || (!active)) {
                return;
            }

            userSetTurnouts.stream().map(nbh -> (Turnout) nbh.getBean()).forEachOrdered(key -> {
                key.setLocked(Turnout.CABLOCKOUT + Turnout.PUSHBUTTONLOCKOUT, true);
            });
            Enumeration<Turnout> keys = autoTurnouts.keys();
            while (keys.hasMoreElements()) {
                Turnout key = keys.nextElement();
                key.setLocked(Turnout.CABLOCKOUT + Turnout.PUSHBUTTONLOCKOUT, true);
            }
        }

        void clearTurnoutLock() {
            // We do not allow the turnout lock to be cleared if we are not active,
            // and the lock flag has not been set.
            if ((!lockTurnouts) && (!active)) {
                return;
            }

            Enumeration<Turnout> keys = autoTurnouts.keys();
            while (keys.hasMoreElements()) {
                Turnout key = keys.nextElement();
                key.setLocked(Turnout.CABLOCKOUT + Turnout.PUSHBUTTONLOCKOUT, false);
            }

            userSetTurnouts.stream().map(nbh -> (Turnout) nbh.getBean()).forEachOrdered(key ->
                key.setLocked(Turnout.CABLOCKOUT + Turnout.PUSHBUTTONLOCKOUT, false));
        }

        protected void calculateSpeed() {
            log.debug("{} calculate the speed setting for this logic ie what the signalmast will display", destinationSignalMast.getDisplayName());
            minimumBlockSpeed = 0.0f;
            Enumeration<Turnout> keys = autoTurnouts.keys();
            while (keys.hasMoreElements()) {
                Turnout key = keys.nextElement();
                log.debug("{} turnout {}", destinationSignalMast.getDisplayName(), key.getDisplayName());
                if (!isTurnoutIncluded(key)) {
                    if (autoTurnouts.get(key) == Turnout.CLOSED) {
                        if (((key.getStraightLimit() < minimumBlockSpeed) || (minimumBlockSpeed == 0)) && (key.getStraightLimit() != -1)) {
                            minimumBlockSpeed = key.getStraightLimit();
                            log.debug("{} turnout {} set speed to {}", destinationSignalMast.getDisplayName(), key.getDisplayName(), minimumBlockSpeed);
                        }
                    } else {
                        if (((key.getDivergingLimit() < minimumBlockSpeed) || (minimumBlockSpeed == 0)) && (key.getDivergingLimit() != -1)) {
                            minimumBlockSpeed = key.getDivergingLimit();
                            log.debug("{} turnout {} set speed to {}", destinationSignalMast.getDisplayName(), key.getDisplayName(), minimumBlockSpeed);
                        }
                    }
                }
            }

            userSetTurnouts.forEach(nbh -> {
                Turnout key = (Turnout) nbh.getBean();
                if (nbh.getSetting() == Turnout.CLOSED) {
                    if (((key.getStraightLimit() < minimumBlockSpeed) || (minimumBlockSpeed == 0)) && (key.getStraightLimit() != -1)) {
                        minimumBlockSpeed = key.getStraightLimit();
                        log.debug("{} turnout {} set speed to {}", destinationSignalMast.getDisplayName(), key.getDisplayName(), minimumBlockSpeed);
                    }
                } else if (nbh.getSetting() == Turnout.THROWN) {
                    if (((key.getDivergingLimit() < minimumBlockSpeed) || (minimumBlockSpeed == 0)) && (key.getDivergingLimit() != -1)) {
                        minimumBlockSpeed = key.getDivergingLimit();
                        log.debug("{} turnout {} set speed to {}", destinationSignalMast.getDisplayName(), key.getDisplayName(), minimumBlockSpeed);
                    }
                }
            });

            Set<Block> autoBlockKeys = autoBlocks.keySet();
            for (Block key : autoBlockKeys) {
                log.debug("{} auto block add list {}", destinationSignalMast.getDisplayName(), key.getDisplayName());
                if (!isBlockIncluded(key)) {
                    if (((key.getSpeedLimit() < minimumBlockSpeed) || (minimumBlockSpeed == 0)) && (key.getSpeedLimit() != -1)) {
                        minimumBlockSpeed = key.getSpeedLimit();
                        log.debug("{} block {} set speed to {}", destinationSignalMast.getDisplayName(), key.getDisplayName(), minimumBlockSpeed);
                    }
                }
            }
            for (NamedBeanSetting nbh : userSetBlocks) {
                Block key = (Block) nbh.getBean();
                if (((key.getSpeedLimit() < minimumBlockSpeed) || (minimumBlockSpeed == 0)) && (key.getSpeedLimit() != -1)) {
                    log.debug("{} block {} set speed to {}", destinationSignalMast.getDisplayName(), key.getDisplayName(), minimumBlockSpeed);
                    minimumBlockSpeed = key.getSpeedLimit();
                }
            }
            /*if(minimumBlockSpeed==-0.1f)
             minimumBlockSpeed==0.0f;*/
        }

        /**
         * Check whether a block on this route is reserved for a train other
         * than the one approaching the source mast.
         * <p>
         * Only blocks marked as allocated (shown in the extra color) are
         * checked. A Section records who holds it, see
         * {@link Section#getAllocatedTo()}; the approaching train is the
         * holder of the block the source mast faces. A marked block whose
         * holder is not the approaching train, or that has no holder, puts the
         * mast to danger. So does a marked block when no train holds the
         * facing block.
         *
         * @param routeBlocks the blocks on this route
         * @param lbm         the layout block manager
         * @return true if the mast must show danger
         */
        private boolean isRouteHeldByAnotherTrain(List<Block> routeBlocks, LayoutBlockManager lbm) {
            List<Block> marked = new ArrayList<>();
            for (Block b : routeBlocks) {
                LayoutBlock lb = lbm.getLayoutBlock(b);
                if (lb != null && lb.getUseExtraColor()) {
                    marked.add(b);
                }
            }
            if (marked.isEmpty()) {
                return false;
            }
            LayoutBlock approach = getApproachBlock(lbm);
            Object approaching = (approach == null) ? null : heldBy(approach.getBlock());
            for (Block b : marked) {
                Object holder = heldBy(b);
                if (holder == null || holder != approaching) {
                    log.debug("{} block {} is held by {}, approaching train is {}",
                            destinationSignalMast.getDisplayName(), b.getDisplayName(), holder, approaching);
                    return true;
                }
            }
            return false;
        }

        /*
         * The block the source mast faces, where a train approaching the mast is.
         * Found from the Layout Editor panels when this logic does not use the
         * Layout Editor, without changing the stored facing block.
         */
        private LayoutBlock getApproachBlock(LayoutBlockManager lbm) {
            if (getFacingBlock() != null) {
                return getFacingBlock();
            }
            for (LayoutEditor editor : InstanceManager.getDefault(EditorManager.class).getAll(LayoutEditor.class)) {
                LayoutBlock lb = lbm.getFacingBlockByNamedBean(getSourceMast(), editor);
                if (lb != null) {
                    return lb;
                }
            }
            return null;
        }

        /*
         * The Sections this logic listens to for a change of holder, and the
         * blocks it cares about: those on the route and the block the source
         * mast faces.
         */
        private final Set<Section> holderSections = new HashSet<>();
        private final Set<Block> holderBlocks = new HashSet<>();

        /*
         * Listen for changes of holder on Sections, so the dispatcher check
         * above is made again when a train is given or releases a Section
         * containing one of the blocks this logic cares about. Every Section
         * is listened to, and the blocks are checked when the holder changes,
         * because a Section's blocks can be set after it is created without
         * any event being sent.
         */
        private void listenForSectionHolders() {
            stopListeningForSectionHolders();
            // Only use a Section manager that already exists: with no Sections
            // defined there is nothing to listen to, and asking for one would
            // create it.
            if (!InstanceManager.containsDefault(SectionManager.class)) {
                return;
            }
            SectionManager sm = InstanceManager.getDefault(SectionManager.class);
            holderBlocks.addAll(autoBlocks.keySet());
            for (NamedBeanSetting nbh : userSetBlocks) {
                holderBlocks.add((Block) nbh.getBean());
            }
            if (holderBlocks.isEmpty()) {
                return;
            }
            if (InstanceManager.containsDefault(LayoutBlockManager.class)) {
                LayoutBlock approach = getApproachBlock(InstanceManager.getDefault(LayoutBlockManager.class));
                if (approach != null && approach.getBlock() != null) {
                    holderBlocks.add(approach.getBlock());
                }
            }
            sm.addPropertyChangeListener(Manager.PROPERTY_BEANS, sectionManagerListener);
            for (Section sec : sm.getNamedBeanSet()) {
                listenTo(sec);
            }
        }

        private void listenTo(Section sec) {
            if (!holderSections.contains(sec)) {
                sec.addPropertyChangeListener(Section.PROPERTY_ALLOCATED_TO, sectionHolderListener);
                holderSections.add(sec);
            }
        }

        private void stopListeningForSectionHolders() {
            for (Section sec : holderSections) {
                sec.removePropertyChangeListener(Section.PROPERTY_ALLOCATED_TO, sectionHolderListener);
            }
            holderSections.clear();
            holderBlocks.clear();
            if (InstanceManager.containsDefault(SectionManager.class)) {
                InstanceManager.getDefault(SectionManager.class)
                        .removePropertyChangeListener(Manager.PROPERTY_BEANS, sectionManagerListener);
            }
        }

        private final PropertyChangeListener sectionHolderListener = e -> {
            Section sec = (Section) e.getSource();
            for (Block b : holderBlocks) {
                if (sec.containsBlock(b)) {
                    log.debug("{} section {} now held by {}", destinationSignalMast.getDisplayName(),
                            sec.getDisplayName(), e.getNewValue());
                    checkState();
                    return;
                }
            }
        };

        /*
         * A Section added is listened to; one removed is dropped. An event
         * without a Section (sent after a silenced bulk load) starts again.
         */
        private final PropertyChangeListener sectionManagerListener = e -> {
            if (!destMastInit || disposed) {
                return;
            }
            if (e.getNewValue() instanceof Section) {
                listenTo((Section) e.getNewValue());
            } else if (e.getOldValue() instanceof Section) {
                Section sec = (Section) e.getOldValue();
                if (holderSections.remove(sec)) {
                    sec.removePropertyChangeListener(Section.PROPERTY_ALLOCATED_TO, sectionHolderListener);
                }
            } else {
                listenForSectionHolders();
            }
        };

        /*
         * The holder of an allocated Section containing the block, or null.
         */
        private Object heldBy(Block b) {
            if (b == null || !InstanceManager.containsDefault(SectionManager.class)) {
                return null;
            }
            for (Section sec : InstanceManager.getDefault(SectionManager.class).getNamedBeanSet()) {
                Object holder = sec.getAllocatedTo();
                if (holder != null && sec.containsBlock(b)) {
                    return holder;
                }
            }
            return null;
        }

        protected PropertyChangeListener propertySensorListener = new PropertyChangeListener() {
            @Override
            public void propertyChange(PropertyChangeEvent e) {
                Sensor sen = (Sensor) e.getSource();
                log.debug("{} to {} destination sensor {} trigger {}",source.getDisplayName(), destinationSignalMast.getDisplayName(), sen.getDisplayName(), e.getPropertyName());
                if ( Sensor.PROPERTY_KNOWN_STATE.equals(e.getPropertyName())) {
                    int now = ((Integer) e.getNewValue());
                    log.debug("current value {} value we want {}", now, getSensorState(sen));
                    if (isSensorIncluded(sen) && getSensorState(sen) != now) {
                        log.debug("Sensor {} caused the signalmast to be set to danger", sen.getDisplayName());
                        //getSourceMast().setAspect(stopAspect);
                        routeNoLongerSet();
                    } else if (getSensorState(sen) == now) {
                        log.debug("{} sensor {} triggers a calculation of change", destinationSignalMast.getDisplayName(), sen.getDisplayName());
                        checkState();
                    }
                }
            }
        };

        protected PropertyChangeListener propertyTurnoutListener = new PropertyChangeListener() {
            @Override
            public void propertyChange(PropertyChangeEvent e) {
                Turnout turn = (Turnout) e.getSource();
                //   log.debug(destination.getDisplayName() + " destination sensor "+ sen.getDisplayName() + "trigger");
                if ( Turnout.PROPERTY_KNOWN_STATE.equals(e.getPropertyName())) {
                    //Need to check this against the manual list vs auto list
                    //The manual list should over-ride the auto list
                    int now = ((Integer) e.getNewValue());
                    if (isTurnoutIncluded(turn)) {
                        if (getTurnoutState(turn) != now) {
                            log.debug("Turnout {} caused the signalmast to be set", turn.getDisplayName());
                            log.debug("From {} to {} Turnout {} caused the signalmast to be set to danger", getSourceMast().getDisplayName(), destinationSignalMast.getDisplayName(), turn.getDisplayName());
                            routeNoLongerSet();
                        } else {
                            log.debug("{} turnout {} triggers a calculation of change", destinationSignalMast.getDisplayName(), turn.getDisplayName());
                            checkState();
                        }
                    } else if (autoTurnouts.containsKey(turn)) {
                        if (getAutoTurnoutState(turn) != now) {
                            log.debug("Turnout {} auto caused the signalmast to be set", turn.getDisplayName());
                            log.debug("From {} to {} Auto Turnout {} auto caused the signalmast to be set to danger", getSourceMast().getDisplayName(), destinationSignalMast.getDisplayName(), turn.getDisplayName());
                            routeNoLongerSet();
                        } else {
                            log.debug("From {} to {} turnout {} triggers a calculation of change", getSourceMast().getDisplayName(), destinationSignalMast.getDisplayName(), turn.getDisplayName());
                            checkState();
                        }
                    }

                } else if ( Turnout.PROPERTY_TURNOUT_STRAIGHT_SPEED.equals(e.getPropertyName())
                        || Turnout.PROPERTY_TURNOUT_DIVERGING_SPEED.equals(e.getPropertyName())) {
                    calculateSpeed();
                }
            }
        };

        /**
         * Check if a block on this route has become occupied while the route
         * needs it to be unoccupied.
         *
         * @param block the block to check
         * @return true if the block is occupied, not in permissive working,
         *         and this logic needs it to be unoccupied
         */
        boolean isOccupiedAgainstRoute(Block block) {
            if (block.getState() != Block.OCCUPIED || block.getPermissiveWorking()) {
                return false;
            }
            int required;
            if (isBlockIncluded(block)) {
                required = getBlockState(block);
            } else if (autoBlocks.containsKey(block)) {
                required = getAutoBlockState(block);
            } else {
                return false;
            }
            return required != Block.OCCUPIED && required != 0x03;
        }

        protected PropertyChangeListener propertyBlockListener = new PropertyChangeListener() {
            @Override
            public void propertyChange(PropertyChangeEvent e) {
                Block block = (Block) e.getSource();
                log.debug("{} destination block {} trigger {} {}", destinationSignalMast.getDisplayName(), block.getDisplayName(), e.getPropertyName(), e.getNewValue());
                if ( Block.PROPERTY_STATE.equals(e.getPropertyName()) && isOccupiedAgainstRoute(block)) {
                    // Going to danger is not delayed, only a change towards clear is.
                    log.debug("Block {} occupied, caused the signalmast to be set to danger", block.getDisplayName());
                    routeNoLongerSet();
                } else if ( Block.PROPERTY_STATE.equals(e.getPropertyName()) || Block.PROPERTY_ALLOCATED.equals(e.getPropertyName())) {
                    // TODO: what is this?
                    log.debug("Included in user entered block {}", Boolean.toString(isBlockIncluded(block)));
                    log.debug("Included in AutoGenerated Block {}", Boolean.toString(autoBlocks.containsKey(block)));
                    if (isBlockIncluded(block)) {
                        log.debug("{} in manual block", destinationSignalMast.getDisplayName());
                        log.debug("  state: {}  {}", getBlockState(block), block.getState());
                        checkState();
                    } else if (autoBlocks.containsKey(block)) {
                        log.debug("{} in auto block", destinationSignalMast.getDisplayName());
                        log.debug("  states: {}  {}", getAutoBlockState(block), block.getState());
                        checkState();
                    } else {
                        log.debug("{} Not found", destinationSignalMast.getDisplayName());
                    }
                } else if ( e.getPropertyName().equals("BlockSpeedChange")) {
                    calculateSpeed();
                }
            }
        };

        protected PropertyChangeListener propertySignalMastListener = new PropertyChangeListener() {
            @Override
            public void propertyChange(PropertyChangeEvent e) {

                SignalMast mast = (SignalMast) e.getSource();
                log.debug("{} signalmast change {} {}", destinationSignalMast.getDisplayName(), mast.getDisplayName(), e.getPropertyName());
                //   log.debug(destination.getDisplayName() + " destination sensor "+ sen.getDisplayName() + "trigger");
                if ( SignalMast.PROPERTY_ASPECT.equals(e.getPropertyName())) {

                    String now = ((String) e.getNewValue());
                    log.debug("{} match property {}", destinationSignalMast.getDisplayName(), now);
                    if (isSignalMastIncluded(mast)) {
                        if (!now.equals(getSignalMastState(mast))) {
                            log.debug("{} in mast list SignalMast {} caused the signalmast to be set", destinationSignalMast.getDisplayName(), mast.getDisplayName());
                            log.debug("SignalMast {} caused the signalmast to be set", mast.getDisplayName());
                            routeNoLongerSet();
                        } else {
                            log.debug("{} in mast list signalmast change", destinationSignalMast.getDisplayName());
                            checkState();
                        }
                    } else if (autoMasts.containsKey(mast)) {
                        if (!now.equals(getAutoSignalMastState(mast))) {
                            log.debug("SignalMast {} caused the signalmast to be set", mast.getDisplayName());
                            log.debug("{} in auto mast list SignalMast {} caused the signalmast to be set", destinationSignalMast.getDisplayName(), mast.getDisplayName());
                            routeNoLongerSet();
                        } else {
                            log.debug("{} in auto mast list signalmast change", destinationSignalMast.getDisplayName());
                            checkState();
                        }
                    }
                }
            }
        };

        private class NamedBeanSetting {

            NamedBeanHandle<?> namedBean;
            int setting = 0;
            String strSetting = null;

            NamedBeanSetting(NamedBeanHandle<?> namedBean, int setting) {
                this.namedBean = namedBean;
                this.setting = setting;
            }

            NamedBeanSetting(NamedBeanHandle<?> namedBean, String setting) {
                this.namedBean = namedBean;
                strSetting = setting;
            }

            NamedBean getBean() {
                return namedBean.getBean();
            }

            NamedBeanHandle<?> getNamedBean() {
                return namedBean;
            }

            int getSetting() {
                return setting;
            }

            String getStringSetting() {
                return strSetting;
            }

            String getBeanName() {
                return namedBean.getName();
            }
        }
    }

    /**
     * The listener on the destination Signal Mast.
     */
    private PropertyChangeListener propertyDestinationMastListener = new PropertyChangeListener() {
        @Override
        public void propertyChange(PropertyChangeEvent e) {
            SignalMast mast = (SignalMast) e.getSource();
            if (mast == destination) {
                log.debug("destination mast change {}", mast.getDisplayName());
                setSignalAppearance();
            }
        }
    };

    /**
     * The listener on the source Signal Mast.
     */
    private PropertyChangeListener propertySourceMastListener = new PropertyChangeListener() {
        @Override
        public void propertyChange(PropertyChangeEvent e) {
            SignalMast mast = (SignalMast) e.getSource();
            if ((mast == source) && ( SignalMast.PROPERTY_HELD.equals(e.getPropertyName()))) {
                log.debug("source mast change {} {}", mast.getDisplayName(), e.getPropertyName());
                setSignalAppearance();
            }
        }
    };

    //@todo need to think how we deal with auto generated lists based upon the layout editor.
    @Override
    public void vetoableChange(PropertyChangeEvent evt) throws PropertyVetoException {
        NamedBean nb = (NamedBean) evt.getOldValue();
        if (Manager.PROPERTY_CAN_DELETE.equals(evt.getPropertyName())) {
            boolean found = false;
            StringBuilder message = new StringBuilder();
            if (nb instanceof SignalMast) {
                if (nb.equals(source)) {
                    message.append("Has SignalMast Logic attached which will be <b>Deleted</b> to <ul>");
                    for (SignalMast sm : getDestinationList()) {
                        message.append("<li>");
                        message.append(sm.getDisplayName());
                        message.append("</li>");
                    }
                    message.append("</ul>");
                    throw new PropertyVetoException(message.toString(), evt);

                } else if (isDestinationValid((SignalMast) nb)) {
                    throw new PropertyVetoException("Is the end point mast for logic attached to signal mast " + source.getDisplayName() + " which will be <b>Deleted</b> ", evt);
                }
                for (SignalMast sm : getDestinationList()) {
                    if (isSignalMastIncluded((SignalMast) nb, sm)) {
                        message.append("<li>");
                        message.append("Used in conflicting logic of ").append(source.getDisplayName())
                            .append(" & ").append(sm.getDisplayName()).append("</li>");
                    }
                }
            }
            if (nb instanceof Turnout) {
                for (SignalMast sm : getDestinationList()) {
                    if (isTurnoutIncluded((Turnout) nb, sm)) {
                        message.append("<li>Is in logic between Signal Masts ").append(source.getDisplayName())
                            .append(" ").append(sm.getDisplayName()).append("</li>");
                        found = true;
                    }
                }
            }
            if (nb instanceof Sensor) {
                for (SignalMast sm : getDestinationList()) {
                    if (isSensorIncluded((Sensor) nb, sm)) {
                        message.append("<li>");
                        message.append("Is in logic between Signal Masts ").append(source.getDisplayName())
                            .append(" ").append(sm.getDisplayName()).append("</li>");
                        found = true;
                    }
                }
            }
            if (found) {
                throw new PropertyVetoException(message.toString(), evt);
            }
        } else if (Manager.PROPERTY_DO_DELETE.equals(evt.getPropertyName())) {
            if (nb instanceof SignalMast) {
                if (nb.equals(source)) {
                    dispose();
                }
                if (isDestinationValid((SignalMast) nb)) {
                    removeDestination((SignalMast) nb);
                }
                for (SignalMast sm : getDestinationList()) {
                    if (isSignalMastIncluded((SignalMast) nb, sm)) {
                        log.warn("Unhandled condition: signal mast included during DoDelete");
                        // @todo need to deal with this situation
                    }
                }
            }
            if (nb instanceof Turnout) {
                Turnout t = (Turnout) nb;
                getDestinationList().stream().filter(sm -> (isTurnoutIncluded(t, sm))).forEachOrdered(sm -> {
                    removeTurnout(t, sm);
                });
            }
            if (nb instanceof Sensor) {
                Sensor s = (Sensor) nb;
                getDestinationList().stream().filter(sm -> (isSensorIncluded(s, sm))).forEachOrdered(sm -> {
                    removeSensor(s, sm);
                });
            }
        }
    }

    /**
     * Note: This does not stop any delayed operations that might be queued.
     */
    @Override
    public void dispose() {
        disposing = true;
        getSourceMast().removePropertyChangeListener(propertySourceMastListener);
        Enumeration<SignalMast> en = destList.keys();
        while (en.hasMoreElements()) {
            SignalMast dm = en.nextElement();
            destList.get(dm).dispose();
        }
        super.dispose(); // release any prop change listeners
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public String getBeanType() {
        return Bundle.getMessage("BeanNameSignalMastLogic");
    }

    /**
     * No valid integer state, always return a constant.
     *
     * @return Always zero
     */
    @Override
    public int getState() {
        return 0;
    }

    @Override
    public void setState(int i) {
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public List<NamedBeanUsageReport> getUsageReport(NamedBean bean) {
        List<NamedBeanUsageReport> report = new ArrayList<>();
        if (bean != null) {
            if (bean.equals(getSourceMast())) {
                report.add(new NamedBeanUsageReport("SMLSourceMast"));  // NOI18N
            }
            getDestinationList().forEach((dest) -> {
                if (bean.equals(dest)) {
                    report.add(new NamedBeanUsageReport("SMLDestinationMast"));  // NOI18N
                }
                getAutoBlocks(dest).forEach((block) -> {
                    if (bean.equals(block)) {
                        report.add(new NamedBeanUsageReport("SMLBlockAuto", dest));  // NOI18N
                    }
                });
                getBlocks(dest).forEach((block) -> {
                    if (bean.equals(block)) {
                        report.add(new NamedBeanUsageReport("SMLBlockUser", dest));  // NOI18N
                    }
                });
                getAutoTurnouts(dest).forEach((turnout) -> {
                    if (bean.equals(turnout)) {
                        report.add(new NamedBeanUsageReport("SMLTurnoutAuto", dest));  // NOI18N
                    }
                });
                getTurnouts(dest).forEach((turnout) -> {
                    if (bean.equals(turnout)) {
                        report.add(new NamedBeanUsageReport("SMLTurnoutUser", dest));  // NOI18N
                    }
                });
                getSensors(dest).forEach((sensor) -> {
                    if (bean.equals(sensor)) {
                        report.add(new NamedBeanUsageReport("SMLSensor", dest));  // NOI18N
                    }
                });
                getAutoMasts(dest).forEach((mast) -> {
                    if (bean.equals(mast)) {
                        report.add(new NamedBeanUsageReport("SMLMastAuto", dest));  // NOI18N
                    }
                });
                getSignalMasts(dest).forEach((mast) -> {
                    if (bean.equals(mast)) {
                        report.add(new NamedBeanUsageReport("SMLMastUser", dest));  // NOI18N
                    }
                });
            });
        }
        return report;
    }

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

}