/*

 * Copyright 2007 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.  Sun designates this

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

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

 */

package com.sun.jmx.remote.util;

import com.sun.jmx.event.EventClientFactory;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.util.Arrays;

import java.util.concurrent.Callable;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.management.MBeanServerConnection;

import javax.management.NotificationFilter;

import javax.management.NotificationListener;

import javax.management.ObjectName;

import javax.management.event.EventClient;

import javax.management.event.EventClientDelegate;

/**

 * Class EventClientConnection - a {@link Proxy} that wraps an

 * {@link MBeanServerConnection} and an {@link EventClient}.

 * All methods are routed to the underlying {@code MBeanServerConnection},

 * except add/remove notification listeners which are routed to the

 * {@code EventClient}.

 * The caller only sees an {@code MBeanServerConnection} which uses an

 * {@code EventClient} behind the scenes.

 *

 * @author Sun Microsystems, Inc.

 */

public class EventClientConnection implements InvocationHandler,

        EventClientFactory {

    /**

     * A logger for this class.

     **/

    private static final int NAMESPACE_SEPARATOR_LENGTH =

    /**

     * Creates a new {@code EventClientConnection}.

     * @param  connection The underlying MBeanServerConnection.

     */

    public EventClientConnection(MBeanServerConnection connection) {

        this(connection,null);

    }

    /**

     * Creates a new {@code EventClientConnection}.

     * @param connection The underlying MBeanServerConnection.

     * @param eventClientFactory a factory object that will be invoked

     *        to create an {@link EventClient} when needed.

     *        The {@code EventClient} is created lazily, when it is needed

     *        for the first time. If null, a default factory will be used

     *        (see {@link #createEventClient}).

     */

    public EventClientConnection(MBeanServerConnection connection,

                                 Callable<EventClient> eventClientFactory) {

        if (connection == null) {

            throw new IllegalArgumentException("Null connection");

        }

        this.connection = connection;

        if (eventClientFactory == null) {

            eventClientFactory = new Callable<EventClient>() {

                public final EventClient call() throws Exception {

                    return createEventClient(EventClientConnection.this.connection);

                }

            };

        }

        this.eventClientFactory = eventClientFactory;

        this.lock = new ReentrantLock();

     }

    /**

     * <p>The MBean server connection through which the methods of

     * a proxy using this handler are forwarded.</p>

     *

     * @return the MBean server connection.

     *

     * @since 1.6

     */

    public MBeanServerConnection getMBeanServerConnection() {

        return connection;

    }

    /**

     * Creates a new EventClientConnection proxy instance.

     *

     * @param <T> The underlying {@code MBeanServerConnection} - which should

     *        not be using the Event Service itself.

     * @param interfaceClass {@code MBeanServerConnection.class}, or a subclass.

     * @param eventClientFactory a factory used to create the EventClient.

     *        If null, a default factory is used (see {@link

     *        #createEventClient}).

     * @return the new proxy instance, which will route add/remove notification

     *         listener calls through an {@code EventClient}.

     *

     */

    private static <T extends MBeanServerConnection> T

            newProxyInstance(T connection,

            Class<T> interfaceClass, Callable<EventClient> eventClientFactory) {

        final InvocationHandler handler =

                new EventClientConnection(connection,eventClientFactory);

        final Class[] interfaces =

                new Class[] {interfaceClass, EventClientFactory.class};

        Object proxy =

                Proxy.newProxyInstance(interfaceClass.getClassLoader(),

                interfaces,

                handler);

        return interfaceClass.cast(proxy);

    }

    public Object invoke(Object proxy, Method method, Object[] args)

            throws Throwable {

        final String methodName = method.getName();

        // add/remove notification listener are routed to the EventClient

        if (methodName.equals("addNotificationListener")

            || methodName.equals("removeNotificationListener")) {

            final Class[] sig = method.getParameterTypes();

            if (sig.length>1 &&

                    NotificationListener.class.isAssignableFrom(sig[1])) {

                return invokeBroadcasterMethod(proxy,method,args);

            }

        }

        // subscribe/unsubscribe are also routed to the EventClient.

        final Class clazz = method.getDeclaringClass();

        if (clazz.equals(EventClientFactory.class)) {

            return invokeEventClientSubscriberMethod(proxy,method,args);

        }

        // local or not: equals, toString, hashCode

        if (shouldDoLocally(proxy, method))

            return doLocally(proxy, method, args);

        return call(connection,method,args);

    }

    // The purpose of this method is to unwrap InvocationTargetException,

    // in order to avoid throwing UndeclaredThrowableException for

    // declared exceptions.

    //

    // When calling method.invoke(), any exception thrown by the invoked

    // method will be wrapped in InvocationTargetException. If we don't

    // unwrap this exception, the proxy will always throw

    // UndeclaredThrowableException, even for runtime exceptions.

    //

    private Object call(final Object obj, final Method m,

            final Object[] args)

        throws Throwable {

        try {

            return m.invoke(obj,args);

        } catch (InvocationTargetException x) {

            final Throwable xx = x.getTargetException();

            if (xx == null) throw x;

            else throw xx;

        }

    }

    /**

     * Route add/remove notification listener to the event client.

     **/

    private Object invokeBroadcasterMethod(Object proxy, Method method,

                                           Object[] args) throws Exception {

        final String methodName = method.getName();

        final int nargs = (args == null) ? 0 : args.length;

        if (nargs < 1) {

           final String msg =

                    "Bad arg count: " + nargs;

           throw new IllegalArgumentException(msg);

        }

        final ObjectName mbean = (ObjectName) args[0];

        // in a subnamespace. We fail here because we know this will not

        // work.

        //

        // Note that if the wrapped MBeanServerConnection points to a an

        // earlier agent (JDK 1.6 or earlier), then the EventClient will

        // be null (we can't use the event service with earlier JDKs).

        //

        // an earlier version, in which case it shouldn't contain any namespace.

        //

        // clearly an error case.

        //

            final String domain = mbean.getDomain();

            if (index > -1 && index <

                    (domain.length()-NAMESPACE_SEPARATOR_LENGTH)) {

                throw new UnsupportedOperationException(method.getName()+

                        " on namespace "+domain.substring(0,index+

                        NAMESPACE_SEPARATOR_LENGTH));

            }

        }

        if (methodName.equals("addNotificationListener")) {

            /* The various throws of IllegalArgumentException here

               should not happen, since we know what the methods in

               NotificationBroadcaster and NotificationEmitter

               are.  */

            if (nargs != 4) {

                final String msg =

                    "Bad arg count to addNotificationListener: " + nargs;

                throw new IllegalArgumentException(msg);

            }

            /* Other inconsistencies will produce ClassCastException

               below.  */

            final NotificationListener listener = (NotificationListener) args[1];

            final NotificationFilter filter = (NotificationFilter) args[2];

            final Object handback = args[3];

                // general case

            } else {

                // deprecated case. Only works for mbean in local namespace.

                connection.addNotificationListener(mbean,listener,filter,

                                                   handback);

            }

            return null;

        } else if (methodName.equals("removeNotificationListener")) {

            /* NullPointerException if method with no args, but that

               shouldn't happen because removeNL does have args.  */

            NotificationListener listener = (NotificationListener) args[1];

            switch (nargs) {

            case 2:

                    // general case

                } else {

                    // deprecated case. Only works for mbean in local namespace.

                    connection.removeNotificationListener(mbean, listener);

                }

                return null;

            case 4:

                NotificationFilter filter = (NotificationFilter) args[2];

                Object handback = args[3];

                                                      listener,

                                                      filter,

                                                      handback);

                } else {

                    connection.removeNotificationListener(mbean,

                                                      listener,

                                                      filter,

                                                      handback);

                }

                return null;

            default:

                final String msg =

                    "Bad arg count to removeNotificationListener: " + nargs;

                throw new IllegalArgumentException(msg);

            }

        } else {

            throw new IllegalArgumentException("Bad method name: " +

                                               methodName);

        }

    }

    private boolean shouldDoLocally(Object proxy, Method method) {

        final String methodName = method.getName();

        if ((methodName.equals("hashCode") || methodName.equals("toString"))

            && method.getParameterTypes().length == 0

                && isLocal(proxy, method))

            return true;

        if (methodName.equals("equals")

            && Arrays.equals(method.getParameterTypes(),

                new Class[] {Object.class})

                && isLocal(proxy, method))

            return true;

        return false;

    }

    private Object doLocally(Object proxy, Method method, Object[] args) {

        final String methodName = method.getName();

        if (methodName.equals("equals")) {

            if (this == args[0]) {

                return true;

            }

            if (!(args[0] instanceof Proxy)) {

                return false;

            }

            final InvocationHandler ihandler =

                Proxy.getInvocationHandler(args[0]);

            if (ihandler == null ||

                !(ihandler instanceof EventClientConnection)) {

                return false;

            }

            final EventClientConnection handler =

                (EventClientConnection)ihandler;

            return connection.equals(handler.connection) &&

                proxy.getClass().equals(args[0].getClass());

        } else if (methodName.equals("hashCode")) {

            return connection.hashCode();

        }

        throw new RuntimeException("Unexpected method name: " + methodName);

    }

    private static boolean isLocal(Object proxy, Method method) {

        final Class<?>[] interfaces = proxy.getClass().getInterfaces();

        if(interfaces == null) {

            return true;

        }

        final String methodName = method.getName();

        final Class<?>[] params = method.getParameterTypes();

        for (Class<?> intf : interfaces) {

            try {

                intf.getMethod(methodName, params);

                return false; // found method in one of our interfaces

            } catch (NoSuchMethodException nsme) {

                // OK.

            }

        }

        return true;  // did not find in any interface

    }

    /**

     * Return the EventClient used by this object. Can be null if the

     * remote VM is of an earlier JDK version which doesn't have the

     * event service.<br>

     * This method will invoke the event client factory the first time

     * it is called.

     **/

    public final EventClient getEventClient()  {

        if (initialized) return client;

        try {

            if (!lock.tryLock(TRYLOCK_TIMEOUT,TimeUnit.SECONDS))

                throw new IllegalStateException("can't acquire lock");

            try {

                client = eventClientFactory.call();

                initialized = true;

            } finally {

                lock.unlock();

            }

        } catch (RuntimeException x) {

            throw x;

        } catch (Exception x) {

            throw new IllegalStateException("Can't create EventClient: "+x,x);

        }

        return client;

    }

    /**

     * Returns an event client for the wrapped {@code MBeanServerConnection}.

     * This is the method invoked by the default event client factory.

     * @param connection the  wrapped {@code MBeanServerConnection}.

     **/

    protected EventClient createEventClient(MBeanServerConnection connection)

        throws Exception {

        final ObjectName name =

           EventClientDelegate.OBJECT_NAME;

        if (connection.isRegistered(name)) {

            return new EventClient(connection);

        }

        return null;

    }

    /**

     * Creates a new {@link MBeanServerConnection} that goes through an

     * {@link EventClient} to receive/subscribe to notifications.

     * @param connection the underlying {@link MBeanServerConnection}.

     *        The given <code>connection</code> shouldn't be already

     *        using an {@code EventClient}.

     * @param eventClientFactory a factory object that will be invoked

     *        to create an {@link EventClient} when needed.

     *        The {@code EventClient} is created lazily, when it is needed

     *        for the first time. If null, a default factory will be used

     *        (see {@link #createEventClient}).

     * @return the

     **/

    public static MBeanServerConnection getEventConnectionFor(

                    MBeanServerConnection connection,

                    Callable<EventClient> eventClientFactory) {

        // if c already uses an EventClient no need to create a new one.

        //

        if (connection instanceof EventClientFactory

            && eventClientFactory != null)

            throw new IllegalArgumentException("connection already uses EventClient");

        if (connection instanceof EventClientFactory)

            return connection;

        // create a new proxy using an event client.

        //

        if (LOG.isLoggable(Level.FINE))

            LOG.fine("Creating EventClient for: "+connection);

        return newProxyInstance(connection,

                MBeanServerConnection.class,

                eventClientFactory);

    }

    private Object invokeEventClientSubscriberMethod(Object proxy,

            Method method, Object[] args) throws Throwable {

        return call(this,method,args);

    }

    // Maximum lock timeout in seconds. Obviously arbitrary.

    //

    private final static short TRYLOCK_TIMEOUT = 3;

    private final MBeanServerConnection connection;

    private final Callable<EventClient> eventClientFactory;

    private final Lock lock;

    private volatile EventClient client = null;

    private volatile boolean initialized = false;

}