/*

 * 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 javax.swing.*;

import javax.swing.event.*;

import javax.swing.table.*;

import javax.swing.tree.*;

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.GridLayout;

import java.awt.FlowLayout;

import java.awt.Component;

import java.awt.EventQueue;

import java.awt.event.*;

import java.awt.Insets;

import java.awt.Dimension;

import java.util.*;

import java.io.*;

import java.lang.reflect.Array;

import javax.management.*;

import javax.management.openmbean.CompositeData;

import javax.management.openmbean.TabularData;

import sun.tools.jconsole.Resources;

import sun.tools.jconsole.MBeansTab;

import sun.tools.jconsole.Plotter;

import sun.tools.jconsole.JConsole;

import sun.tools.jconsole.ProxyClient.SnapshotMBeanServerConnection;

/*IMPORTANT :

  There is a deadlock issue there if we don't synchronize well loadAttributes,

  refresh attributes and empty table methods since a UI thread can call

  loadAttributes and at the same time a JMX notification can raise an

  emptyTable. Since there are synchronization in the JMX world it's

  COMPULSORY to not call the JMX world in synchronized blocks */

@SuppressWarnings("serial")

public class XMBeanAttributes extends XTable {

    private final static String[] columnNames =

    {Resources.getText("Name"),

     Resources.getText("Value")};

    private boolean editable = true;

    private XMBean mbean;

    private MBeanInfo mbeanInfo;

    private MBeanAttributeInfo[] attributesInfo;

    private HashMap<String, Object> attributes;

    private HashMap<String, Object> unavailableAttributes;

    private HashMap<String, Object> viewableAttributes;

    private WeakHashMap<XMBean, HashMap<String, ZoomedCell>> viewersCache =

            new WeakHashMap<XMBean, HashMap<String, ZoomedCell>>();

    private TableModelListener attributesListener;

    private MBeansTab mbeansTab;

    private XTable table;

    private TableCellEditor valueCellEditor = new ValueCellEditor();

    private int rowMinHeight = -1;

    private AttributesMouseListener mouseListener = new AttributesMouseListener();

    private static TableCellEditor editor =

            new Utils.ReadOnlyTableCellEditor(new JTextField());

    public XMBeanAttributes(MBeansTab mbeansTab) {

        super();

        this.mbeansTab = mbeansTab;

        ((DefaultTableModel)getModel()).setColumnIdentifiers(columnNames);

        getModel().addTableModelListener(attributesListener =

                                         new AttributesListener(this));

        getColumnModel().getColumn(NAME_COLUMN).setPreferredWidth(40);

        addMouseListener(mouseListener);

        getTableHeader().setReorderingAllowed(false);

        setColumnEditors();

        addKeyListener(new Utils.CopyKeyAdapter());

    }

    public synchronized Component prepareRenderer(TableCellRenderer renderer,

                                                  int row, int column) {

        //In case we have a repaint thread that is in the process of

        //repainting an obsolete table, just ignore the call.

        //It can happen when MBean selection is switched at a very quick rate

        if(row >= getRowCount())

            return null;

        else

            return super.prepareRenderer(renderer, row, column);

    }

    void updateRowHeight(Object obj, int row) {

        ZoomedCell cell = null;

        if(obj instanceof ZoomedCell) {

            cell = (ZoomedCell) obj;

            if(cell.isInited())

                setRowHeight(row, cell.getHeight());

            else

                if(rowMinHeight != - 1)

                    setRowHeight(row, rowMinHeight);

        } else

            if(rowMinHeight != - 1)

                setRowHeight(row, rowMinHeight);

    }

    public synchronized TableCellRenderer getCellRenderer(int row,

            int column) {

        //In case we have a repaint thread that is in the process of

        //repainting an obsolete table, just ignore the call.

        //It can happen when MBean selection is switched at a very quick rate

        if (row >= getRowCount()) {

            return null;

        } else {

            if (column == VALUE_COLUMN) {

                Object obj = getModel().getValueAt(row, column);

                if (obj instanceof ZoomedCell) {

                    ZoomedCell cell = (ZoomedCell) obj;

                    if (cell.isInited()) {

                        DefaultTableCellRenderer renderer =

                                (DefaultTableCellRenderer) cell.getRenderer();

                        renderer.setToolTipText(getToolTip(row,column));

                        return renderer;

                    }

                }

            }

            DefaultTableCellRenderer renderer = (DefaultTableCellRenderer)

                super.getCellRenderer(row, column);

            if (!isCellError(row, column)) {

                if (!(isColumnEditable(column) && isWritable(row) &&

                      Utils.isEditableType(getClassName(row)))) {

                    renderer.setForeground(getDefaultColor());

                }

            }

            return renderer;

        }

    }

    private void setColumnEditors() {

        TableColumnModel tcm = getColumnModel();

        for (int i = 0; i < columnNames.length; i++) {

            TableColumn tc = tcm.getColumn(i);

            if (isColumnEditable(i)) {

                tc.setCellEditor(valueCellEditor);

            } else {

                tc.setCellEditor(editor);

            }

        }

    }

    public void cancelCellEditing() {

        TableCellEditor editor = getCellEditor();

        if (editor != null) {

            editor.cancelCellEditing();

        }

    }

    public void stopCellEditing() {

        TableCellEditor editor = getCellEditor();

        if (editor != null) {

            editor.stopCellEditing();

        }

    }

    public final boolean editCellAt(int row, int column, EventObject e) {

        boolean retVal = super.editCellAt(row, column, e);

        if (retVal) {

            TableCellEditor editor =

                    getColumnModel().getColumn(column).getCellEditor();

            if (editor == valueCellEditor) {

                ((JComponent) editor).requestFocus();

            }

        }

        return retVal;

    }

    @Override

    public boolean isCellEditable(int row, int col) {

        // All the cells in non-editable columns are editable

        if (!isColumnEditable(col)) {

            return true;

        }

        // Maximized zoomed cells are editable

        Object obj = getModel().getValueAt(row, col);

        if (obj instanceof ZoomedCell) {

            ZoomedCell cell = (ZoomedCell) obj;

            return cell.isMaximized();

        }

        return true;

    }

    @Override

    public void setValueAt(Object value, int row, int column) {

        if (!isCellError(row, column) && isColumnEditable(column) &&

            isWritable(row) && Utils.isEditableType(getClassName(row))) {

            super.setValueAt(value, row, column);

        }

    }

    //Table methods

    public boolean isTableEditable() {

        return true;

    }

    public void setTableValue(Object value, int row) {

    }

    public boolean isColumnEditable(int column) {

        if (column < getColumnCount()) {

            return getColumnName(column).equals(Resources.getText("Value"));

        }

        else {

            return false;

        }

    }

    public String getClassName(int row) {

        int index = convertRowToIndex(row);

        if (index != -1) {

            return attributesInfo[index].getType();

        }

        else {

            return null;

        }

    }

    public String getValueName(int row) {

        int index = convertRowToIndex(row);

        if (index != -1) {

            return attributesInfo[index].getName();

        }

        else {

            return null;

        }

    }

    public Object getValue(int row) {

        return ((DefaultTableModel) getModel()).getValueAt(row, VALUE_COLUMN);

    }

    //tool tip only for editable column

    public String getToolTip(int row, int column) {

        if (isCellError(row, column)) {

            return (String) unavailableAttributes.get(getValueName(row));

        }

        if (isColumnEditable(column)) {

            Object value = getValue(row);

            String tip = null;

            if (value != null) {

                tip = value.toString();

                if(isAttributeViewable(row, VALUE_COLUMN))

                    tip = Resources.getText("Double click to expand/collapse")+

                        ". " + tip;

            }

            return tip;

        }

        if(column == NAME_COLUMN) {

            int index = convertRowToIndex(row);

            if (index != -1) {

                return attributesInfo[index].getDescription();

            }

        }

        return null;

    }

    public synchronized boolean isWritable(int row) {

        int index = convertRowToIndex(row);

        if (index != -1) {

            return (attributesInfo[index].isWritable());

        }

        else {

            return false;

        }

    }

    /**

     * Override JTable method in order to make any call to this method

     * atomic with TableModel elements.

     */

    public synchronized int getRowCount() {

        return super.getRowCount();

    }

    public synchronized boolean isReadable(int row) {

        int index = convertRowToIndex(row);

        if (index != -1) {

            return (attributesInfo[index].isReadable());

        }

        else {

            return false;

        }

    }

    public synchronized boolean isCellError(int row, int col) {

        return (isColumnEditable(col) &&

                (unavailableAttributes.containsKey(getValueName(row))));

    }

    public synchronized boolean isAttributeViewable(int row, int col) {

        boolean isViewable = false;

        if(col == VALUE_COLUMN) {

            Object obj = getModel().getValueAt(row, col);

            if(obj instanceof ZoomedCell)

                isViewable = true;

        }

        return isViewable;

    }

    public void loadAttributes(final XMBean mbean, MBeanInfo mbeanInfo) {

        // To avoid deadlock with events coming from the JMX side,

        // we retrieve all JMX stuff in a non synchronized block.

        if(mbean == null) return;

        final MBeanAttributeInfo[] attributesInfo = mbeanInfo.getAttributes();

        final HashMap<String, Object> attributes =

            new HashMap<String, Object>(attributesInfo.length);

        final HashMap<String, Object> unavailableAttributes =

            new HashMap<String, Object>(attributesInfo.length);

        final HashMap<String, Object> viewableAttributes =

            new HashMap<String, Object>(attributesInfo.length);

        AttributeList list = null;

        try {

            list = mbean.getAttributes(attributesInfo);

        } catch (Exception e) {

            if (JConsole.isDebug()) {

                System.err.println("Error calling getAttributes() on MBean \"" +

                                   mbean.getObjectName() + "\". JConsole will " +

                                   "try to get them individually calling " +

                                   "getAttribute() instead. Exception:");

                e.printStackTrace(System.err);

            }

            list = new AttributeList();

            //Can't load all attributes, do it one after each other.

            for(int i = 0; i < attributesInfo.length; i++) {

                String name = null;

                try {

                    name = attributesInfo[i].getName();

                    Object value =

                        mbean.getMBeanServerConnection().getAttribute(mbean.getObjectName(), name);

                    list.add(new Attribute(name, value));

                }catch(Exception ex) {

                    if(attributesInfo[i].isReadable()) {

                        unavailableAttributes.put(name,

                                                  Utils.getActualException(ex).

                                                  toString());

                    }

                }

            }

        }

        try {

            int att_length = list.size();

            for (int i=0;i<att_length;i++) {

                Attribute attribute = (Attribute) list.get(i);

                if(isViewable(attribute)) {

                    viewableAttributes.put(attribute.getName(),

                                           attribute.getValue());

                }

                else

                    attributes.put(attribute.getName(),attribute.getValue());

            }

            // if not all attributes are accessible,

            // check them one after the other.

            if (att_length < attributesInfo.length) {

                for (int i=0;i<attributesInfo.length;i++) {

                    MBeanAttributeInfo attributeInfo = attributesInfo[i];

                    if (!attributes.containsKey(attributeInfo.getName()) &&

                        !viewableAttributes.containsKey(attributeInfo.

                                                        getName()) &&

                        !unavailableAttributes.containsKey(attributeInfo.

                                                           getName())) {

                        if (attributeInfo.isReadable()) {

                            // getAttributes didn't help resolving the

                            // exception.

                            // We must call it again to understand what

                            // went wrong.

                            try {

                                Object v =

                                    mbean.getMBeanServerConnection().getAttribute(

                                    mbean.getObjectName(), attributeInfo.getName());

                                //What happens if now it is ok?

                                // Be pragmatic, add it to readable...

                                attributes.put(attributeInfo.getName(),

                                               v);

                            }catch(Exception e) {

                                //Put the exception that will be displayed

                                // in tooltip

                                unavailableAttributes.put(attributeInfo.

                                                          getName(),

                                                          Utils.

                                                          getActualException(e)

                                                          .toString());

                            }

                        }

                    }

                }

            }

        }

        catch(Exception e) {

            //sets all attributes unavailable except the writable ones

            for (int i=0;i<attributesInfo.length;i++) {

                MBeanAttributeInfo attributeInfo = attributesInfo[i];

                if (attributeInfo.isReadable()) {

                    unavailableAttributes.put(attributeInfo.getName(),

                                              Utils.getActualException(e).

                                              toString());

                }

            }

        }

        //end of retrieval

        //one update at a time

        synchronized(this) {

            this.mbean = mbean;

            this.mbeanInfo = mbeanInfo;

            this.attributesInfo = attributesInfo;

            this.attributes = attributes;

            this.unavailableAttributes = unavailableAttributes;

            this.viewableAttributes = viewableAttributes;

            EventQueue.invokeLater(new Runnable() {

                public void run() {

                    DefaultTableModel tableModel =

                            (DefaultTableModel) getModel();

                    // don't listen to these events

                    tableModel.removeTableModelListener(attributesListener);

                    // add attribute information

                    emptyTable();

                    addTableData(tableModel,

                                 mbean,

                                 attributesInfo,

                                 attributes,

                                 unavailableAttributes,

                                 viewableAttributes);

                    // update the model with the new data

                    tableModel.newDataAvailable(new TableModelEvent(tableModel));

                    // re-register for change events

                    tableModel.addTableModelListener(attributesListener);

                }

            });

        }

    }

    void collapse(String attributeName, final Component c) {

        final int row = getSelectedRow();

        Object obj = getModel().getValueAt(row, VALUE_COLUMN);

        if(obj instanceof ZoomedCell) {

            cancelCellEditing();

            ZoomedCell cell = (ZoomedCell) obj;

            cell.reset();

            setRowHeight(row,

                         cell.getHeight());

            editCellAt(row,

                       VALUE_COLUMN);

            invalidate();

            repaint();

        }

    }

    ZoomedCell updateZoomedCell(int row,

                                int col) {

        Object obj = getModel().getValueAt(row, VALUE_COLUMN);

        ZoomedCell cell = null;

        if(obj instanceof ZoomedCell) {

            cell = (ZoomedCell) obj;

            if(!cell.isInited()) {

                Object elem = cell.getValue();

                String attributeName =

                    (String) getModel().getValueAt(row,

                                                   NAME_COLUMN);

                Component comp = mbeansTab.getDataViewer().

                        createAttributeViewer(elem, mbean, attributeName, this);

                if(comp != null){

                    if(rowMinHeight == -1)

                        rowMinHeight = getRowHeight(row);

                    cell.init(super.getCellRenderer(row, col),

                              comp,

                              rowMinHeight);

                    mbeansTab.getDataViewer().registerForMouseEvent(

                            comp, mouseListener);

                } else

                    return cell;

            }

            cell.switchState();

            setRowHeight(row,

                         cell.getHeight());

            if(!cell.isMaximized()) {

                cancelCellEditing();

                //Back to simple editor.

                editCellAt(row,