/*

 * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package javax.management;

import java.util.Collections;

import java.util.List;

import java.util.Objects;

import java.util.concurrent.CopyOnWriteArrayList;

import java.util.concurrent.Executor;

import com.sun.jmx.remote.util.ClassLogger;

/**

 * <p>Provides an implementation of {@link

 * javax.management.NotificationEmitter NotificationEmitter}

 * interface.  This can be used as the super class of an MBean that

 * sends notifications.</p>

 *

 * <p>By default, the notification dispatch model is synchronous.

 * That is, when a thread calls sendNotification, the

 * <code>NotificationListener.handleNotification</code> method of each listener

 * is called within that thread. You can override this default

 * by overriding <code>handleNotification</code> in a subclass, or by passing an

 * Executor to the constructor.</p>

 *

 * <p>If the method call of a filter or listener throws an {@link Exception},

 * then that exception does not prevent other listeners from being invoked.  However,

 * if the method call of a filter or of {@code Executor.execute} or of

 * {@code handleNotification} (when no {@code Excecutor} is specified) throws an

 * {@link Error}, then that {@code Error} is propagated to the caller of

 * {@link #sendNotification sendNotification}.</p>

 *

 * <p>Remote listeners added using the JMX Remote API (see JMXConnector) are not

 * usually called synchronously.  That is, when sendNotification returns, it is

 * not guaranteed that any remote listeners have yet received the notification.</p>

 *

 * @since 1.5

 */

public class NotificationBroadcasterSupport implements NotificationEmitter {

    /**

     * Constructs a NotificationBroadcasterSupport where each listener is invoked by the

     * thread sending the notification. This constructor is equivalent to

     * {@link NotificationBroadcasterSupport#NotificationBroadcasterSupport(Executor,

     * MBeanNotificationInfo[] info) NotificationBroadcasterSupport(null, null)}.

     */

    public NotificationBroadcasterSupport() {

        this(null, (MBeanNotificationInfo[]) null);

    }

    /**

     * Constructs a NotificationBroadcasterSupport where each listener is invoked using

     * the given {@link java.util.concurrent.Executor}. When {@link #sendNotification

     * sendNotification} is called, a listener is selected if it was added with a null

     * {@link NotificationFilter}, or if {@link NotificationFilter#isNotificationEnabled

     * isNotificationEnabled} returns true for the notification being sent. The call to

     * <code>NotificationFilter.isNotificationEnabled</code> takes place in the thread

     * that called <code>sendNotification</code>. Then, for each selected listener,

     * {@link Executor#execute executor.execute} is called with a command

     * that calls the <code>handleNotification</code> method.

     * This constructor is equivalent to

     * {@link NotificationBroadcasterSupport#NotificationBroadcasterSupport(Executor,

     * MBeanNotificationInfo[] info) NotificationBroadcasterSupport(executor, null)}.

     * @param executor an executor used by the method <code>sendNotification</code> to

     * send each notification. If it is null, the thread calling <code>sendNotification</code>

     * will invoke the <code>handleNotification</code> method itself.

     * @since 1.6

     */

    public NotificationBroadcasterSupport(Executor executor) {

        this(executor, (MBeanNotificationInfo[]) null);

    }

    /**

     * <p>Constructs a NotificationBroadcasterSupport with information

     * about the notifications that may be sent.  Each listener is

     * invoked by the thread sending the notification.  This

     * constructor is equivalent to {@link

     * NotificationBroadcasterSupport#NotificationBroadcasterSupport(Executor,

     * MBeanNotificationInfo[] info)

     * NotificationBroadcasterSupport(null, info)}.</p>

     *

     * <p>If the <code>info</code> array is not empty, then it is

     * cloned by the constructor as if by {@code info.clone()}, and

     * each call to {@link #getNotificationInfo()} returns a new

     * clone.</p>

     *

     * @param info an array indicating, for each notification this

     * MBean may send, the name of the Java class of the notification

     * and the notification type.  Can be null, which is equivalent to

     * an empty array.

     *

     * @since 1.6

     */

    public NotificationBroadcasterSupport(MBeanNotificationInfo... info) {

        this(null, info);

    }

    /**

     * <p>Constructs a NotificationBroadcasterSupport with information about the notifications that may be sent,

     * and where each listener is invoked using the given {@link java.util.concurrent.Executor}.</p>

     *

     * <p>When {@link #sendNotification sendNotification} is called, a

     * listener is selected if it was added with a null {@link

     * NotificationFilter}, or if {@link

     * NotificationFilter#isNotificationEnabled isNotificationEnabled}

     * returns true for the notification being sent. The call to

     * <code>NotificationFilter.isNotificationEnabled</code> takes

     * place in the thread that called

     * <code>sendNotification</code>. Then, for each selected

     * listener, {@link Executor#execute executor.execute} is called

     * with a command that calls the <code>handleNotification</code>

     * method.</p>

     *

     * <p>If the <code>info</code> array is not empty, then it is

     * cloned by the constructor as if by {@code info.clone()}, and

     * each call to {@link #getNotificationInfo()} returns a new

     * clone.</p>

     *

     * @param executor an executor used by the method

     * <code>sendNotification</code> to send each notification. If it

     * is null, the thread calling <code>sendNotification</code> will

     * invoke the <code>handleNotification</code> method itself.

     *

     * @param info an array indicating, for each notification this

     * MBean may send, the name of the Java class of the notification

     * and the notification type.  Can be null, which is equivalent to

     * an empty array.

     *

     * @since 1.6

     */

    public NotificationBroadcasterSupport(Executor executor,

                                          MBeanNotificationInfo... info) {

        this.executor = (executor != null) ? executor : defaultExecutor;

        notifInfo = info == null ? NO_NOTIFICATION_INFO : info.clone();

    }

    /**

     * Adds a listener.

     *

     * @param listener The listener to receive notifications.

     * @param filter The filter object. If filter is null, no

     * filtering will be performed before handling notifications.

     * @param handback An opaque object to be sent back to the

     * listener when a notification is emitted. This object cannot be

     * used by the Notification broadcaster object. It should be

     * resent unchanged with the notification to the listener.

     *

     * @exception IllegalArgumentException thrown if the listener is null.

     *

     * @see #removeNotificationListener

     */

    public void addNotificationListener(NotificationListener listener,

                                        NotificationFilter filter,

                                        Object handback) {

        if (listener == null) {

            throw new IllegalArgumentException ("Listener can't be null") ;

        }

        listenerList.add(new ListenerInfo(listener, filter, handback));

    }

    public void removeNotificationListener(NotificationListener listener)

            throws ListenerNotFoundException {

        ListenerInfo wildcard = new WildcardListenerInfo(listener);

        boolean removed =

            listenerList.removeAll(Collections.singleton(wildcard));

        if (!removed)

            throw new ListenerNotFoundException("Listener not registered");

    }

    public void removeNotificationListener(NotificationListener listener,

                                           NotificationFilter filter,

                                           Object handback)

            throws ListenerNotFoundException {

        ListenerInfo li = new ListenerInfo(listener, filter, handback);

        boolean removed = listenerList.remove(li);

        if (!removed) {

            throw new ListenerNotFoundException("Listener not registered " +

                                                "(with this filter and " +

                                                "handback)");

            // or perhaps not registered at all

        }

    }

    public MBeanNotificationInfo[] getNotificationInfo() {

        if (notifInfo.length == 0)

            return notifInfo;

        else

            return notifInfo.clone();

    }

    /**

     * Sends a notification.

     *

     * If an {@code Executor} was specified in the constructor, it will be given one

     * task per selected listener to deliver the notification to that listener.

     *

     * @param notification The notification to send.

     */

    public void sendNotification(Notification notification) {

        if (notification == null) {

            return;

        }

        boolean enabled;

        for (ListenerInfo li : listenerList) {

            try {

                enabled = li.filter == null ||

                    li.filter.isNotificationEnabled(notification);

            } catch (Exception e) {

                if (logger.debugOn()) {

                    logger.debug("sendNotification", e);

                }

                continue;

            }

            if (enabled) {

                executor.execute(new SendNotifJob(notification, li));

            }

        }

    }

    /**

     * <p>This method is called by {@link #sendNotification

     * sendNotification} for each listener in order to send the

     * notification to that listener.  It can be overridden in

     * subclasses to change the behavior of notification delivery,

     * for instance to deliver the notification in a separate

     * thread.</p>

     *

     * <p>The default implementation of this method is equivalent to

     * <pre>

     * listener.handleNotification(notif, handback);

     * </pre>

     *

     * @param listener the listener to which the notification is being

     * delivered.

     * @param notif the notification being delivered to the listener.

     * @param handback the handback object that was supplied when the

     * listener was added.

     *

     */

    protected void handleNotification(NotificationListener listener,

                                      Notification notif, Object handback) {

        listener.handleNotification(notif, handback);

    }

    // private stuff

    private static class ListenerInfo {

        NotificationListener listener;

        NotificationFilter filter;

        Object handback;

        ListenerInfo(NotificationListener listener,

                     NotificationFilter filter,

                     Object handback) {

            this.listener = listener;

            this.filter = filter;

            this.handback = handback;

        }

        @Override

        public boolean equals(Object o) {

            if (!(o instanceof ListenerInfo))

                return false;

            ListenerInfo li = (ListenerInfo) o;

            if (li instanceof WildcardListenerInfo)

                return (li.listener == listener);

            else

                return (li.listener == listener && li.filter == filter

                        && li.handback == handback);

        }

        @Override

        public int hashCode() {

            return Objects.hashCode(listener);

        }

    }

    private static class WildcardListenerInfo extends ListenerInfo {

        WildcardListenerInfo(NotificationListener listener) {

            super(listener, null, null);

        }

        @Override

        public boolean equals(Object o) {

            assert (!(o instanceof WildcardListenerInfo));

            return o.equals(this);

        }

        @Override

        public int hashCode() {

            return super.hashCode();

        }

    }

    private List<ListenerInfo> listenerList =

        new CopyOnWriteArrayList<ListenerInfo>();

    // since 1.6

    private final Executor executor;

    private final MBeanNotificationInfo[] notifInfo;

    private final static Executor defaultExecutor = new Executor() {

            // DirectExecutor using caller thread

            public void execute(Runnable r) {

                r.run();

            }

        };

    private static final MBeanNotificationInfo[] NO_NOTIFICATION_INFO =

        new MBeanNotificationInfo[0];

    private class SendNotifJob implements Runnable {

        public SendNotifJob(Notification notif, ListenerInfo listenerInfo) {

            this.notif = notif;

            this.listenerInfo = listenerInfo;

        }

        public void run() {

            try {

                handleNotification(listenerInfo.listener,

                                   notif, listenerInfo.handback);

            } catch (Exception e) {

                if (logger.debugOn()) {

                    logger.debug("SendNotifJob-run", e);

                }

            }

        }

        private final Notification notif;

        private final ListenerInfo listenerInfo;

    }

    private static final ClassLogger logger =

        new ClassLogger("javax.management", "NotificationBroadcasterSupport");

}