/*
 * 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 com.sun.jmx.interceptor;

import com.sun.jmx.defaults.JmxProperties;
import com.sun.jmx.mbeanserver.MBeanInstantiator;
import com.sun.jmx.mbeanserver.Repository;
import com.sun.jmx.mbeanserver.Util;
import com.sun.jmx.namespace.NamespaceInterceptor;

import java.util.Queue;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.management.MBeanServer;
import javax.management.MBeanServerDelegate;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
import javax.management.namespace.JMXDomain;
import javax.management.namespace.JMXNamespace;
import static javax.management.namespace.JMXNamespaces.NAMESPACE_SEPARATOR;

/**
 * A dispatcher that dispatches to NamespaceInterceptors.
 * <p><b>
 * This API is a Sun internal API and is subject to changes without notice.
 * </b></p>
 * @since 1.7
 */
public class NamespaceDispatchInterceptor
        extends DispatchInterceptor<NamespaceInterceptor, JMXNamespace> {

    /**
     * A logger for this class.
     **/
    private static final Logger LOG = JmxProperties.NAMESPACE_LOGGER;

    private static final int NAMESPACE_SEPARATOR_LENGTH =
            NAMESPACE_SEPARATOR.length();

    private final DomainDispatchInterceptor localNamespace;
    private final String           serverName;

    /**
     * Creates a NamespaceDispatchInterceptor with the specified
     * repository instance.
     * <p>Do not forget to call <code>initialize(outer,delegate)</code>
     * before using this object.
     *
     * @param outer A pointer to the MBeanServer object that must be
     *        passed to the MBeans when invoking their
     *        {@link javax.management.MBeanRegistration} interface.
     * @param delegate A pointer to the MBeanServerDelegate associated
     *        with the new MBeanServer. The new MBeanServer must register
     *        this MBean in its MBean repository.
     * @param instantiator The MBeanInstantiator that will be used to
     *        instantiate MBeans and take care of class loading issues.
     * @param repository The repository to use for this MBeanServer
     */
    public NamespaceDispatchInterceptor(MBeanServer         outer,
                               MBeanServerDelegate delegate,
                               MBeanInstantiator   instantiator,
                               Repository          repository)  {
           localNamespace = new DomainDispatchInterceptor(outer,delegate,
                   instantiator,repository,this);
           serverName = Util.getMBeanServerSecurityName(delegate);
    }

    // TODO: Should move that to JMXNamespace? or to ObjectName?
    /**
     * Get first name space in ObjectName path. Ignore leading namespace
     * separators.
     **/
    public static String getFirstNamespace(ObjectName name) {
        if (name == null) return "";
        final String domain = name.getDomain();
        if (domain.equals("")) return "";

        int first = 0;
        int end = domain.indexOf(NAMESPACE_SEPARATOR,first);
        while (end == first) {
            first = end+NAMESPACE_SEPARATOR_LENGTH;
            end = domain.indexOf(NAMESPACE_SEPARATOR,first);
            if (end == -1) break;
        }

        if (end == -1) return "";

        final String namespace = domain.substring(first,end);

        return namespace;
    }

    /**
     * Called by the DefaultMBeanServerInterceptor, just before adding an
     * MBean to the repository.
     *
     * @param resource the MBean to be registered.
     * @param logicalName the name of the MBean to be registered.
     */
    final void checkLocallyRegistrable(Object resource,
            ObjectName logicalName) {
        if (!(resource instanceof JMXNamespace) &&
                logicalName.getDomain().contains(NAMESPACE_SEPARATOR))
            throw new IllegalArgumentException(String.valueOf(logicalName)+
                    ": Invalid ObjectName for an instance of " +
                    resource.getClass().getName());
    }

    final boolean isLocalHandlerNameFor(String namespace,
            ObjectName handlerName) {
        return handlerName.getDomain().equals(namespace+NAMESPACE_SEPARATOR) &&
               JMXNamespace.TYPE_ASSIGNMENT.equals(
               handlerName.getKeyPropertyListString());
    }

    @Override
    final MBeanServer getInterceptorOrNullFor(ObjectName name) {
        final String namespace = getFirstNamespace(name);
        if (namespace.equals("") || isLocalHandlerNameFor(namespace,name) ||
            name.getDomain().equals(namespace+NAMESPACE_SEPARATOR)) {
            LOG.finer("dispatching to local name space");
            return localNamespace;
        }
        final NamespaceInterceptor ns = getInterceptor(namespace);
        if (LOG.isLoggable(Level.FINER)) {
            if (ns != null) {
                LOG.finer("dispatching to name space: " + namespace);
            } else {
                LOG.finer("no handler for: " + namespace);
            }
        }
        return ns;
    }

    @Override
    final QueryInterceptor getInterceptorForQuery(ObjectName pattern) {
        final String namespace = getFirstNamespace(pattern);
        if (namespace.equals("") || isLocalHandlerNameFor(namespace,pattern) ||
            pattern.getDomain().equals(namespace+NAMESPACE_SEPARATOR)) {
            LOG.finer("dispatching to local name space");
            return new QueryInterceptor(localNamespace);
        }
        final NamespaceInterceptor ns = getInterceptor(namespace);
        if (LOG.isLoggable(Level.FINER)) {
            if (ns != null) {
                LOG.finer("dispatching to name space: " + namespace);
            } else {
                LOG.finer("no handler for: " + namespace);
            }
        }
        if (ns == null) return null;
        return new QueryInterceptor(ns);
    }

    @Override
    final ObjectName getHandlerNameFor(String key)
        throws MalformedObjectNameException {
        return ObjectName.getInstance(key+NAMESPACE_SEPARATOR,
                    "type", JMXNamespace.TYPE);
    }

    @Override
    final public String getHandlerKey(ObjectName name) {
        return getFirstNamespace(name);
    }

    @Override
    final NamespaceInterceptor createInterceptorFor(String key,
            ObjectName name, JMXNamespace handler,
            Queue<Runnable> postRegisterQueue) {
        final NamespaceInterceptor ns =
                new NamespaceInterceptor(serverName,handler,key);
        if (LOG.isLoggable(Level.FINER)) {
            LOG.finer("NamespaceInterceptor created: "+ns);
        }
        return ns;
    }

    @Override
    final DomainDispatchInterceptor getNextInterceptor() {
        return localNamespace;
    }

    /**
     * Returns the list of domains in which any MBean is currently
     * registered.
     */
    @Override
    public String[] getDomains() {
        return localNamespace.getDomains();
    }

    @Override
    public void addNamespace(ObjectName name, JMXNamespace handler,
            Queue<Runnable> postRegisterQueue) {
        if (handler instanceof JMXDomain)
            localNamespace.addNamespace(name,
                    (JMXDomain)handler,postRegisterQueue);
        else super.addNamespace(name,handler,postRegisterQueue);
    }

    @Override
    public void removeNamespace(ObjectName name, JMXNamespace handler,
            Queue<Runnable> postDeregisterQueue) {
        if (handler instanceof JMXDomain)
            localNamespace.removeNamespace(name,(JMXDomain)handler,
                    postDeregisterQueue);
        else super.removeNamespace(name,handler,postDeregisterQueue);
    }


}