/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.tomcat.util.modeler;


import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import javax.management.Attribute;
import javax.management.AttributeChangeNotification;
import javax.management.AttributeList;
import javax.management.AttributeNotFoundException;
import javax.management.DynamicMBean;
import javax.management.InstanceNotFoundException;
import javax.management.InvalidAttributeValueException;
import javax.management.ListenerNotFoundException;
import javax.management.MBeanException;
import javax.management.MBeanInfo;
import javax.management.MBeanNotificationInfo;
import javax.management.MBeanRegistration;
import javax.management.MBeanServer;
import javax.management.Notification;
import javax.management.NotificationFilter;
import javax.management.NotificationListener;
import javax.management.ObjectName;
import javax.management.ReflectionException;
import javax.management.RuntimeErrorException;
import javax.management.RuntimeOperationsException;
import javax.management.modelmbean.InvalidTargetObjectTypeException;
import javax.management.modelmbean.ModelMBeanNotificationBroadcaster;

import org.apache.juli.logging.Log;
import org.apache.juli.logging.LogFactory;
import org.apache.tomcat.util.res.StringManager;

/*
 * Changes from commons.modeler:
 *
 *  - use DynamicMBean
 *  - remove methods not used in tomcat and redundant/not very generic
 *  - must be created from the ManagedBean - I don't think there were any direct
 *    uses, but now it is required.
 *  - some of the gratuitous flexibility removed - instead this is more predictive and
 *    strict with the use cases.
 *  - all Method and metadata is stored in ManagedBean. BaseModelBMean and ManagedBean act
 *    like Object and Class.
 *  - setModelMBean is no longer called on resources ( not used in tomcat )
 *  - no caching of Methods for now - operations and setters are not called repeatedly in most
 *  management use cases. Getters shouldn't be called very frequently either - and even if they
 *  are, the overhead of getting the method should be small compared with other JMX costs ( RMI, etc ).
 *  We can add getter cache if needed.
 *  - removed unused constructor, fields
 *
 *  TODO:
 *   - clean up catalina.mbeans, stop using weird inheritance
 */

/**
 * <p>
 * Basic implementation of the <code>DynamicMBean</code> interface, which supports the minimal requirements of the
 * interface contract.
 * </p>
 * <p>
 * This can be used directly to wrap an existing java bean, or inside a mlet or anywhere an MBean would be used.
 * <p>
 * Limitations:
 * <ul>
 * <li>Only managed resources of type <code>objectReference</code> are supported.</li>
 * <li>Caching of attribute values and operation results is not supported. All calls to <code>invoke()</code> are
 * immediately executed.</li>
 * <li>Persistence of MBean attributes and operations is not supported.</li>
 * <li>All classes referenced as attribute types, operation parameters, or operation return values must be one of the
 * following:
 * <ul>
 * <li>One of the Java primitive types (boolean, byte, char, double, float, integer, long, short). Corresponding value
 * will be wrapped in the appropriate wrapper class automatically.</li>
 * <li>Operations that return no value should declare a return type of <code>void</code>.</li>
 * </ul>
 * <li>Attribute caching is not supported</li>
 * </ul>
 */
public class BaseModelMBean implements DynamicMBean, MBeanRegistration, ModelMBeanNotificationBroadcaster {

    private static final Log log = LogFactory.getLog(BaseModelMBean.class);
    private static final StringManager sm = StringManager.getManager(BaseModelMBean.class);

    // ----------------------------------------------------- Instance Variables

    protected ObjectName oname = null;

    /**
     * Notification broadcaster for attribute changes.
     */
    protected BaseNotificationBroadcaster attributeBroadcaster = null;

    /**
     * Notification broadcaster for general notifications.
     */
    protected BaseNotificationBroadcaster generalBroadcaster = null;

    /**
     * Metadata for the mbean instance.
     */
    protected ManagedBean managedBean = null;

    /**
     * The managed resource this MBean is associated with (if any).
     */
    protected Object resource = null;

    // --------------------------------------------------- DynamicMBean Methods
    // TODO: move to ManagedBean
    static final Object[] NO_ARGS_PARAM = new Object[0];

    protected String resourceType = null;

    // key: operation val: invoke method
    // private Hashtable invokeAttMap=new Hashtable();

    @Override
    public Object getAttribute(String name) throws AttributeNotFoundException, MBeanException, ReflectionException {
        // Validate the input parameters
        if (name == null) {
            throw new RuntimeOperationsException(
                    new IllegalArgumentException(sm.getString("baseModelMBean.nullAttributeName")),
                    sm.getString("baseModelMBean.nullAttributeName"));
        }

        if ((resource instanceof DynamicMBean) && !(resource instanceof BaseModelMBean)) {
            return ((DynamicMBean) resource).getAttribute(name);
        }

        Method m = managedBean.getGetter(name, this, resource);
        Object result;
        try {
            Class<?> declaring = m.getDeclaringClass();
            // workaround for catalina weird mbeans - the declaring class is BaseModelMBean.
            // but this is the catalina class.
            if (declaring.isAssignableFrom(this.getClass())) {
                result = m.invoke(this, NO_ARGS_PARAM);
            } else {
                result = m.invoke(resource, NO_ARGS_PARAM);
            }
        } catch (InvocationTargetException e) {
            Throwable t = e.getTargetException();
            if (t == null) {
                t = e;
            }
            if (t instanceof RuntimeException) {
                throw new RuntimeOperationsException((RuntimeException) t,
                        sm.getString("baseModelMBean.invokeError", name));
            } else if (t instanceof Error) {
                throw new RuntimeErrorException((Error) t, sm.getString("baseModelMBean.invokeError", name));
            } else {
                throw new MBeanException(e, sm.getString("baseModelMBean.invokeError", name));
            }
        } catch (Exception e) {
            throw new MBeanException(e, sm.getString("baseModelMBean.invokeError", name));
        }

        // Return the results of this method invocation
        return result;
    }


    @Override
    public AttributeList getAttributes(String[] names) {

        // Validate the input parameters
        if (names == null) {
            throw new RuntimeOperationsException(
                    new IllegalArgumentException(sm.getString("baseModelMBean.nullAttributeNameList")),
                    sm.getString("baseModelMBean.nullAttributeNameList"));
        }

        // Prepare our response, eating all exceptions
        AttributeList response = new AttributeList();
        for (String name : names) {
            try {
                response.add(new Attribute(name, getAttribute(name)));
            } catch (Exception e) {
                // Not having a particular attribute in the response
                // is the indication of a getter problem
            }
        }
        return response;

    }

    public void setManagedBean(ManagedBean managedBean) {
        this.managedBean = managedBean;
    }

    /**
     * Return the <code>MBeanInfo</code> object for this MBean.
     */
    @Override
    public MBeanInfo getMBeanInfo() {
        return managedBean.getMBeanInfo();
    }


    /**
     * {@inheritDoc}
     * <p>
     * <strong>IMPLEMENTATION NOTE</strong> - This implementation will attempt to invoke this method on the MBean
     * itself, or (if not available) on the managed resource object associated with this MBean.
     * </p>
     */
    @Override
    public Object invoke(String name, Object[] params, String[] signature) throws MBeanException, ReflectionException {
        if ((resource instanceof DynamicMBean) && !(resource instanceof BaseModelMBean)) {
            return ((DynamicMBean) resource).invoke(name, params, signature);
        }

        // Validate the input parameters
        if (name == null) {
            throw new RuntimeOperationsException(
                    new IllegalArgumentException(sm.getString("baseModelMBean.nullMethodName")),
                    sm.getString("baseModelMBean.nullMethodName"));
        }

        if (log.isTraceEnabled()) {
            log.trace("Invoke " + name);
        }

        Method method = managedBean.getInvoke(name, params, signature, this, resource);

        // Invoke the selected method on the appropriate object
        Object result;
        try {
            if (method.getDeclaringClass().isAssignableFrom(this.getClass())) {
                result = method.invoke(this, params);
            } else {
                result = method.invoke(resource, params);
            }
        } catch (InvocationTargetException e) {
            Throwable t = e.getTargetException();
            log.error(sm.getString("baseModelMBean.invokeError", name), t);
            if (t == null) {
                t = e;
            }
            if (t instanceof RuntimeException) {
                throw new RuntimeOperationsException((RuntimeException) t,
                        sm.getString("baseModelMBean.invokeError", name));
            } else if (t instanceof Error) {
                throw new RuntimeErrorException((Error) t, sm.getString("baseModelMBean.invokeError", name));
            } else {
                throw new MBeanException((Exception) t, sm.getString("baseModelMBean.invokeError", name));
            }
        } catch (Exception e) {
            log.error(sm.getString("baseModelMBean.invokeError", name), e);
            throw new MBeanException(e, sm.getString("baseModelMBean.invokeError", name));
        }

        // Return the results of this method invocation
        return result;

    }

    static Class<?> getAttributeClass(String signature) throws ReflectionException {
        if (signature.equals(Boolean.TYPE.getName())) {
            return Boolean.TYPE;
        } else if (signature.equals(Byte.TYPE.getName())) {
            return Byte.TYPE;
        } else if (signature.equals(Character.TYPE.getName())) {
            return Character.TYPE;
        } else if (signature.equals(Double.TYPE.getName())) {
            return Double.TYPE;
        } else if (signature.equals(Float.TYPE.getName())) {
            return Float.TYPE;
        } else if (signature.equals(Integer.TYPE.getName())) {
            return Integer.TYPE;
        } else if (signature.equals(Long.TYPE.getName())) {
            return Long.TYPE;
        } else if (signature.equals(Short.TYPE.getName())) {
            return Short.TYPE;
        } else {
            try {
                ClassLoader cl = Thread.currentThread().getContextClassLoader();
                if (cl != null) {
                    return cl.loadClass(signature);
                }
            } catch (ClassNotFoundException ignore) {
                // Ignore
            }
            try {
                return Class.forName(signature);
            } catch (ClassNotFoundException e) {
                throw new ReflectionException(e, sm.getString("baseModelMBean.cnfeForSignature", signature));
            }
        }
    }

    @Override
    public void setAttribute(Attribute attribute)
            throws AttributeNotFoundException, MBeanException, ReflectionException {
        if (log.isTraceEnabled()) {
            log.trace("Setting attribute " + this + " " + attribute);
        }

        if ((resource instanceof DynamicMBean) && !(resource instanceof BaseModelMBean)) {
            try {
                ((DynamicMBean) resource).setAttribute(attribute);
            } catch (InvalidAttributeValueException e) {
                throw new MBeanException(e);
            }
            return;
        }

        // Validate the input parameters
        if (attribute == null) {
            throw new RuntimeOperationsException(
                    new IllegalArgumentException(sm.getString("baseModelMBean.nullAttribute")),
                    sm.getString("baseModelMBean.nullAttribute"));
        }

        String name = attribute.getName();
        Object value = attribute.getValue();

        if (name == null) {
            throw new RuntimeOperationsException(
                    new IllegalArgumentException(sm.getString("baseModelMBean.nullAttributeName")),
                    sm.getString("baseModelMBean.nullAttributeName"));
        }

        Object oldValue = null;
        // if( getAttMap.get(name) != null )
        // oldValue=getAttribute( name );

        Method m = managedBean.getSetter(name, this, resource);

        try {
            if (m.getDeclaringClass().isAssignableFrom(this.getClass())) {
                m.invoke(this, value);
            } else {
                m.invoke(resource, value);
            }
        } catch (InvocationTargetException e) {
            Throwable t = e.getTargetException();
            if (t == null) {
                t = e;
            }
            if (t instanceof RuntimeException) {
                throw new RuntimeOperationsException((RuntimeException) t,
                        sm.getString("baseModelMBean.invokeError", name));
            } else if (t instanceof Error) {
                throw new RuntimeErrorException((Error) t, sm.getString("baseModelMBean.invokeError", name));
            } else {
                throw new MBeanException(e, sm.getString("baseModelMBean.invokeError", name));
            }
        } catch (Exception e) {
            log.error(sm.getString("baseModelMBean.invokeError", name), e);
            throw new MBeanException(e, sm.getString("baseModelMBean.invokeError", name));
        }
        try {
            sendAttributeChangeNotification(new Attribute(name, oldValue), attribute);
        } catch (Exception e) {
            log.error(sm.getString("baseModelMBean.notificationError", name), e);
        }
        // attributes.put( name, value );
        // if( source != null ) {
        // // this mbean is associated with a source - maybe we want to persist
        // source.updateField(oname, name, value);
        // }
    }

    @Override
    public String toString() {
        if (resource == null) {
            return "BaseModelMbean[" + resourceType + "]";
        }
        return resource.toString();
    }

    @Override
    public AttributeList setAttributes(AttributeList attributes) {
        AttributeList response = new AttributeList();

        // Validate the input parameters
        if (attributes == null) {
            return response;
        }

        // Prepare and return our response, eating all exceptions
        String[] names = new String[attributes.size()];
        int n = 0;
        for (Object attribute : attributes) {
            Attribute item = (Attribute) attribute;
            names[n++] = item.getName();
            try {
                setAttribute(item);
            } catch (Exception ignore) {
                // Ignore all exceptions
            }
        }

        return getAttributes(names);

    }


    // ----------------------------------------------------- ModelMBean Methods


    /**
     * Get the instance handle of the object against which we execute all methods in this ModelMBean management
     * interface.
     *
     * @return the backend managed object
     *
     * @exception InstanceNotFoundException        if the managed resource object cannot be found
     * @exception InvalidTargetObjectTypeException if the managed resource object is of the wrong type
     * @exception MBeanException                   if the initializer of the object throws an exception
     * @exception RuntimeOperationsException       if the managed resource or the resource type is <code>null</code> or
     *                                                 invalid
     */
    public Object getManagedResource() throws InstanceNotFoundException, InvalidTargetObjectTypeException,
            MBeanException, RuntimeOperationsException {

        if (resource == null) {
            throw new RuntimeOperationsException(
                    new IllegalArgumentException(sm.getString("baseModelMBean.nullResource")),
                    sm.getString("baseModelMBean.nullResource"));
        }

        return resource;

    }


    /**
     * Set the instance handle of the object against which we will execute all methods in this ModelMBean management
     * interface. The caller can provide the mbean instance or the object name to the resource, if needed.
     *
     * @param resource The resource object to be managed
     * @param type     The type of reference for the managed resource ("ObjectReference", "Handle", "IOR", "EJBHandle",
     *                     or "RMIReference")
     *
     * @exception InstanceNotFoundException  if the managed resource object cannot be found
     * @exception MBeanException             if the initializer of the object throws an exception
     * @exception RuntimeOperationsException if the managed resource or the resource type is <code>null</code> or
     *                                           invalid
     */
    public void setManagedResource(Object resource, String type)
            throws InstanceNotFoundException, MBeanException, RuntimeOperationsException {
        if (resource == null) {
            throw new RuntimeOperationsException(
                    new IllegalArgumentException(sm.getString("baseModelMBean.nullResource")),
                    sm.getString("baseModelMBean.nullResource"));
        }

        this.resource = resource;
        this.resourceType = resource.getClass().getName();
    }


    // ------------------------------ ModelMBeanNotificationBroadcaster Methods

    @Override
    public void addAttributeChangeNotificationListener(NotificationListener listener, String name, Object handback)
            throws IllegalArgumentException {

        if (listener == null) {
            throw new IllegalArgumentException(sm.getString("baseModelMBean.nullListener"));
        }
        if (attributeBroadcaster == null) {
            attributeBroadcaster = new BaseNotificationBroadcaster();
        }

        if (log.isTraceEnabled()) {
            log.trace("addAttributeNotificationListener " + listener);
        }

        BaseAttributeFilter filter = new BaseAttributeFilter(name);
        attributeBroadcaster.addNotificationListener(listener, filter, handback);

    }


    @Override
    public void removeAttributeChangeNotificationListener(NotificationListener listener, String name)
            throws ListenerNotFoundException {

        if (listener == null) {
            throw new IllegalArgumentException(sm.getString("baseModelMBean.nullListener"));
        }

        // FIXME - currently this removes *all* notifications for this listener
        if (attributeBroadcaster != null) {
            attributeBroadcaster.removeNotificationListener(listener);
        }

    }


    @Override
    public void sendAttributeChangeNotification(AttributeChangeNotification notification)
            throws MBeanException, RuntimeOperationsException {

        if (notification == null) {
            throw new RuntimeOperationsException(
                    new IllegalArgumentException(sm.getString("baseModelMBean.nullNotification")),
                    sm.getString("baseModelMBean.nullNotification"));
        }
        if (attributeBroadcaster == null) {
            return; // This means there are no registered listeners
        }
        if (log.isTraceEnabled()) {
            log.trace("AttributeChangeNotification " + notification);
        }
        attributeBroadcaster.sendNotification(notification);

    }


    @Override
    public void sendAttributeChangeNotification(Attribute oldValue, Attribute newValue)
            throws MBeanException, RuntimeOperationsException {

        // Calculate the class name for the change notification
        String type;
        if (newValue.getValue() != null) {
            type = newValue.getValue().getClass().getName();
        } else if (oldValue.getValue() != null) {
            type = oldValue.getValue().getClass().getName();
        } else {
            return; // Old and new are both null == no change
        }

        AttributeChangeNotification notification = new AttributeChangeNotification(this, 1, System.currentTimeMillis(),
                "Attribute value has changed", oldValue.getName(), type, oldValue.getValue(), newValue.getValue());
        sendAttributeChangeNotification(notification);

    }


    @Override
    public void sendNotification(Notification notification) throws MBeanException, RuntimeOperationsException {

        if (notification == null) {
            throw new RuntimeOperationsException(
                    new IllegalArgumentException(sm.getString("baseModelMBean.nullNotification")),
                    sm.getString("baseModelMBean.nullNotification"));
        }
        if (generalBroadcaster == null) {
            return; // This means there are no registered listeners
        }
        generalBroadcaster.sendNotification(notification);

    }


    @Override
    public void sendNotification(String message) throws MBeanException, RuntimeOperationsException {

        if (message == null) {
            throw new RuntimeOperationsException(
                    new IllegalArgumentException(sm.getString("baseModelMBean.nullMessage")),
                    sm.getString("baseModelMBean.nullMessage"));
        }
        Notification notification = new Notification("jmx.modelmbean.generic", this, 1, message);
        sendNotification(notification);

    }


    // ---------------------------------------- NotificationBroadcaster Methods


    @Override
    public void addNotificationListener(NotificationListener listener, NotificationFilter filter, Object handback)
            throws IllegalArgumentException {

        if (listener == null) {
            throw new IllegalArgumentException(sm.getString("baseModelMBean.nullListener"));
        }

        if (log.isTraceEnabled()) {
            log.trace("addNotificationListener " + listener);
        }

        if (generalBroadcaster == null) {
            generalBroadcaster = new BaseNotificationBroadcaster();
        }
        generalBroadcaster.addNotificationListener(listener, filter, handback);

        // We'll send the attribute change notifications to all listeners ( who care )
        // The normal filtering can be used.
        // The problem is that there is no other way to add attribute change listeners
        // to a model mbean ( AFAIK ). I suppose the spec should be fixed.
        if (attributeBroadcaster == null) {
            attributeBroadcaster = new BaseNotificationBroadcaster();
        }

        if (log.isTraceEnabled()) {
            log.trace("addAttributeNotificationListener " + listener);
        }

        attributeBroadcaster.addNotificationListener(listener, filter, handback);
    }


    @Override
    public MBeanNotificationInfo[] getNotificationInfo() {

        // Acquire the set of application notifications
        MBeanNotificationInfo[] current = getMBeanInfo().getNotifications();
        MBeanNotificationInfo[] response = new MBeanNotificationInfo[current.length + 2];
        // Descriptor descriptor = null;

        // Fill in entry for general notifications
        // descriptor = new DescriptorSupport
        // (new String[] { "name=GENERIC",
        // "descriptorType=notification",
        // "log=T",
        // "severity=5",
        // "displayName=jmx.modelmbean.generic" });
        response[0] = new MBeanNotificationInfo(new String[] { "jmx.modelmbean.generic" }, "GENERIC",
                "Text message notification from the managed resource");
        // descriptor);

        // Fill in entry for attribute change notifications
        // descriptor = new DescriptorSupport
        // (new String[] { "name=ATTRIBUTE_CHANGE",
        // "descriptorType=notification",
        // "log=T",
        // "severity=5",
        // "displayName=jmx.attribute.change" });
        response[1] = new MBeanNotificationInfo(new String[] { "jmx.attribute.change" }, "ATTRIBUTE_CHANGE",
                "Observed MBean attribute value has changed");
        // descriptor);

        // Copy remaining notifications as reported by the application
        System.arraycopy(current, 0, response, 2, current.length);
        return response;

    }


    @Override
    public void removeNotificationListener(NotificationListener listener) throws ListenerNotFoundException {

        if (listener == null) {
            throw new IllegalArgumentException(sm.getString("baseModelMBean.nullListener"));
        }

        if (generalBroadcaster != null) {
            generalBroadcaster.removeNotificationListener(listener);
        }

        if (attributeBroadcaster != null) {
            attributeBroadcaster.removeNotificationListener(listener);
        }
    }


    public String getModelerType() {
        return resourceType;
    }

    /**
     * @return the fully qualified Java class name of the managed object for this MBean
     */
    public String getClassName() {
        return getModelerType();
    }

    public ObjectName getJmxName() {
        return oname;
    }

    public String getObjectName() {
        if (oname != null) {
            return oname.toString();
        } else {
            return null;
        }
    }


    // -------------------- Registration --------------------
    // XXX We can add some method patterns here- like setName() and
    // setDomain() for code that doesn't implement the Registration

    @Override
    public ObjectName preRegister(MBeanServer server, ObjectName name) throws Exception {
        if (log.isTraceEnabled()) {
            log.trace("preRegister " + resource + " " + name);
        }
        oname = name;
        if (resource instanceof MBeanRegistration) {
            oname = ((MBeanRegistration) resource).preRegister(server, name);
        }
        return oname;
    }

    @Override
    public void postRegister(Boolean registrationDone) {
        if (resource instanceof MBeanRegistration) {
            ((MBeanRegistration) resource).postRegister(registrationDone);
        }
    }

    @Override
    public void preDeregister() throws Exception {
        if (resource instanceof MBeanRegistration) {
            ((MBeanRegistration) resource).preDeregister();
        }
    }

    @Override
    public void postDeregister() {
        if (resource instanceof MBeanRegistration) {
            ((MBeanRegistration) resource).postDeregister();
        }
    }
}