/*

 * Copyright (c) 2005, 2015, 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.

 *

 * 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.

 */

import java.util.Collection;

import java.util.Date;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

import javax.management.Descriptor;

import javax.management.ImmutableDescriptor;

import javax.management.ListenerNotFoundException;

import javax.management.MBeanNotificationInfo;

import javax.management.MBeanRegistration;

import javax.management.MBeanServer;

import javax.management.Notification;

import javax.management.NotificationBroadcasterSupport;

import javax.management.NotificationEmitter;

import javax.management.NotificationFilter;

import javax.management.NotificationListener;

import javax.management.ObjectName;

/**

 * Class Basic

 * Basic Description

 */

public class Basic implements BasicMXBean, NotificationEmitter,

                              MBeanRegistration {

    public static final String EXCEPTION_MESSAGE = "from Basic";

    public static final String NOTIFICATION_MESSAGE = "from Basic";

    /** Attribute : IntAtt */

    private int intAtt = 0;

    /** Attribute : IntegerAtt */

    private Integer integerAtt = 0;

    /** Attribute : BoolAtt */

    private boolean boolAtt = false;

    /** Attribute : BooleanAtt */

    private Boolean booleanAtt = false;

    /** Attribute : StringAtt */

    private String stringAtt = null;

    /** Attribute : DateAtt */

    private Date dateAtt = null;

    /** Attribute : ObjectNameAtt */

    private ObjectName objectNameAtt = null;

    /** Attribute : NotifDescriptorAsMapAtt */

    private Map<String, String> notifDescriptorAsMapAtt = null;

    /** Attribute : NotifDescriptorAtt */

    private Descriptor notifDescriptorAtt = null;

    /** Attribute : SqeParameter */

    private SqeParameter sqeParameterAtt = null;

    /* Creates a new instance of Basic */

    @SqeDescriptorKey("CONSTRUCTOR Basic")

    public Basic() {

    }

    /* Creates a new instance of Basic */

    @SqeDescriptorKey("CONSTRUCTOR Basic")

    public Basic(

            @SqeDescriptorKey("CONSTRUCTOR PARAMETER SqeParameter") SqeParameter param) {

    }

    /**

     * Get int attribute

     */

    public int getIntAtt() {

        return intAtt;

    }

    /**

     * Set int attribute

     */

    public void setIntAtt(int value) {

        intAtt = value;

    }

    /**

     * Get Integer attribute

     */

    public Integer getIntegerAtt() {

        return integerAtt;

    }

    /**

     * Set Integer attribute

     */

    public void setIntegerAtt(Integer value) {

        integerAtt = value;

    }

    /**

     * Get boolean attribute

     */

    public boolean getBoolAtt() {

        return boolAtt;

    }

    /**

     * Set boolean attribute

     */

    public void setBoolAtt(boolean value) {

        boolAtt = value;

    }

    /**

     * Get Boolean attribute

     */

    public Boolean getBooleanAtt() {

        return booleanAtt;

    }

    /**

     * Set Boolean attribute

     */

    public void setBooleanAtt(Boolean value) {

        booleanAtt = value;

    }

    /**

     * Get String attribute

     */

    public String getStringAtt() {

        return stringAtt;

    }

    /**

     * Set String attribute

     */

    public void setStringAtt(String value) {

        stringAtt = value;

    }

    /**

     * Get Date attribute

     */

    public Date getDateAtt() {

        return dateAtt;

    }

    /**

     * Set Date attribute

     */

    public void setDateAtt(Date value) {

        dateAtt = value;

    }

    /**

     * Get ObjectName attribute

     */

    public ObjectName getObjectNameAtt() {

        return objectNameAtt;

    }

    /**

     * Set ObjectName attribute

     */

    public void setObjectNameAtt(ObjectName value) {

        objectNameAtt = value;

    }

    /**

     * Get SqeParameter attribute

     */

    public SqeParameter getSqeParameterAtt() throws Exception {

        if (sqeParameterAtt == null) {

            sqeParameterAtt = new SqeParameter();

            sqeParameterAtt.setGlop("INITIALIZED");

        }

        return sqeParameterAtt;

    }

    /**

     * Set SqeParameter attribute

     */

    public void setSqeParameterAtt(SqeParameter value) {

        sqeParameterAtt = value;

    }

    /**

     * Get the Descriptor used to build the NotificationInfo

     * of emitted notifications.

     */

    public Map<String, String> getNotifDescriptorAsMapAtt() {

        if (notifDescriptorAsMapAtt == null) {

            initNotifDescriptorAtt();

        }

        return notifDescriptorAsMapAtt;

    }

    /**

     * Set the Descriptor used to build the NotificationInfo

     * of emitted notifications.

     * <br>A Map<String, Object> would better fit Descriptor needs but then

     * it is not convertible according the MXBean specification so the MBean

     * registration fails.

     * As we plan to test our custom Descriptor finds its way into

     * the metadata of emitted notifications, String is good enough.

     */

    public void setNotifDescriptorAsMapAtt(Map<String, String> value) {

        notifDescriptorAsMapAtt = new HashMap<String, String>(value);

        notifDescriptorAtt = new ImmutableDescriptor(value);

    }

    /**

     * Do nothing

     */

    public void doNothing() {

        // I said NOTHING !

    }

    /**

     * Do take SqeParameter as a parameter

     */

    public void doWeird(SqeParameter param) {

    }

    /**

     * Throw an Exception

     */

    public void throwException() throws Exception {

        throw new Exception(EXCEPTION_MESSAGE);

    }

    /**

     * Throw an Error

     */

    public void throwError() {

        throw new InternalError(EXCEPTION_MESSAGE);

    }

    /**

     * Reset all attributes

     */

    public void reset() {

        intAtt = 0;

        integerAtt = 0;

        boolAtt = false;

        booleanAtt = Boolean.FALSE;

        stringAtt = null;

        dateAtt = null;

        objectNameAtt = null;

    }

    /**

     * Returns the weather for the coming days

     * @param verbose <code>boolean</code> verbosity

     * @throws java.lang.Exception <code>storm</code>

     * @return <code>ObjectName</code>

     */

    public Weather getWeather(boolean verbose)

            throws java.lang.Exception {

        return Weather.SUNNY;

    }

    // Starting here are the 4 methods of MBeanRegistration interface.

    // We use that to grab the ObjectName the MBean is registered with.

    //

    public ObjectName preRegister(MBeanServer server, ObjectName name)

            throws Exception {

        // Grab a reference on the MBeanServer we're registered in.

        mbs = server;

        // Compute the name we're registered with.

        if (name != null) {

            mbeanName = name;

            return name;

        } else {

            mbeanName =

                new ObjectName("sqe:type=" + Basic.class.getName());

            return mbeanName;

        }

    }

    public void postRegister(Boolean registrationDone) {

        // Do nothing

    }

    public void preDeregister() throws Exception {

        // Do nothing

    }

    public void postDeregister() {

        // Do nothing

    }

    /**

     * Send one Notification of the provided notifType type.

     */

    public void sendNotification(String notifType) {

        Notification notification = null;

        if (notifType.equals(NOTIF_TYPE_0)) {

            notification = new Notification(NOTIF_TYPE_0,

                    mbeanName,

                    seqNumber,

                    NOTIFICATION_MESSAGE);

        } else if (notifType.equals(NOTIF_TYPE_1)) {

            notification = new SqeNotification(NOTIF_TYPE_1,

                    mbeanName,

                    seqNumber,

                    NOTIFICATION_MESSAGE);

        }

        seqNumber++;

        broadcaster.sendNotification(notification);

    }

    /**

     * That method starts a set of threads, each thread sends a given number of

     * notifications.

     * The number of threads can be set via the attribute numOfNotificationSenders.

     * The number of notification sent by each thread can be set via

     * the attribute numOfNotificationSenderLoops.

     * Depending on the parameter customNotification we send either custom

     * notification(s) or MBeanServer registration and unregistration notification(s).

     * When customNotification=true the total number of notification(s) sent is

     * (numOfNotificationSenders * numOfNotificationSenderLoops). They are

     * sequentially of type NOTIF_TYPE_0 then NOTIF_TYPE_1 and so on.

     *

     * When customNotification=false the total number of notification(s) sent is

     * (numOfNotificationSenders * numOfNotificationSenderLoops) registration

     * notification(s)

     * +

     * (numOfNotificationSenders * numOfNotificationSenderLoops) unregistration

     * notification(s)

     *

     * @throws java.lang.Exception

     */

    public void sendNotificationWave(boolean customNotification) throws

            Exception {

        // Build the set of notification sender.

        Collection<Callable<Integer>> tasks =

                new HashSet<Callable<Integer>>(numOfNotificationSenders);

        for (int i = 1; i <= numOfNotificationSenders; i++) {

            tasks.add(new NotifSender(numOfNotificationSenderLoops,

                    customNotification, i));

        }

        // Start all notification sender in parallel.

        ExecutorService execServ = null;

        try {

            execServ = Executors.newFixedThreadPool(numOfNotificationSenders);

            List<Future<Integer>> taskHandlers = execServ.invokeAll(tasks);

            checkNotifSenderThreadStatus(taskHandlers);

        } finally {

            if (!execServ.isShutdown()) {

                execServ.shutdown();

            }

        }

    }

    public void setNumOfNotificationSenders(int value) {

        numOfNotificationSenders = value;

    }

    public void setNumOfNotificationSenderLoops(int value) {

        numOfNotificationSenderLoops = value;

    }

    /**

     * MBean Notification support

     * You shouldn't update these methods

     */

    // <editor-fold defaultstate="collapsed" desc=" Generated Code ">

    public void addNotificationListener(NotificationListener listener,

                                        NotificationFilter filter,

                                        Object handback)

            throws IllegalArgumentException {

        broadcaster.addNotificationListener(listener, filter, handback);

    }

    public MBeanNotificationInfo[] getNotificationInfo() {

        if (notifDescriptorAtt == null) {

            initNotifDescriptorAtt();

        }

        return new MBeanNotificationInfo[]{

                    new MBeanNotificationInfo(new String[]{

                        NOTIF_TYPE_0

                    },

                    javax.management.Notification.class.getName(),

                    "Standard JMX Notification",

                    notifDescriptorAtt),

                    new MBeanNotificationInfo(new String[]{

                        NOTIF_TYPE_1

                    },

                    SqeNotification.class.getName(),

                    "SQE Notification",

                    notifDescriptorAtt)

                };

    }

    public void removeNotificationListener(NotificationListener listener)

            throws ListenerNotFoundException {

        broadcaster.removeNotificationListener(listener);

    }

    public void removeNotificationListener(NotificationListener listener,

                                           NotificationFilter filter,

                                           Object handback)

            throws ListenerNotFoundException {

        broadcaster.removeNotificationListener(listener, filter, handback);

    }

    // </editor-fold>

    private synchronized long getNextSeqNumber() {

        return seqNumber++;

    }

    private void initNotifDescriptorAtt() {

        String key = "CRABE";

        String value = "TAMBOUR";

        notifDescriptorAtt =

                new ImmutableDescriptor(new String[]{key + "=" + value});

        notifDescriptorAsMapAtt =

                new HashMap<String, String>();

        notifDescriptorAsMapAtt.put(key, value);

    }

    private void checkNotifSenderThreadStatus(

            List<Future<Integer>> taskHandlers)

            throws Exception {

        String msgTag = "Basic::checkNotifSenderThreadStatus: ";

        // Grab back status of each notification sender.

        for (Future<Integer> f : taskHandlers) {

            if (f.isCancelled()) {

                String message = msgTag +

                        "---- ERROR : One thread has been cancelled";

                System.out.println(message);

                throw new RuntimeException(message);

            } else {

                Integer effectiveNumOfLoops = f.get();

                if (effectiveNumOfLoops != numOfNotificationSenderLoops) {

                    String message = msgTag + "---- ERROR : One thread did " +

                            effectiveNumOfLoops + " loops in place of " +

                            numOfNotificationSenderLoops;

                    System.out.println(message);

                    throw new RuntimeException(message);

                }

            }

        }

    }

    //

    private int numOfNotificationSenderLoops = 2;

    private int numOfNotificationSenders = 13;

    private class NotifSender implements Callable<Integer> {

        private int cycles;

        private boolean customNotification;

        private int senderID;

        public NotifSender(int cycles, boolean customNotification, int id) {

            this.cycles = cycles;

            this.customNotification = customNotification;

            this.senderID = id;

        }

        public Integer call() throws Exception {

            int callsDone = 0;

            try {

                for (int i = 1; i <= cycles; i++) {

                    if (customNotification) {

                        if (i % 2 == 0) {

                            sendNotification(NOTIF_TYPE_0);

                        } else {

                            sendNotification(NOTIF_TYPE_1);

                        }

                    } else {

                        ObjectName mbeanName = new ObjectName("SQE:type=" +

                                mbeanClassName + ",senderID=" + senderID);

                        mbs.createMBean(mbeanClassName, mbeanName);

                        mbs.unregisterMBean(mbeanName);

                    }

                    callsDone++;

                }

            } catch (Exception e) {

                System.out.println("NotifSender::call: (ERROR) Thread [" + senderID +

                        "] failed after " + callsDone + " cycles");

                throw e;

            }

            return Integer.valueOf(callsDone);

        }

    }

    //

    private long seqNumber;

    private final NotificationBroadcasterSupport broadcaster =

            new NotificationBroadcasterSupport();

    private ObjectName mbeanName;

    private MBeanServer mbs;

    private String mbeanClassName = "Simple";

    /**

     * Notification types definitions. To use when creating JMX Notifications.

     */

    public static final String NOTIF_TYPE_0 =

            "sqe.notification.a.type";

    public static final String NOTIF_TYPE_1 =

            "sqe.notification.b.type";