/*
 * Copyright 2004-2006 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 sun.tools.jconsole.inspector;

import java.awt.EventQueue;
import java.util.*;
import javax.management.*;
import javax.swing.*;
import javax.swing.tree.*;
import sun.tools.jconsole.JConsole;
import sun.tools.jconsole.MBeansTab;
import sun.tools.jconsole.Resources;
import sun.tools.jconsole.inspector.XNodeInfo;
import sun.tools.jconsole.inspector.XNodeInfo.Type;

@SuppressWarnings("serial")
public class XTree extends JTree {

    private static final List<String> orderedKeyPropertyList =
            new ArrayList<String>();
    static {
        String keyPropertyList =
                System.getProperty("com.sun.tools.jconsole.mbeans.keyPropertyList");
        if (keyPropertyList == null) {
            orderedKeyPropertyList.add("type");
            orderedKeyPropertyList.add("j2eeType");
        } else {
            StringTokenizer st = new StringTokenizer(keyPropertyList, ",");
            while (st.hasMoreTokens()) {
                orderedKeyPropertyList.add(st.nextToken());
            }
        }
    }

    private MBeansTab mbeansTab;

    private Map<String, DefaultMutableTreeNode> nodes =
            new HashMap<String, DefaultMutableTreeNode>();

    public XTree(MBeansTab mbeansTab) {
        this(new DefaultMutableTreeNode("MBeanTreeRootNode"), mbeansTab);
    }

    public XTree(TreeNode root, MBeansTab mbeansTab) {
        super(root);
        this.mbeansTab = mbeansTab;
        setRootVisible(false);
        setShowsRootHandles(true);
        ToolTipManager.sharedInstance().registerComponent(this);
    }

    /**
     * This method removes the node from its parent
     */
    // Call on EDT
    private synchronized void removeChildNode(DefaultMutableTreeNode child) {
        DefaultTreeModel model = (DefaultTreeModel) getModel();
        model.removeNodeFromParent(child);
    }

    /**
     * This method adds the child to the specified parent node
     * at specific index.
     */
    // Call on EDT
    private synchronized void addChildNode(
            DefaultMutableTreeNode parent,
            DefaultMutableTreeNode child,
            int index) {
        // Tree does not show up when there is only the root node
        //
        DefaultTreeModel model = (DefaultTreeModel) getModel();
        DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
        boolean rootLeaf = root.isLeaf();
        model.insertNodeInto(child, parent, index);
        if (rootLeaf) {
            model.nodeStructureChanged(root);
        }
    }

    /**
     * This method adds the child to the specified parent node.
     * The index where the child is to be added depends on the
     * child node being Comparable or not. If the child node is
     * not Comparable then it is added at the end, i.e. right
     * after the current parent's children.
     */
    // Call on EDT
    private synchronized void addChildNode(
            DefaultMutableTreeNode parent, DefaultMutableTreeNode child) {
        int childCount = parent.getChildCount();
        if (childCount == 0) {
            addChildNode(parent, child, 0);
        } else if (child instanceof ComparableDefaultMutableTreeNode) {
            ComparableDefaultMutableTreeNode comparableChild =
                (ComparableDefaultMutableTreeNode)child;
            int i = 0;
            for (; i < childCount; i++) {
                DefaultMutableTreeNode brother =
                        (DefaultMutableTreeNode) parent.getChildAt(i);
                //child < brother
                if (comparableChild.compareTo(brother) < 0) {
                    addChildNode(parent, child, i);
                    break;
                }
                //child = brother
                else if (comparableChild.compareTo(brother) == 0) {
                    addChildNode(parent, child, i);
                    break;
                }
            }
            //child < all brothers
            if (i == childCount) {
                addChildNode(parent, child, childCount);
            }
        } else {
            //not comparable, add at the end
            addChildNode(parent, child, childCount);
        }
    }

    /**
     * This method removes all the displayed nodes from the tree,
     * but does not affect actual MBeanServer contents.
     */
    // Call on EDT
    public synchronized void removeAll() {
        DefaultTreeModel model = (DefaultTreeModel) getModel();
        DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
        root.removeAllChildren();
        model.nodeStructureChanged(root);
        nodes.clear();
    }

    public void delMBeanFromView(final ObjectName mbean) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                // We assume here that MBeans are removed one by one (on MBean
                // unregistered notification). Deletes the tree node associated
                // with the given MBean and recursively all the node parents
                // which are leaves and non XMBean.
                //
                synchronized (XTree.this) {
                    DefaultMutableTreeNode node = null;
                    Dn dn = buildDn(mbean);
                    if (dn.size() > 0) {
                        DefaultTreeModel model = (DefaultTreeModel) getModel();
                        Token token = dn.getToken(0);
                        String hashKey = dn.getHashKey(token);
                        node = nodes.get(hashKey);
                        if ((node != null) && (!node.isRoot())) {
                            if (hasMBeanChildren(node)) {
                                removeNonMBeanChildren(node);
                                String label = token.getValue().toString();
                                XNodeInfo userObject = new XNodeInfo(
                                        Type.NONMBEAN, label,
                                        label, token.toString());
                                changeNodeValue(node, userObject);
                            } else {
                                DefaultMutableTreeNode parent =
                                        (DefaultMutableTreeNode) node.getParent();
                                model.removeNodeFromParent(node);
                                nodes.remove(hashKey);
                                delParentFromView(dn, 1, parent);
                            }
                        }
                    }
                }
            }
        });
    }

    /**
     * Returns true if any of the children nodes is an MBean.
     */
    private boolean hasMBeanChildren(DefaultMutableTreeNode node) {
        for (Enumeration e = node.children(); e.hasMoreElements(); ) {
            DefaultMutableTreeNode n = (DefaultMutableTreeNode) e.nextElement();
            if (((XNodeInfo) n.getUserObject()).getType().equals(Type.MBEAN)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Remove all the children nodes which are not MBean.
     */
    private void removeNonMBeanChildren(DefaultMutableTreeNode node) {
        Set<DefaultMutableTreeNode> metadataNodes =
                new HashSet<DefaultMutableTreeNode>();
        DefaultTreeModel model = (DefaultTreeModel) getModel();
        for (Enumeration e = node.children(); e.hasMoreElements(); ) {
            DefaultMutableTreeNode n = (DefaultMutableTreeNode) e.nextElement();
            if (!((XNodeInfo) n.getUserObject()).getType().equals(Type.MBEAN)) {
                metadataNodes.add(n);
            }
        }
        for (DefaultMutableTreeNode n : metadataNodes) {
            model.removeNodeFromParent(n);
        }
    }

    /**
     * Removes only the parent nodes which are non MBean and leaf.
     * This method assumes the child nodes have been removed before.
     */
    private DefaultMutableTreeNode delParentFromView(
            Dn dn, int index, DefaultMutableTreeNode node) {
        if ((!node.isRoot()) && node.isLeaf() &&
                (!(((XNodeInfo) node.getUserObject()).getType().equals(Type.MBEAN)))) {
            DefaultMutableTreeNode parent =
                    (DefaultMutableTreeNode) node.getParent();
            removeChildNode(node);
            String hashKey = dn.getHashKey(dn.getToken(index));
            nodes.remove(hashKey);
            delParentFromView(dn, index + 1, parent);
        }
        return node;
    }

    public synchronized void addMBeanToView(final ObjectName mbean) {
        final XMBean xmbean;
        try {
            xmbean = new XMBean(mbean, mbeansTab);
            if (xmbean == null) {
                return;
            }
        } catch (Exception e) {
            // Got exception while trying to retrieve the
            // given MBean from the underlying MBeanServer
            //
            if (JConsole.isDebug()) {
                e.printStackTrace();
            }
            return;
        }
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                synchronized (XTree.this) {
                    // Add the new nodes to the MBean tree from leaf to root

                    Dn dn = buildDn(mbean);
                    if (dn.size() == 0) return;
                    Token token = dn.getToken(0);
                    DefaultMutableTreeNode node = null;
                    boolean nodeCreated = true;

                    //
                    // Add the node or replace its user object if already added
                    //

                    String hashKey = dn.getHashKey(token);
                    if (nodes.containsKey(hashKey)) {
                        //already in the tree, means it has been created previously
                        //when adding another node
                        node = nodes.get(hashKey);
                        //sets the user object
                        final Object data = createNodeValue(xmbean, token);
                        final String label = data.toString();
                        final XNodeInfo userObject =
                                new XNodeInfo(Type.MBEAN, data, label, mbean.toString());
                        changeNodeValue(node, userObject);
                        nodeCreated = false;
                    } else {
                        //create a new node
                        node = createDnNode(dn, token, xmbean);
                        if (node != null) {
                            nodes.put(hashKey, node);
                            nodeCreated = true;
                        } else {
                            return;
                        }
                    }

                    //
                    // Add (virtual) nodes without user object if necessary
                    //

                    for (int i = 1; i < dn.size(); i++) {
                        DefaultMutableTreeNode currentNode = null;
                        token = dn.getToken(i);
                        hashKey = dn.getHashKey(token);
                        if (nodes.containsKey(hashKey)) {
                            //node already present
                            if (nodeCreated) {
                                //previous node created, link to do
                                currentNode = nodes.get(hashKey);
                                addChildNode(currentNode, node);
                                return;
                            } else {
                                //both nodes already present
                                return;
                            }
                        } else {
                            //creates the node that can be a virtual one
                            if (token.getKeyDn().equals("domain")) {
                                //better match on keyDn that on Dn
                                currentNode = createDomainNode(dn, token);
                                if (currentNode != null) {
                                    final DefaultMutableTreeNode root =
                                            (DefaultMutableTreeNode) getModel().getRoot();
                                    addChildNode(root, currentNode);
                                }
                            } else {
                                currentNode = createSubDnNode(dn, token);
                                if (currentNode == null) {
                                    //skip
                                    continue;
                                }
                            }
                            nodes.put(hashKey, currentNode);
                            addChildNode(currentNode, node);
                            nodeCreated = true;
                        }
                        node = currentNode;
                    }
                }
            }
        });
    }

    // Call on EDT
    private synchronized void changeNodeValue(
            final DefaultMutableTreeNode node, XNodeInfo nodeValue) {
        if (node instanceof ComparableDefaultMutableTreeNode) {
            // should it stay at the same place?
            DefaultMutableTreeNode clone =
                    (DefaultMutableTreeNode) node.clone();
            clone.setUserObject(nodeValue);
            if (((ComparableDefaultMutableTreeNode) node).compareTo(clone) == 0) {
                // the order in the tree didn't change
                node.setUserObject(nodeValue);
                DefaultTreeModel model = (DefaultTreeModel) getModel();
                model.nodeChanged(node);
            } else {
                // delete the node and re-order it in case the
                // node value modifies the order in the tree
                DefaultMutableTreeNode parent =
                        (DefaultMutableTreeNode) node.getParent();
                removeChildNode(node);
                node.setUserObject(nodeValue);
                addChildNode(parent, node);
            }
        } else {
            // not comparable stays at the same place
            node.setUserObject(nodeValue);
            DefaultTreeModel model = (DefaultTreeModel) getModel();
            model.nodeChanged(node);
        }
        // Load the MBean metadata if type is MBEAN
        if (nodeValue.getType().equals(Type.MBEAN)) {
            XMBeanInfo.loadInfo(node);
            DefaultTreeModel model = (DefaultTreeModel) getModel();
            model.nodeStructureChanged(node);
        }
        // Clear the current selection and set it
        // again so valueChanged() gets called
        if (node == getLastSelectedPathComponent()) {
            TreePath selectionPath = getSelectionPath();
            clearSelection();
            setSelectionPath(selectionPath);
        }
    }

    //creates the domain node, called on a domain token
    private DefaultMutableTreeNode createDomainNode(Dn dn, Token token) {
        DefaultMutableTreeNode node = new ComparableDefaultMutableTreeNode();
        String label = dn.getDomain();
        XNodeInfo userObject =
                new XNodeInfo(Type.NONMBEAN, label, label, label);
        node.setUserObject(userObject);
        return node;
    }

    //creates the node corresponding to the whole Dn
    private DefaultMutableTreeNode createDnNode(
            Dn dn, Token token, XMBean xmbean) {
        DefaultMutableTreeNode node = new ComparableDefaultMutableTreeNode();
        Object data = createNodeValue(xmbean, token);
        String label = data.toString();
        XNodeInfo userObject = new XNodeInfo(Type.MBEAN, data, label,
                xmbean.getObjectName().toString());
        node.setUserObject(userObject);
        XMBeanInfo.loadInfo(node);
        return node;
    }

    //creates a node with the token value, call for each non domain sub
    //dn token
    private DefaultMutableTreeNode createSubDnNode(Dn dn, Token token) {
        DefaultMutableTreeNode node = new ComparableDefaultMutableTreeNode();
        String label = isKeyValueView() ? token.toString() :
            token.getValue().toString();
        XNodeInfo userObject =
                new XNodeInfo(Type.NONMBEAN, label, label, token.toString());
        node.setUserObject(userObject);
        return node;
    }

    private Object createNodeValue(XMBean xmbean, Token token) {
        String label = isKeyValueView() ? token.toString() :
            token.getValue().toString();
        xmbean.setText(label);
        return xmbean;
    }

    /**
     * Parses MBean ObjectName comma-separated properties string and put the
     * individual key/value pairs into the map. Key order in the properties
     * string is preserved by the map.
     */
    private Map<String,String> extractKeyValuePairs(
            String properties, ObjectName mbean) {
        String props = properties;
        Map<String,String> map = new LinkedHashMap<String,String>();
        int eq = props.indexOf("=");
        while (eq != -1) {
            String key = props.substring(0, eq);
            String value = mbean.getKeyProperty(key);
            map.put(key, value);
            props = props.substring(key.length() + 1 + value.length());
            if (props.startsWith(",")) {
                props = props.substring(1);
            }
            eq = props.indexOf("=");
        }
        return map;
    }

    /**
     * Returns the ordered key property list that will be used to build the
     * MBean tree. If the "com.sun.tools.jconsole.mbeans.keyPropertyList" system
     * property is not specified, then the ordered key property list used
     * to build the MBean tree will be the one returned by the method
     * ObjectName.getKeyPropertyListString() with "type" as first key,
     * and "j2eeType" as second key, if present. If any of the keys specified
     * in the comma-separated key property list does not apply to the given
     * MBean then it will be discarded.
     */
    private String getKeyPropertyListString(ObjectName mbean) {
        String props = mbean.getKeyPropertyListString();
        Map<String,String> map = extractKeyValuePairs(props, mbean);
        StringBuilder sb = new StringBuilder();
        // Add the key/value pairs to the buffer following the
        // key order defined by the "orderedKeyPropertyList"
        for (String key : orderedKeyPropertyList) {
            if (map.containsKey(key)) {
                sb.append(key + "=" + map.get(key) + ",");
                map.remove(key);
            }
        }
        // Add the remaining key/value pairs to the buffer
        for (Map.Entry<String,String> entry : map.entrySet()) {
            sb.append(entry.getKey() + "=" + entry.getValue() + ",");
        }
        String orderedKeyPropertyListString = sb.toString();
        orderedKeyPropertyListString = orderedKeyPropertyListString.substring(
                0, orderedKeyPropertyListString.length() - 1);
        return orderedKeyPropertyListString;
    }

    /**
     * Builds the Dn for the given MBean.
     */
    private Dn buildDn(ObjectName mbean) {

        String domain = mbean.getDomain();
        String globalDn = getKeyPropertyListString(mbean);

        Dn dn = buildDn(domain, globalDn, mbean);

        //update the Dn tokens to add the domain
        dn.updateDn();

        //reverse the Dn (from leaf to root)
        dn.reverseOrder();

        //compute the hashDn
        dn.computeHashDn();

        return dn;
    }

    /**
     * Builds the Dn for the given MBean.
     */
    private Dn buildDn(String domain, String globalDn, ObjectName mbean) {
        Dn dn = new Dn(domain, globalDn);
        String keyDn = "no_key";
        if (isTreeView()) {
            String props = globalDn;
            Map<String,String> map = extractKeyValuePairs(props, mbean);
            for (Map.Entry<String,String> entry : map.entrySet()) {
                dn.addToken(new Token(keyDn,
                        entry.getKey() + "=" + entry.getValue()));
            }
        } else {
            //flat view
            dn.addToken(new Token(keyDn, "properties=" + globalDn));
        }
        return dn;
    }

    //
    //utility objects
    //

    public static class ComparableDefaultMutableTreeNode
            extends DefaultMutableTreeNode
            implements Comparable<DefaultMutableTreeNode> {
        public int compareTo(DefaultMutableTreeNode node) {
            return (this.toString().compareTo(node.toString()));
        }
    }

    //
    //tree preferences
    //

    private boolean treeView;
    private boolean treeViewInit = false;
    public boolean isTreeView() {
        if (!treeViewInit) {
            treeView = getTreeViewValue();
            treeViewInit = true;
        }
        return treeView;
    }

    private boolean getTreeViewValue() {
        String treeView = System.getProperty("treeView");
        return ((treeView == null) ? true : !(treeView.equals("false")));
    }

    //
    //MBean key-value preferences
    //

    private boolean keyValueView = Boolean.getBoolean("keyValueView");
    public boolean isKeyValueView() {
        return keyValueView;
    }

    //
    //utility classes
    //

    public static class Dn {

        private String domain;
        private String dn;
        private String hashDn;
        private ArrayList<Token> tokens = new ArrayList<Token>();

        public Dn(String domain, String dn) {
            this.domain = domain;
            this.dn = dn;
        }

        public void clearTokens() {
            tokens.clear();
        }

        public void addToken(Token token) {
            tokens.add(token);
        }

        public void addToken(int index, Token token) {
            tokens.add(index, token);
        }

        public void setToken(int index, Token token) {
            tokens.set(index, token);
        }

        public void removeToken(int index) {
            tokens.remove(index);
        }

        public Token getToken(int index) {
            return tokens.get(index);
        }

        public void reverseOrder() {
            ArrayList<Token> newOrder = new ArrayList<Token>(tokens.size());
            for (int i = tokens.size() - 1; i >= 0; i--) {
                newOrder.add(tokens.get(i));
            }
            tokens = newOrder;
        }

        public int size() {
            return tokens.size();
        }

        public String getDomain() {
            return domain;
        }

        public String getDn() {
            return dn;
        }

        public String getHashDn() {
            return hashDn;
        }

        public String getHashKey(Token token) {
            final int begin = getHashDn().indexOf(token.getHashToken());
            return  getHashDn().substring(begin, getHashDn().length());
        }

        public void computeHashDn() {
            final StringBuilder hashDn = new StringBuilder();
            final int tokensSize = tokens.size();
            for (int i = 0; i < tokensSize; i++) {
                Token token = tokens.get(i);
                String hashToken = token.getHashToken();
                if (hashToken == null) {
                    hashToken = token.getToken() + (tokensSize - i);
                    token.setHashToken(hashToken);
                }
                hashDn.append(hashToken);
                hashDn.append(",");
            }
            if (tokensSize > 0) {
                this.hashDn = hashDn.substring(0, hashDn.length() - 1);
            } else {
                this.hashDn = "";
            }
        }

        /**
         * Adds the domain as the first token in the Dn.
         */
        public void updateDn() {
            addToken(0, new Token("domain", "domain=" + getDomain()));
        }

        public String toString() {
            return tokens.toString();
        }
    }

    public static class Token {

        private String keyDn;
        private String token;
        private String hashToken;
        private String key;
        private String value;

        public Token(String keyDn, String token) {
            this.keyDn = keyDn;
            this.token = token;
            buildKeyValue();
        }

        public Token(String keyDn, String token, String hashToken) {
            this.keyDn = keyDn;
            this.token = token;
            this.hashToken = hashToken;
            buildKeyValue();
        }

        public String getKeyDn() {
            return keyDn;
        }

        public String getToken() {
            return token;
        }

        public void setValue(String value) {
            this.value = value;
            this.token = key + "=" + value;
        }

        public void setKey(String key) {
            this.key = key;
            this.token = key + "=" + value;
        }

        public void setKeyDn(String keyDn) {
            this.keyDn = keyDn;
        }

        public  void setHashToken(String hashToken) {
            this.hashToken = hashToken;
        }

        public String getHashToken() {
            return hashToken;
        }

        public String getKey() {
            return key;
        }

        public String getValue() {
            return value;
        }

        public String toString(){
            return getToken();
        }

        public boolean equals(Object object) {
            if (object instanceof Token) {
                return token.equals(((Token) object));
            } else {
                return false;
            }
        }

        private void buildKeyValue() {
            int index = token.indexOf("=");
            if (index < 0) {
                key = token;
                value = token;
            } else {
                key = token.substring(0, index);
                value = token.substring(index + 1, token.length());
            }
        }
    }
}