/*
 * 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.  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 javax.management.namespace;

import java.io.IOException;
import java.util.Set;
import javax.management.MBeanServer;
import javax.management.MBeanServerConnection;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;

/**
 * This class makes it possible to navigate easily within a hierarchical
 * namespace view.
 *
 * <pre>
 * MBeanServerConnnection rootConnection = ...;
 *
 * // create a view at the local root of the namespace hierarchy.
 * //
 * JMXNamespaceView view = new JMXNamespaceView(rootConnection);
 *
 * // list all top level namespaces
 * String[] list = view.list();
 *
 * // select one namespace from the list
 * String whereToGo = ... ;
 *
 * // go down to the selected namespace:
 * view = view.down(whereToGo);
 * System.out.println("I am now in: " + view.where());
 * System.out.println("I can see these MBeans:" +
 *    view.getMBeanServerConnection().queryNames(null,null));
 *
 * // list sub namespaces in current view ('whereToGo')
 * list = view.list();
 * System.out.println("Here are the sub namespaces of "+view.where()+": "+
 *                    Arrays.toString(list));
 *
 * // go up one level
 * view = view.up();
 * System.out.println("I am now back to: " +
 *    (view.isRoot() ? "root namespace" : view.where()));
 * </pre>
 * @since 1.7
 */
public class JMXNamespaceView {

    private static final ObjectName ALL_NAMESPACES;
    static {
        try {
            ALL_NAMESPACES = ObjectName.getInstance("*" +
                    JMXNamespaces.NAMESPACE_SEPARATOR + ":"+
                    JMXNamespace.TYPE_ASSIGNMENT);
        } catch (MalformedObjectNameException x) {
            throw new ExceptionInInitializerError(x);
        }
    }
    private static final int NAMESPACE_SEPARATOR_LENGTH =
            JMXNamespaces.NAMESPACE_SEPARATOR.length();

    private final JMXNamespaceView parent;
    private final MBeanServerConnection here;
    private final String where;

    private static MBeanServerConnection checkRoot(MBeanServerConnection root) {
        if (root == null)
            throw new IllegalArgumentException(
                    "namespaceRoot: null is not a valid value");
        return root;
    }

    /**
     * Creates a view at the top of a JMX namespace hierarchy.
     * @param namespaceRoot The {@code MBeanServerConnection} at the
     *        top of the hierarchy.
     */
    public JMXNamespaceView(MBeanServerConnection namespaceRoot) {
        this(null,checkRoot(namespaceRoot),"");
    }

    // This constructor should remain private. A user can only create
    // JMXNamespaceView at the top of the hierarchy.
    // JMXNamespaceView sub nodes are created by their parent nodes.
    private JMXNamespaceView(JMXNamespaceView parent,
            MBeanServerConnection here, String where) {
        this.parent = parent;
        this.here   = here;
        this.where  = where;
    }

    /**
     * Returns the path leading to the namespace in this view, from
     * the top of the hierarchy.
     * @return The path to the namespace in this view.
     */
    public String where() {
        return where;
    }

    /**
     * Lists all direct sub namespaces in this view.  The returned strings
     * do not contain the {@code //} separator.
     *
     * @return A list of direct sub name spaces accessible from this
     *         namespace.
     * @throws IOException if the attempt to list the namespaces fails because
     * of a communication problem.
     */
    public String[] list() throws IOException {
        final Set<ObjectName> names =
                here.queryNames(ALL_NAMESPACES,null);
        final String[] res = new String[names.size()];
        int i = 0;
        for (ObjectName dirName : names) {
            final String dir = dirName.getDomain();
            res[i++]=dir.substring(0,dir.length()-NAMESPACE_SEPARATOR_LENGTH);
        }
        return res;
    }

    /**
     * Go down into a sub namespace.
     * @param namespace the namespace to go down to.  It can contain one or
     * more {@code //} separators, to traverse intermediate namespaces, but
     * it must not begin or end with {@code //} or contain an empty
     * intermediate namespace.  If it is the empty string, then {@code this} is
     * returned.
     * @return A view of the named sub namespace.
     * @throws IllegalArgumentException if the {@code namespace} begins or
     * ends with {@code //}.
     */
    public JMXNamespaceView down(String namespace) {
        if (namespace.equals("")) return this;
        if (namespace.startsWith(JMXNamespaces.NAMESPACE_SEPARATOR))
            throw new IllegalArgumentException(namespace+": can't start with "+
                    JMXNamespaces.NAMESPACE_SEPARATOR);

        // This is a convenience to handle paths like xxx//yyy
        final String[] elts =
                namespace.split(JMXNamespaces.NAMESPACE_SEPARATOR);

        // Go down the path, creating all sub namespaces along the way.
        // Usually there will be a single element in the given namespace
        // name, but we don't want to forbid things like
        // down("xxx//yyy/www");
        //
        JMXNamespaceView previous = this;
        String cursor = where;
        for (String elt : elts) {
            // empty path elements are not allowed. It means we
            // had something like "xxx////yyy"
            if (elt.equals(""))
                throw new IllegalArgumentException(namespace+
                        ": invalid path element");

            // compute the "where" for the child.
            cursor = JMXNamespaces.concat(cursor, elt);

            // create the child...
            final JMXNamespaceView next =
                    makeJMXNamespaceView(root(), previous, cursor);

            // the current child will be the parent of the next child...
            previous = next;
        }

        // We return the last child that was created.
        return previous;
    }

    /**
     * Go back up one level. If this view is at the root of the
     * hierarchy, returns {@code null}.
     * @return A view of the parent namespace, or {@code null} if we're at
     *         the root of the hierarchy.
     */
    public JMXNamespaceView up() {
        return parent;
    }

    /**
     * Tells whether this view is at the root of the hierarchy.
     * @return {@code true} if this view is at the root of the hierachy.
     */
    public boolean isRoot() {
        return parent == null;
    }

    /**
     * Returns the view at the root of the hierarchy.
     * If we are already at the root, this is {@code this}.
     * @return the view at the root of the hierarchy.
     */
    public JMXNamespaceView root() {
        if (parent == null) return this;
        return parent.root();
    }

    /**
     * A MBeanServerConnection to the namespace shown by this view.
     * This is what would have been obtained by doing:
     * <pre>
     *   JMX.narrowToNamespace(this.root().getMBeanServerConnection(),
     *       this.where());
     * </pre>
     * @return A MBeanServerConnection to the namespace shown by this view.
     */
    public MBeanServerConnection getMBeanServerConnection() {
        return here;
    }

    /**
     * <p>Get the name of the JMXNamespaceMBean handling the namespace shown by
     * this view, relative to the root of the hierarchy.  If we are at the root
     * of the hierarchy, this method returns {@code null}.</p>
     *
     * <p>You can use this method to make a proxy for the JMXNamespaceMBean
     * as follows:</p>
     *
     * <pre>
     * JMXNamespaceView view = ...;
     * ObjectName namespaceMBeanName = view.getJMXNamespaceMBeanName();
     * JMXNamespaceMBean namespaceMBean = JMX.newMBeanProxy(
     *     view.root().getMBeanServerConnection(), namespaceMBeanName,
     *     JMXNamespaceMBean.class);
     * </pre>
     *
     * @return The name of the {@code JMXNamespaceMBean} handling the namespace
     *         shown by this view, or {@code null}.
     */
    public ObjectName getJMXNamespaceMBeanName() {
        if (parent == null)
            return null;
        else
            return JMXNamespaces.getNamespaceObjectName(where);
    }

    @Override
    public int hashCode() {
        return where.hashCode();
    }

    /**
     * Returns true if this object is equal to the given object.  The
     * two objects are equal if the other object is also a {@code
     * JMXNamespaceView} and both objects have the same {@linkplain #root root}
     * MBeanServerConnection and the same {@linkplain #where path}.
     * @param o the other object to compare to.
     * @return true if both objects are equal.
     */
    @Override
    public boolean equals(Object o) {
        if (o==this) return true;
        if (! (o instanceof JMXNamespaceView)) return false;
        if (!where.equals(((JMXNamespaceView)o).where)) return false;
        return root().getMBeanServerConnection().equals(
                ((JMXNamespaceView)o).root().getMBeanServerConnection());
    }

    private JMXNamespaceView makeJMXNamespaceView(final JMXNamespaceView root,
            final JMXNamespaceView directParent, final String pathFromRoot) {
        if (pathFromRoot.equals("")) return root;

        return new JMXNamespaceView(directParent,
                narrowToNamespace(root.getMBeanServerConnection(),
                pathFromRoot),pathFromRoot);
    }

    private MBeanServerConnection narrowToNamespace(MBeanServerConnection root,
            String path) {
        if (root instanceof MBeanServer)
            return JMXNamespaces.narrowToNamespace((MBeanServer)root, path);
        return JMXNamespaces.narrowToNamespace(root, path);
    }

}