package jmri.managers;

import java.beans.*;
import java.text.DecimalFormat;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;

import javax.annotation.CheckReturnValue;
import javax.annotation.CheckForNull;
import javax.annotation.Nonnull;
import javax.annotation.OverridingMethodsMustInvokeSuper;

import jmri.*;
import jmri.beans.VetoableChangeSupport;
import jmri.NamedBean.DuplicateSystemNameException;

/**
 * Abstract partial implementation for all Manager-type classes.
 * <p>
 * Note that this does not enforce any particular system naming convention at
 * the present time. They're just names...
 * <p>
 * It does include, with AbstractNamedBean, the implementation of the normalized
 * user name.
 * <p>
 * See source file for extensive implementation notes.
 *
 * @param <E> the class this manager supports
 * @see jmri.NamedBean#normalizeUserName
 *
 * @author Bob Jacobsen Copyright (C) 2003
 */
public abstract class AbstractManager<E extends NamedBean> extends VetoableChangeSupport implements Manager<E>, PropertyChangeListener, VetoableChangeListener {

    // The data model consists of several components:
    // * The primary reference is _beans, a SortedSet of NamedBeans, sorted automatically on system name.
    //      Currently that's implemented as a TreeSet; further performance work might change that
    //      Live access is available as an unmodifiableSortedSet via getNamedBeanSet()
    // * The manager also maintains synchronized maps from SystemName -> NamedBean (_tsys) and UserName -> NamedBean (_tuser)
    //      These are not made available: get access through the manager calls
    //      These use regular HashMaps instead of some sorted form for efficiency
    // * Caches for the List<String> getSystemNameList() and List<E> getNamedBeanList() calls

    protected final SystemConnectionMemo memo;
    protected final TreeSet<E> _beans;
    protected final Hashtable<String, E> _tsys = new Hashtable<>();   // stores known E (NamedBean, i.e. Turnout) instances by system name
    protected final Hashtable<String, E> _tuser = new Hashtable<>();  // stores known E (NamedBean, i.e. Turnout) instances by user name
    protected final Map<String, Boolean> silencedProperties = new HashMap<>();
    protected final Set<String> silenceableProperties = new HashSet<>();

    // Auto names. The atomic integer is always created even if not used, to
    // simplify concurrency.
    AtomicInteger lastAutoNamedBeanRef = new AtomicInteger(0);
    DecimalFormat paddedNumber = new DecimalFormat("0000");

    public AbstractManager(SystemConnectionMemo memo) {
        this.memo = memo;
        this._beans = new TreeSet<>(memo.getNamedBeanComparator(getNamedBeanClass()));
        silenceableProperties.add(PROPERTY_BEANS);
        setRegisterSelf();
    }

    final void setRegisterSelf(){
        registerSelf();
    }

    public AbstractManager() {
        // create and use a reference to an internal connection
        this(InstanceManager.getDefault(jmri.jmrix.internal.InternalSystemConnectionMemo.class));
    }

    /**
     * By default, register this manager to store as configuration information.
     * Override to change that.
     */
    @OverridingMethodsMustInvokeSuper
    protected void registerSelf() {
        log.debug("registerSelf for config of type {}", getClass());
        InstanceManager.getOptionalDefault(ConfigureManager.class).ifPresent(cm -> {
            cm.registerConfig(this, getXMLOrder());
            log.debug("registering for config of type {}", getClass());
        });
    }

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

    /** {@inheritDoc} */
    @Override
    @Nonnull
    public String makeSystemName(@Nonnull String s, boolean logErrors, Locale locale) {
        try {
            return Manager.super.makeSystemName(s, logErrors, locale);
        } catch (IllegalArgumentException ex) {
            if (logErrors || log.isTraceEnabled()) {
                log.error("Invalid system name for {}: {}", getBeanTypeHandled(), ex.getMessage());
            }
            throw ex;
        }
    }

    /** {@inheritDoc} */
    @Override
    @OverridingMethodsMustInvokeSuper
    public void dispose() {
        InstanceManager.getOptionalDefault(ConfigureManager.class).ifPresent(cm -> cm.deregister(this));
        _beans.clear();
        _tsys.clear();
        _tuser.clear();
    }

    /** {@inheritDoc} */
    @CheckForNull
    @Override
    public E getBySystemName(@Nonnull String systemName) {
        return _tsys.get(systemName);
    }

    /**
     * Protected method used by subclasses to over-ride the default behavior of
     * getBySystemName when a simple string lookup is not sufficient.
     *
     * @param systemName the system name to check
     * @param comparator a Comparator encapsulating the system specific comparison behavior
     * @return a named bean of the appropriate type, or null if not found
     */
    @CheckForNull
    protected E getBySystemName(String systemName, Comparator<String> comparator){
        for (Map.Entry<String,E> e : _tsys.entrySet()) {
            if (0 == comparator.compare(e.getKey(), systemName)) {
                return e.getValue();
            }
        }
        return null;
    }

    /** {@inheritDoc} */
    @Override
    @CheckForNull
    public E getByUserName(@Nonnull String userName) {
        String normalizedUserName = NamedBean.normalizeUserName(userName);
        return normalizedUserName != null ? _tuser.get(normalizedUserName) : null;
    }

    /** {@inheritDoc} */
    @CheckForNull
    @Override
    public E getNamedBean(@Nonnull String name) {
        String normalizedUserName = NamedBean.normalizeUserName(name);
        if (normalizedUserName != null) {
            E b = getByUserName(normalizedUserName);
            if (b != null) {
                return b;
            }
        }
        return getBySystemName(name);
    }

    /** {@inheritDoc} */
    @Override
    @OverridingMethodsMustInvokeSuper
    public void deleteBean(@Nonnull E bean, @Nonnull String property) throws PropertyVetoException {
        // throws PropertyVetoException if vetoed
        fireVetoableChange(property, bean, null);
        if ( PROPERTY_DO_DELETE.equals(property) ) {
            deregister(bean);
            bean.dispose();
        }
    }

    /** {@inheritDoc} */
    @edu.umd.cs.findbugs.annotations.SuppressFBWarnings( value="SLF4J_FORMAT_SHOULD_BE_CONST",
        justification="String already built for use in exception text")
    @Override
    @OverridingMethodsMustInvokeSuper
    public void register(@Nonnull E s) {
        String systemName = s.getSystemName();

        E existingBean = getBySystemName(systemName);
        if (existingBean != null) {
            if (s == existingBean) {
                log.debug("the named bean is registered twice: {}", systemName);
            } else {
                log.error("systemName is already registered: {}", systemName);
                throw new DuplicateSystemNameException("systemName is already registered: " + systemName);
            }
        } else {
            // Check if the manager already has a bean with a system name that is
            // not equal to the system name of the new bean, but there the two
            // system names are treated as the same. For example LT1 and LT01.
            if (_beans.contains(s)) {
                final AtomicReference<String> oldSysName = new AtomicReference<>();
                Comparator<E> c = memo.getNamedBeanComparator(getNamedBeanClass());
                _beans.forEach(t -> {
                    if (c.compare(s, t) == 0) {
                        oldSysName.set(t.getSystemName());
                    }
                });
                if (!systemName.equals(oldSysName.get())) {
                    String msg = String.format("systemName is already registered. Current system name: %s. New system name: %s",
                            oldSysName, systemName);
                    log.error(msg);
                    throw new DuplicateSystemNameException(msg);
                }
            }
        }

        // save this bean
        _beans.add(s);
        _tsys.put(systemName, s);
        registerUserName(s);

        // notifications
        int position = isPositionNeeded() ? getPosition(s) : -1;
        fireDataListenersAdded(position, position, s);
        if (!silencedProperties.getOrDefault(PROPERTY_BEANS, false)) {
            fireIndexedPropertyChange(PROPERTY_BEANS, position, null, s);
        }
        firePropertyChange(PROPERTY_LENGTH, null, _beans.size());
        // listen for name and state changes to forward
        s.addPropertyChangeListener(this);
    }

    // not efficient, but does job for now
    private int getPosition(E s) {
        if (_beans.contains(s)) {
            // beans are often added in order, check the ends before counting
            if (_beans.last() == s) {
                return _beans.size() - 1;
            }
            if (_beans.first() == s) {
                return 0;
            }
            return _beans.headSet(s, false).size();
        } else {
            return -1;
        }
    }

    // the position is only sent to data listeners and "beans" listeners
    private boolean isPositionNeeded() {
        return (!muted && !listeners.isEmpty())
                || (!silencedProperties.getOrDefault(PROPERTY_BEANS, false)
                        && propertyChangeSupport.hasListeners(PROPERTY_BEANS));
    }

    /**
     * Invoked by {@link #register(NamedBean)} to register the user name of the
     * bean.
     *
     * @param s the bean to register
     */
    protected void registerUserName(E s) {
        String userName = s.getUserName();
        if (userName == null) {
            return;
        }

        handleUserNameUniqueness(s);
        // since we've handled uniqueness,
        // store the new bean under the name
        _tuser.put(userName, s);
    }

    /**
     * Invoked by {@link #registerUserName(NamedBean)} to ensure uniqueness of
     * the NamedBean during registration.
     *
     * @param s the bean to register
     */
    protected void handleUserNameUniqueness(E s) {
        String userName = s.getUserName();
        // enforce uniqueness of user names
        // by setting username to null in any existing bean with the same name
        // Note that this is not a "move" operation for the user name
        if (userName != null && _tuser.get(userName) != null && _tuser.get(userName) != s) {
            _tuser.get(userName).setUserName(null);
        }
    }

    /** {@inheritDoc} */
    @Override
    @OverridingMethodsMustInvokeSuper
    public void deregister(@Nonnull E s) {
        int position = isPositionNeeded() ? getPosition(s) : -1;

        // stop listening for user name changes
        s.removePropertyChangeListener(this);

        // remove bean from local storage
        String systemName = s.getSystemName();
        _beans.remove(s);
        _tsys.remove(systemName);
        String userName = s.getUserName();
        if (userName != null) {
            _tuser.remove(userName);
        }

        // notifications
        fireDataListenersRemoved(position, position, s);
        if (!silencedProperties.getOrDefault(PROPERTY_BEANS, false)) {
            fireIndexedPropertyChange(PROPERTY_BEANS, position, s, null);
        }
        firePropertyChange(PROPERTY_LENGTH, null, _beans.size());
    }

    /**
     * By default there are no custom properties.
     *
     * @return empty list
     */
    @Override
    @Nonnull
    public List<NamedBeanPropertyDescriptor<?>> getKnownBeanProperties() {
        return new LinkedList<>();
    }

    /**
     * Get the outer bean of an encapsulated bean.
     * Some managers encapsulates the beans and those managers needs to
     * override this method.
     * @param  bean the bean
     * @return the most outer bean or the bean itself if there is no
     *         outer bean
     */
    protected E getOuterBean(E bean) {
        return bean;
    }

    /**
     * The PropertyChangeListener interface in this class is intended to keep
     * track of user name changes to individual NamedBeans. It is not completely
     * implemented yet. In particular, listeners are not added to newly
     * registered objects.
     *
     * @param e the event
     */
    @Override
    @SuppressWarnings("unchecked") // The cast of getSource() to E can't be checked due to type erasure, but we catch errors
    @OverridingMethodsMustInvokeSuper
    public void propertyChange(PropertyChangeEvent e) {
        if ( NamedBean.PROPERTY_USERNAME.equals( e.getPropertyName())) {
            String old = (String) e.getOldValue();  // previous user name
            String now = (String) e.getNewValue();  // current user name
            try { // really should always succeed
                E t = getOuterBean((E) e.getSource());
                if (old != null) {
                    _tuser.remove(old); // remove old name for this bean
                }
                if (now != null) {
                    // was there previously a bean with the new name?
                    if (_tuser.get(now) != null && _tuser.get(now) != t) {
                        // If so, clear. Note that this is not a "move" operation
                        _tuser.get(now).setUserName(null);
                    }
                    _tuser.put(now, t); // put new name for this bean
                }
            } catch (ClassCastException ex) {
                log.error("Received event of wrong type {}", e.getSource().getClass().getName(), ex);
            }

            // called DisplayListName, as DisplayName might get used at some point by a NamedBean
            firePropertyChange(PROPERTY_DISPLAY_LIST_NAME, old, now); // NOI18N
        }
    }

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

    /** {@inheritDoc} */
    @Override
    @Nonnull
    public SortedSet<E> getNamedBeanSet() {
        return Collections.unmodifiableSortedSet(_beans);
    }

    /**
     * Inform all registered listeners of a vetoable change. If the
     * propertyName is "CanDelete" ALL listeners with an interest in the bean
     * will throw an exception, which is recorded returned back to the invoking
     * method, so that it can be presented back to the user. However if a
     * listener decides that the bean can not be deleted then it should throw an
     * exception with a property name of "DoNotDelete", this is thrown back up
     * to the user and the delete process should be aborted.
     *
     * @param p   The programmatic name of the property that is to be changed.
     *            "CanDelete" will inquire with all listeners if the item can
     *            be deleted. "DoDelete" tells the listener to delete the item.
     * @param old The old value of the property.
     * @param n   The new value of the property.
     * @throws PropertyVetoException if the recipients wishes the delete to be
     *                               aborted.
     */
    @OverridingMethodsMustInvokeSuper
    @Override
    public void fireVetoableChange(String p, Object old, Object n) throws PropertyVetoException {
        PropertyChangeEvent evt = new PropertyChangeEvent(this, p, old, n);
        if ( PROPERTY_CAN_DELETE.equals(p) ) {
            StringBuilder message = new StringBuilder();
            for (VetoableChangeListener vc : vetoableChangeSupport.getVetoableChangeListeners()) {
                try {
                    vc.vetoableChange(evt);
                } catch (PropertyVetoException e) {
                    if (PROPERTY_DO_NOT_DELETE.equals(e.getPropertyChangeEvent().getPropertyName())) {
                        log.info("Do Not Delete : {}", e.getMessage());
                        throw e;
                    }
                    message.append(e.getMessage()).append("<hr>"); // NOI18N
                }
            }
            throw new PropertyVetoException(message.toString(), evt);
        } else {
            try {
                vetoableChangeSupport.fireVetoableChange(evt);
            } catch (PropertyVetoException e) {
                log.error("Change vetoed.", e);
            }
        }
    }

    /** {@inheritDoc} */
    @Override
    @OverridingMethodsMustInvokeSuper
    public void vetoableChange(PropertyChangeEvent evt) throws PropertyVetoException {

        if (PROPERTY_CAN_DELETE.equals(evt.getPropertyName())) {
            StringBuilder message = new StringBuilder();
            message.append(Bundle.getMessage("VetoFoundIn", getBeanTypeHandled()))
                    .append("<ul>");
            boolean found = false;
            for (NamedBean nb : _beans) {
                try {
                    nb.vetoableChange(evt);
                } catch (PropertyVetoException e) {
                    if (PROPERTY_DO_NOT_DELETE.equals(e.getPropertyChangeEvent().getPropertyName())) {
                        throw e;
                    }
                    found = true;
                    message.append("<li>")
                            .append(e.getMessage())
                            .append("</li>");
                }
            }
            message.append("</ul>")
                    .append(Bundle.getMessage("VetoWillBeRemovedFrom", getBeanTypeHandled()));
            if (found) {
                throw new PropertyVetoException(message.toString(), evt);
            }
        } else {
            for (NamedBean nb : _beans) {
                // throws PropertyVetoException if vetoed
                nb.vetoableChange(evt);
            }
        }
    }

    /**
     * {@inheritDoc}
     *
     * @return {@link jmri.Manager.NameValidity#INVALID} if system name does not
     *         start with
     *         {@link #getSystemNamePrefix()}; {@link jmri.Manager.NameValidity#VALID_AS_PREFIX_ONLY}
     *         if system name equals {@link #getSystemNamePrefix()}; otherwise
     *         {@link jmri.Manager.NameValidity#VALID} to allow Managers that do
     *         not perform more specific validation to be considered valid.
     */
    @Override
    public NameValidity validSystemNameFormat(@Nonnull String systemName) {
        if (getSystemNamePrefix().equals(systemName)) {
            return NameValidity.VALID_AS_PREFIX_ONLY;
        }
        return systemName.startsWith(getSystemNamePrefix()) ? NameValidity.VALID : NameValidity.INVALID;
    }

    /**
     * {@inheritDoc}
     *
     * The implementation in {@link AbstractManager} should be final, but is not
     * for four managers that have arbitrary prefixes.
     */
    @Override
    @Nonnull
    public final String getSystemPrefix() {
        return memo.getSystemPrefix();
    }

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

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

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

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

    private boolean muted = false;

    /** {@inheritDoc} */
    @Override
    public void setDataListenerMute(boolean m) {
        if (muted && !m) {
            // send a total update, as we haven't kept track of specifics
            ManagerDataEvent<E> e = new ManagerDataEvent<>(this, ManagerDataEvent.CONTENTS_CHANGED, 0, getObjectCount()-1, null);
            listeners.forEach(listener -> listener.contentsChanged(e));
        }
        this.muted = m;
    }

    protected void fireDataListenersAdded(int start, int end, E changedBean) {
        if (muted) return;
        ManagerDataEvent<E> e = new ManagerDataEvent<>(this, ManagerDataEvent.INTERVAL_ADDED, start, end, changedBean);
        listeners.forEach(m -> m.intervalAdded(e));
    }

    protected void fireDataListenersRemoved(int start, int end, E changedBean) {
        if (muted) return;
        ManagerDataEvent<E> e = new ManagerDataEvent<>(this, ManagerDataEvent.INTERVAL_REMOVED, start, end, changedBean);
        listeners.forEach(m -> m.intervalRemoved(e));
    }

    public void updateAutoNumber(String systemName) {
        /* The following keeps track of the last created auto system name.
         currently we do not reuse numbers, although there is nothing to stop the
         user from manually recreating them */
        String autoPrefix = getSubSystemNamePrefix() + ":AUTO:";
        if (systemName.startsWith(autoPrefix)) {
            try {
                int autoNumber = Integer.parseInt(systemName.substring(autoPrefix.length()));
                lastAutoNamedBeanRef.accumulateAndGet(autoNumber, Math::max);
            } catch (NumberFormatException e) {
                log.warn("Auto generated SystemName {} is not in the correct format", systemName);
            }
        }
    }

    public String getAutoSystemName() {
        int nextAutoBlockRef = lastAutoNamedBeanRef.incrementAndGet();
        StringBuilder b = new StringBuilder(getSubSystemNamePrefix() + ":AUTO:");
        String nextNumber = paddedNumber.format(nextAutoBlockRef);
        b.append(nextNumber);
        return b.toString();
    }

    /**
     * Create a System Name from hardware address and system letter prefix.
     * AbstractManager performs no validation.
     * @param curAddress hardware address, no system prefix or type letter.
     * @param prefix - just system prefix, not including Type Letter.
     * @return full system name with system prefix, type letter and hardware address.
     * @throws JmriException if unable to create a system name.
     */
    public String createSystemName(@Nonnull String curAddress, @Nonnull String prefix) throws JmriException {
        return prefix + typeLetter() + curAddress;
    }

    /**
     * checks for numeric-only system names.
     * @param curAddress the System name ( excluding both prefix and type letter) to check.
     * @return unchanged if is numeric string.
     * @throws JmriException if not numeric.
     */
    protected String checkNumeric(@Nonnull String curAddress) throws JmriException {
        try {
            Integer.parseInt(curAddress);
        } catch (java.lang.NumberFormatException ex) {
            throw new JmriException("Hardware Address passed "+curAddress+" should be a number");
        }
        return curAddress;
    }

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

}