import java.awt.BorderLayout;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.lang.management.ManagementFactory;
import java.lang.management.GarbageCollectorMXBean;
import java.lang.management.MemoryMXBean;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.swing.Box;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTabbedPane;
import javax.swing.border.EmptyBorder;

public class GarbageCollectorMXBeanTest {
    private List<GarbageCollectorMXBean> mbeans;
    private Map<String, GCInfoPane> gcInfoPanes;

    private JTabbedPane tabbedPane;

    public GarbageCollectorMXBeanTest() {
        initView();

        gcInfoPanes = new HashMap<String, GCInfoPane>();
        mbeans = ManagementFactory.getGarbageCollectorMXBeans();
        createInfoTab();
    }

    private void initView() {
        JFrame frame = new JFrame("Garbage Collector Infomation");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(500, 500);
        tabbedPane = new JTabbedPane();
        frame.getContentPane().add(tabbedPane);

        JPanel panel = new JPanel();
        panel.setLayout(new FlowLayout(FlowLayout.RIGHT));
        JButton updateButton = new JButton("Update");
        updateButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent event) {
                updateInfo();
            }
        });
        panel.add(updateButton);

        JButton gcButton = new JButton("GC");
        gcButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent event) {
                MemoryMXBean mbean = ManagementFactory.getMemoryMXBean();
                mbean.gc();
                updateInfo();
            }
        });
        panel.add(gcButton);

        frame.getContentPane().add(panel, BorderLayout.NORTH);

        frame.setVisible(true);
    }

    private void createInfoTab() {
        for (GarbageCollectorMXBean mbean: mbeans) {
            addInfoTab(mbean);
        }
    }

    private void updateInfo() {
        for (GarbageCollectorMXBean mbean: mbeans) {
            GCInfoPane pane = gcInfoPanes.get(mbean.getName());
            pane.update(mbean);
        }
    }

    private void addInfoTab(GarbageCollectorMXBean mbean) {
        GCInfoPane pane = new GCInfoPane();

        pane.update(mbean);
        tabbedPane.add("GC:" + mbean.getName(), new JScrollPane(pane));

        gcInfoPanes.put(mbean.getName(), pane);
    }

    class GCInfoPane extends JPanel {
        private JLabel nameLabel;
        private JLabel memoryPoolNamesLabel;
        private JLabel validLabel;
        private JLabel collectionCountLabel;
        private JLabel collectionTimeLabel;
        private JLabel idLabel;
        private JLabel startTimeLabel;
        private JLabel endTimeLabel;
        private JLabel durationLabel;
        private JLabel usageBeforeGcLabel;
        private JLabel usageAfterGcLabel;

        public GCInfoPane() {
            setBorder(new EmptyBorder(10, 10, 10, 10));
            setLayout(new CompactGridLayout(0, 2, 2, 20));

            nameLabel = new JLabel();
            memoryPoolNamesLabel = new JLabel();
            validLabel = new JLabel();
            collectionCountLabel = new JLabel();
            collectionTimeLabel = new JLabel();
            idLabel = new JLabel();
            startTimeLabel = new JLabel();
            endTimeLabel = new JLabel();
            durationLabel = new JLabel();
            usageBeforeGcLabel = new JLabel();
            usageAfterGcLabel = new JLabel();

            add(new JLabel("Name"));
            add(nameLabel);
            add(new JLabel("Memory Pool Names"));
            add(memoryPoolNamesLabel);
            add(new JLabel("Valid"));
            add(validLabel);
        
            add(new JLabel("Collection Count"));
            add(collectionCountLabel);
            add(new JLabel("Collection Time"));
            add(collectionTimeLabel);

            add(new JLabel("Last GC Info"));
            add(Box.createGlue());
            add(new JLabel("  ID"));
            add(idLabel);
            add(new JLabel("  Start Time"));
            add(startTimeLabel);
            add(new JLabel("  End Time"));
            add(endTimeLabel);
            add(new JLabel("  Duration"));
            add(durationLabel);
            add(new JLabel("  Usage Before GC"));
            add(usageBeforeGcLabel);
            add(new JLabel("  Usage After GC"));
            add(usageAfterGcLabel);
        }


        public void update(GarbageCollectorMXBean gcmbean) {
            com.sun.management.GarbageCollectorMXBean mbean
                = (com.sun.management.GarbageCollectorMXBean)gcmbean;
            String name = "";
            String memoryPoolNames = "";
            boolean valid = false;
            long collectionCount = -1;
            long collectionTime = -1;
            
            long id = -1;
            long startTime = -1;
            long endTime = -1;
            long duration = -1;
            String usageBeforeGc = "";
            String usageAfterGc = "";
            
            synchronized (mbean) {
                name = mbean.getName();

                StringBuilder buffer = new StringBuilder();
                buffer.append("<html><body>");
                for (Object object: mbean.getMemoryPoolNames()) {
                    buffer.append(object);
                    buffer.append("<br>");
                }
                buffer.append("</body></html>");
                memoryPoolNames = buffer.toString();
                
                valid = mbean.isValid();
                collectionCount = mbean.getCollectionCount();
                collectionTime = mbean.getCollectionTime();
                
                if (collectionCount > 0) {
                    com.sun.management.GcInfo lastGcInfo = mbean.getLastGcInfo();
                    
                    id = lastGcInfo.getId();
                    startTime = lastGcInfo.getStartTime();
                    endTime = lastGcInfo.getEndTime();
                    duration = lastGcInfo.getDuration();
                    
                    List<String> usages = new ArrayList<String>();
                    for (Object object: lastGcInfo.getMemoryUsageBeforeGc().entrySet()) {
                        Map.Entry entry = (Map.Entry)object;
                        usages.add(entry.getKey() + " : " + entry.getValue());
                    }
                    Collections.sort(usages);
                    
                    buffer.setLength(0);
                    buffer.append("<html><body>");
                    for (String usage: usages) {
                        buffer.append(usage);
                        buffer.append("<br>");
                    }
                    buffer.append("</body></html>");
                    usageBeforeGc = buffer.toString();
                    
                    usages.clear();
                    for (Object object: lastGcInfo.getMemoryUsageAfterGc().entrySet()) {
                        Map.Entry entry = (Map.Entry)object;
                        usages.add(entry.getKey() + " : " + entry.getValue());
                    }
                    Collections.sort(usages);
                    
                    buffer.setLength(0);
                    buffer.append("<html><body>");
                    for (String usage: usages) {
                        buffer.append(usage);
                        buffer.append("<br>");
                    }
                    buffer.append("</body></html>");
                    usageAfterGc = buffer.toString();
                }
            }
            
            nameLabel.setText(name);
            memoryPoolNamesLabel.setText(memoryPoolNames);
            validLabel.setText(Boolean.toString(valid));
            
            collectionCountLabel.setText(Long.toString(collectionCount));
            collectionTimeLabel.setText(Long.toString(collectionTime));
            
            if (collectionCount > 0) {
                idLabel.setText(Long.toString(id));
                startTimeLabel.setText(Long.toString(startTime));
                endTimeLabel.setText(Long.toString(endTime));
                durationLabel.setText(Long.toString(duration));
                usageBeforeGcLabel.setText(usageBeforeGc);
                usageAfterGcLabel.setText(usageAfterGc);
            }
        }
    }

    public static void main(String[] args) {
        new GarbageCollectorMXBeanTest();
    }
}