/*

 * Copyright 2008 Sun Microsystems, Inc.  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.

 *

 * 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

/*

 * @test

 * @bug 5072267

 * @summary Test that an MBean can handle localized Notification messages.

 * @author Eamonn McManus

 */

import java.util.Collections;

import java.util.ListResourceBundle;

import java.util.Locale;

import java.util.Map;

import java.util.MissingResourceException;

import java.util.ResourceBundle;

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.Callable;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.ConcurrentMap;

import java.util.concurrent.TimeUnit;

import javax.management.ClientContext;

import javax.management.JMX;

import javax.management.ListenerNotFoundException;

import javax.management.MBeanNotificationInfo;

import javax.management.MBeanServer;

import javax.management.MBeanServerConnection;

import javax.management.MBeanServerFactory;

import javax.management.Notification;

import javax.management.NotificationBroadcasterSupport;

import javax.management.NotificationEmitter;

import javax.management.NotificationFilter;

import javax.management.NotificationListener;

import javax.management.ObjectName;

import javax.management.SendNotification;

import javax.management.remote.JMXConnector;

import javax.management.remote.JMXConnectorFactory;

import javax.management.remote.JMXConnectorServer;

import javax.management.remote.JMXConnectorServerFactory;

import javax.management.remote.JMXServiceURL;

public class LocaleAwareBroadcasterTest {

    static final ObjectName mbeanName = ObjectName.valueOf("d:type=LocaleAware");

    static final String

            messageKey = "broken.window",

            defaultMessage = "broken window",

            frenchMessage = "fen\u00eatre bris\u00e9e",

            irishMessage = "fuinneog briste";

    public static class Bundle extends ListResourceBundle {

        @Override

        protected Object[][] getContents() {

            return new Object[][] {

                {messageKey, defaultMessage},

            };

        }

    }

    public static class Bundle_fr extends ListResourceBundle {

        @Override

        protected Object[][] getContents() {

            return new Object[][] {

                {messageKey, frenchMessage},

            };

        }

    }

    public static class Bundle_ga extends ListResourceBundle {

        @Override

        protected Object[][] getContents() {

            return new Object[][] {

                {messageKey, irishMessage},

            };

        }

    }

    static volatile String failure;

    public static interface LocaleAwareMBean {

        public void sendNotification(Notification n);

    }

    public static class LocaleAware

            implements LocaleAwareMBean, NotificationEmitter, SendNotification {

        private final ConcurrentMap<Locale, NotificationBroadcasterSupport>

                localeToEmitter = newConcurrentMap();

        public void sendNotification(Notification n) {

            for (Map.Entry<Locale, NotificationBroadcasterSupport> entry :

                    localeToEmitter.entrySet()) {

                Notification localizedNotif =

                        localizeNotification(n, entry.getKey());

                entry.getValue().sendNotification(localizedNotif);

            }

        }

        public void addNotificationListener(

                NotificationListener listener,

                NotificationFilter filter,

                Object handback)

                throws IllegalArgumentException {

            Locale locale = ClientContext.getLocale();

            NotificationBroadcasterSupport broadcaster;

            broadcaster = localeToEmitter.get(locale);

            if (broadcaster == null) {

                broadcaster = new NotificationBroadcasterSupport();

                NotificationBroadcasterSupport old =

                        localeToEmitter.putIfAbsent(locale, broadcaster);

                if (old != null)

                    broadcaster = old;

            }

            broadcaster.addNotificationListener(listener, filter, handback);

        }

        public void removeNotificationListener(NotificationListener listener)

                throws ListenerNotFoundException {

            Locale locale = ClientContext.getLocale();

            NotificationBroadcasterSupport broadcaster =

                    localeToEmitter.get(locale);

            if (broadcaster == null)

                throw new ListenerNotFoundException();

            broadcaster.removeNotificationListener(listener);

        }

        public void removeNotificationListener(

                NotificationListener listener,

                NotificationFilter filter,

                Object handback)

                throws ListenerNotFoundException {

            Locale locale = ClientContext.getLocale();

            NotificationBroadcasterSupport broadcaster =

                    localeToEmitter.get(locale);

            if (broadcaster == null)

                throw new ListenerNotFoundException();

            broadcaster.removeNotificationListener(listener, filter, handback);

        }

        public MBeanNotificationInfo[] getNotificationInfo() {

            return new MBeanNotificationInfo[0];

        }

    }

    // Localize notif using the convention that the message looks like

    // [resourcebundlename:resourcekey]defaultmessage

    // for example [foo.bar.Resources:unknown.problem]

    static Notification localizeNotification(Notification n, Locale locale) {

        String msg = n.getMessage();

        if (!msg.startsWith("["))

            return n;

        int close = msg.indexOf(']');

        if (close < 0)

            throw new IllegalArgumentException("Bad notification message: " + msg);

        int colon = msg.indexOf(':');

        if (colon < 0 || colon > close)

            throw new IllegalArgumentException("Bad notification message: " + msg);

        String bundleName = msg.substring(1, colon);

        String key = msg.substring(colon + 1, close);

        ClassLoader loader = LocaleAwareBroadcasterTest.class.getClassLoader();

        ResourceBundle bundle =

                ResourceBundle.getBundle(bundleName, locale, loader);

        try {

            msg = bundle.getString(key);

        } catch (MissingResourceException e) {

            msg = msg.substring(close + 1);

        }

        n = (Notification) n.clone();

        n.setMessage(msg);

        return n;

    }

    public static void main(String[] args) throws Exception {

        Locale.setDefault(new Locale("en"));

        testLocal();

        testRemote();

        if (failure == null)

            System.out.println("TEST PASSED");

        else

            throw new Exception("TEST FAILED: " + failure);

    }

    static interface AddListenerInLocale {

        public void addListenerInLocale(

                MBeanServerConnection mbsc,

                NotificationListener listener,

                Locale locale) throws Exception;

    }

    private static void testLocal() throws Exception {

        System.out.println("Test local MBeanServer using doWithContext");

        MBeanServer mbs = makeMBS();

        AddListenerInLocale addListener = new AddListenerInLocale() {

            public void addListenerInLocale(

                    final MBeanServerConnection mbsc,

                    final NotificationListener listener,

                    Locale locale) throws Exception {

                Map<String, String> localeContext = Collections.singletonMap(

                        ClientContext.LOCALE_KEY, locale.toString());

                ClientContext.doWithContext(

                        localeContext, new Callable<Void>() {

                    public Void call() throws Exception {

                        mbsc.addNotificationListener(

                                mbeanName, listener, null, null);

                        return null;

                    }

                });

            }

        };

        test(mbs, addListener);

    }

    private static void testRemote() throws Exception {

        System.out.println("Test remote MBeanServer using withLocale");

        MBeanServer mbs = makeMBS();

        JMXServiceURL url = new JMXServiceURL("service:jmx:rmi://");

        JMXConnectorServer cs =

                JMXConnectorServerFactory.newJMXConnectorServer(url, null, mbs);

        cs.start();

        JMXServiceURL addr = cs.getAddress();

        JMXConnector cc = JMXConnectorFactory.connect(addr);

        MBeanServerConnection mbsc = cc.getMBeanServerConnection();

        AddListenerInLocale addListenerInLocale = new AddListenerInLocale() {

            public void addListenerInLocale(

                    MBeanServerConnection mbsc,

                    NotificationListener listener,

                    Locale locale) throws Exception {

                mbsc = ClientContext.withLocale(mbsc, locale);

                mbsc.addNotificationListener(mbeanName, listener, null, null);

            }

        };

        try {

            test(mbsc, addListenerInLocale);

        } finally {

            try {

                cc.close();

            } catch (Exception e) {}

            cs.stop();

        }

    }

    static class QueueListener implements NotificationListener {

        final BlockingQueue<Notification> queue =

                new ArrayBlockingQueue<Notification>(10);

        public void handleNotification(Notification notification,

                                       Object handback) {

            queue.add(notification);

        }

    }

    private static void test(

            MBeanServerConnection mbsc, AddListenerInLocale addListener)

            throws Exception {

        QueueListener defaultListener = new QueueListener();

        QueueListener frenchListener = new QueueListener();

        QueueListener irishListener = new QueueListener();

        mbsc.addNotificationListener(mbeanName, defaultListener, null, null);

        addListener.addListenerInLocale(mbsc, frenchListener, new Locale("fr"));

        addListener.addListenerInLocale(mbsc, irishListener, new Locale("ga"));

        LocaleAwareMBean proxy =

                JMX.newMBeanProxy(mbsc, mbeanName, LocaleAwareMBean.class);

        String notifMsg = "[" + Bundle.class.getName() + ":" + messageKey + "]" +

                "broken window (default message that should never be seen)";

        Notification notif = new Notification(

                "notif.type", mbeanName, 0L, notifMsg);

        proxy.sendNotification(notif);

        final Object[][] expected = {

            {defaultListener, defaultMessage},

            {frenchListener, frenchMessage},

            {irishListener, irishMessage},

        };

        for (Object[] exp : expected) {

            QueueListener ql = (QueueListener) exp[0];

            String msg = (String) exp[1];

            System.out.println("Checking: " + msg);

            Notification n = ql.queue.poll(1, TimeUnit.SECONDS);

            if (n == null)

                fail("Did not receive expected notif: " + msg);

            if (!n.getMessage().equals(msg)) {

                fail("Received notif with wrong message: got " +

                        n.getMessage() + ", expected " + msg);

            }

            n = ql.queue.poll(2, TimeUnit.MILLISECONDS);

            if (n != null)

                fail("Received unexpected extra notif: " + n);

        }

    }

    private static MBeanServer makeMBS() throws Exception {

        MBeanServer mbs = MBeanServerFactory.newMBeanServer();

        LocaleAware aware = new LocaleAware();

        mbs.registerMBean(aware, mbeanName);

        return mbs;

    }

    static <K, V> ConcurrentMap<K, V> newConcurrentMap() {

        return new ConcurrentHashMap<K, V>();

    }

    static void fail(String why) {

        System.out.println("FAIL: " + why);

        failure = why;

    }

}