/*
 * Copyright 2001,2004 The Apache Software Foundation.
 *
 * Licensed under the Apache Liusercense, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.axis.utils;

import org.apache.axis.client.AdminClient;
import org.apache.axis.monitor.SOAPMonitorConstants;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import javax.swing.BoxLayout;
import javax.swing.ButtonGroup;
import javax.swing.DefaultListModel;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JPasswordField;
import javax.swing.JProgressBar;
import javax.swing.JRadioButton;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JTabbedPane;
import javax.swing.JTable;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.ListSelectionModel;
import javax.swing.SwingConstants;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.WindowConstants;
import javax.swing.border.BevelBorder;
import javax.swing.border.EmptyBorder;
import javax.swing.border.EtchedBorder;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.table.AbstractTableModel;
import javax.swing.event.ChangeListener;
import javax.xml.parsers.ParserConfigurationException;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.GridLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationTargetException;
import java.net.Socket;
import java.net.URL;
import java.net.MalformedURLException;
import java.text.DateFormat;
import java.util.Collection;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Vector;

/**
 * This is a SOAP Monitor Application class.  This class provides
 * the user interface for deploying the SOAP monitor service and
 * displaying data from the service.
 * 
 * @author Toshiyuki Kimura (toshi@apache.org)
 * @author Brian Price (pricebe@us.ibm.com)
 */
public class SOAPMonitor extends JFrame implements ActionListener, ChangeListener {

    /**
     * Private data
     */
    private JPanel main_panel = null;

    /**
     * Field tabbed_pane
     */
    private JTabbedPane tabbed_pane = null;

    /**
     * Field top_pane
     */
    private JTabbedPane top_pane = null;

    /**
     * Field port
     */
    private int port = 5001;

    /**
     * Field axisHost
     */
    private String axisHost = "localhost";

    /**
     * Field axisPort
     */
    private int axisPort = 8080;

    /**
     * Field axisURL
     */
    private String axisURL = null;

    /**
     * Field pages
     */
    private Vector pages = null;

    /**
     * Field titleStr
     */
    private final String titleStr = "SOAP Monitor Administration";

    /**
     * Field set_panel
     */
    private JPanel set_panel = null;

    /**
     * Field titleLabel
     */
    private JLabel titleLabel = null;

    /**
     * Field add_btn
     */
    private JButton add_btn = null;

    /**
     * Field del_btn
     */
    private JButton del_btn = null;

    /**
     * Field save_btn
     */
    private JButton save_btn = null;

    /**
     * Field login_btn
     */
    private JButton login_btn = null;

    /**
     * Field model1
     */
    private DefaultListModel model1 = null;

    /**
     * Field model2
     */
    private DefaultListModel model2 = null;

    /**
     * Field list1
     */
    private JList list1 = null;

    /**
     * Field list2
     */
    private JList list2 = null;

    /**
     * Field serviceMap
     */
    private HashMap serviceMap = null;

    /**
     * Field originalDoc
     */
    private Document originalDoc = null;

    /**
     * Field axisUser
     */
    private static String axisUser = null;

    /**
     * Field axisPass
     */
    private static String axisPass = null;

    /**
     * Field adminClient
     */
    private AdminClient adminClient = new AdminClient();

    /**
     * Main method for this class
     * 
     * @param args 
     * @throws Exception 
     */
    public static void main(String args[]) throws Exception {
        SOAPMonitor soapMonitor = null;
        Options opts = new Options(args);
        if (opts.isFlagSet('?') > 0) {
            System.out.println(
                    "Usage: SOAPMonitor [-l<url>] [-u<user>] [-w<password>] [-?]");
            System.exit(0);
        }

        // Create an instance
        soapMonitor = new SOAPMonitor();

        // GET Axis URL.
        // The default is "http://localhost:8080/axis/servlet/AxisServlet"
        soapMonitor.axisURL = opts.getURL();
        URL url = new URL(soapMonitor.axisURL);
        soapMonitor.axisHost = url.getHost();

        // GET User name & Password
        axisUser = opts.getUser();
        axisPass = opts.getPassword();

        // Login and start application
        soapMonitor.doLogin();
    }

    /**
     * Constructor
     */
    public SOAPMonitor() {
        setTitle("SOAP Monitor Application");
        Dimension d = getToolkit().getScreenSize();
        setSize(640, 480);
        setLocation((d.width - getWidth()) / 2, (d.height - getHeight()) / 2);
        setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
        addWindowListener(new MyWindowAdapter());

        // Try to use the system look and feel
        try {
            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
        } catch (Exception e) {
        }

        // Create main panel to hold notebook
        main_panel = new JPanel();
        main_panel.setBackground(Color.white);
        main_panel.setLayout(new BorderLayout());
        top_pane = new JTabbedPane();
        set_panel = new JPanel();

        // label for NORTH panel to display the pain title
        titleLabel = new JLabel(titleStr);
        titleLabel.setFont(new Font("Serif", Font.BOLD, 18));

        // list control for WEST panel to list NOT monitored services
        model1 = new DefaultListModel();
        list1 = new JList(model1);
        list1.setFixedCellWidth(250);
        JScrollPane scroll1 = new JScrollPane(list1);

        // list control for EAST panel to list monitored services
        model2 = new DefaultListModel();
        list2 = new JList(model2);
        list2.setFixedCellWidth(250);
        JScrollPane scroll2 = new JScrollPane(list2);

        // buttons for CENTER panel to chage the monitoring state
        add_btn = new JButton("Turn On [ >> ]");
        del_btn = new JButton("[ << ] Turn Off");
        JPanel center_panel = new JPanel();
        GridBagLayout layout = new GridBagLayout();
        center_panel.setLayout(layout);
        GridBagConstraints c = new GridBagConstraints();
        c.gridx = 0;
        c.gridy = 0;
        c.insets = new Insets(10, 10, 10, 10);
        layout.setConstraints(add_btn, c);
        center_panel.add(add_btn);
        c.gridx = 0;
        c.gridy = 1;
        c.insets = new Insets(10, 10, 10, 10);
        layout.setConstraints(del_btn, c);
        center_panel.add(del_btn);

        // buttons for SOUTH panel
        save_btn = new JButton("Save changes");
        login_btn = new JButton("Change server");
        JPanel south_panel = new JPanel();
        layout = new GridBagLayout();
        c.gridx = 0;
        c.gridy = 0;
        c.insets = new Insets(10, 10, 10, 10);
        layout.setConstraints(save_btn, c);
        south_panel.add(save_btn);
        c.gridx = 1;
        c.gridy = 0;
        c.insets = new Insets(10, 10, 10, 10);
        layout.setConstraints(login_btn, c);
        south_panel.add(login_btn);

        // set all controls to the border layout
        set_panel.setLayout(new BorderLayout(5, 5));
        set_panel.add(titleLabel, BorderLayout.NORTH);
        set_panel.add(south_panel, BorderLayout.SOUTH);
        set_panel.add(scroll1, BorderLayout.WEST);
        set_panel.add(scroll2, BorderLayout.EAST);
        set_panel.add(center_panel, BorderLayout.CENTER);

        // register the Action Listener
        add_btn.addActionListener(this);
        del_btn.addActionListener(this);
        save_btn.addActionListener(this);
        login_btn.addActionListener(this);

        // set default button state as 'false'
        add_btn.setEnabled(false);
        del_btn.setEnabled(false);
        save_btn.setEnabled(false);
        login_btn.setEnabled(false);
        top_pane.add("Setting", set_panel);
        top_pane.add("Monitoring", main_panel);
        getContentPane().add(top_pane);

        // Create the notebook
        tabbed_pane = new JTabbedPane(JTabbedPane.TOP);
        main_panel.add(tabbed_pane, BorderLayout.CENTER);
        top_pane.addChangeListener(this);
        top_pane.setEnabled(false);
        setVisible(true);
    }

    /**
     * Do login process
     * 
     * @return 
     */
    private boolean doLogin() {
        Dimension d = null;

        // Login
        LoginDlg login = new LoginDlg();
        login.show();
        if (!login.isLogin()) {
            login_btn.setEnabled(true);
            return false;
        }
        login.dispose();
        save_btn.setEnabled(false);
        login_btn.setEnabled(false);

        // Get the axisHost & axisPort to be used
        String url_str = login.getURL();
        try {
            URL url = new URL(url_str);
            axisHost = url.getHost();
            axisPort = url.getPort();
            if (axisPort == -1) {
                axisPort = 8080;
            }
            String axisPath = url.getPath();
            axisURL = "http://" + axisHost + ":" + axisPort + axisPath;
        } catch (MalformedURLException e) {
            JOptionPane pane = new JOptionPane();
            String msg = e.toString();
            pane.setMessageType(JOptionPane.WARNING_MESSAGE);
            pane.setMessage(msg);
            pane.setOptions(new String[]{"OK"});
            JDialog dlg = pane.createDialog(null, "Login status");
            dlg.setVisible(true);
            login_btn.setEnabled(true);
            return false;
        }
        titleLabel.setText(titleStr + " for [" + axisHost + ":" + axisPort
                + "]");
        final JProgressBar progressBar = new JProgressBar(0, 100);
        BarThread stepper = new BarThread(progressBar);
        stepper.start();
        JFrame progress = new JFrame();
        d = new Dimension(250, 50);
        progress.setSize(d);
        d = getToolkit().getScreenSize();
        progress.getContentPane().add(progressBar);
        progress.setTitle("Now loading data ...");
        progress.setLocation((d.width - progress.getWidth()) / 2,
                (d.height - progress.getHeight()) / 2);
        progress.show();

        // Add notebook page for default host connection
        pages = new Vector();
        addPage(new SOAPMonitorPage(axisHost));
        serviceMap = new HashMap();
        originalDoc = getServerWSDD();
        model1.clear();
        model2.clear();
        if (originalDoc != null) {
            String ret = null;
            NodeList nl = originalDoc.getElementsByTagName("service");
            for (int i = 0; i < nl.getLength(); i++) {
                Node node = nl.item(i);
                NamedNodeMap map = node.getAttributes();
                ret = map.getNamedItem("name").getNodeValue();
                serviceMap.put(ret, node);
                if (!isMonitored(node)) {
                    model1.addElement((String) ret);
                } else {
                    model2.addElement((String) ret);
                }
            }
            if (model1.size() > 0) {
                add_btn.setEnabled(true);
            }
            if (model2.size() > 0) {
                del_btn.setEnabled(true);
            }
            progress.dispose();
            save_btn.setEnabled(true);
            login_btn.setEnabled(true);
            top_pane.setEnabled(true);
            return true;
        } else {
            progress.dispose();
            login_btn.setEnabled(true);
            return false;
        }
    }

    /**
     * This class is a thred for a JProgressBar.
     */
    class BarThread extends Thread {

        /**
         * Field wait
         */
        private int wait = 100;

        /**
         * Field progressBar
         */
        JProgressBar progressBar = null;

        /**
         * Constructor BarThread
         * 
         * @param bar 
         */
        public BarThread(JProgressBar bar) {
            progressBar = bar;
        }

        /**
         * Method run
         */
        public void run() {
            int min = progressBar.getMinimum();
            int max = progressBar.getMaximum();
            Runnable runner = new Runnable() {
                public void run() {
                    int val = progressBar.getValue();
                    progressBar.setValue(val + 1);
                }
            };
            for (int i = min; i < max; i++) {
                try {
                    SwingUtilities.invokeAndWait(runner);
                    Thread.sleep(wait);
                } catch (InterruptedException ignoredException) {
                } catch (InvocationTargetException ignoredException) {
                }
            }
        }
    }

    /**
     * Get the server-config.wsdd as a document to retrieve deployed services
     * 
     * @return 
     */
    private Document getServerWSDD() {
        Document doc = null;
        try {
            String[] param = new String[]{"-u" + axisUser, "-w" + axisPass,
                                          "-l " + axisURL, "list"};
            String ret = adminClient.process(param);
            doc = XMLUtils.newDocument(
                    new ByteArrayInputStream(ret.getBytes()));
        } catch (Exception e) {
            JOptionPane pane = new JOptionPane();
            String msg = e.toString();
            pane.setMessageType(JOptionPane.WARNING_MESSAGE);
            pane.setMessage(msg);
            pane.setOptions(new String[]{"OK"});
            JDialog dlg = pane.createDialog(null, "Login status");
            dlg.setVisible(true);
        }
        return doc;
    }

    /**
     * Deploy the specified wsdd to change the monitoring state
     * 
     * @param wsdd 
     * @return 
     */
    private boolean doDeploy(Document wsdd) {
        String deploy = null;
        Options opt = null;
        deploy = XMLUtils.DocumentToString(wsdd);
        try {
            String[] param = new String[]{"-u" + axisUser, "-w" + axisPass,
                                          "-l " + axisURL, ""};
            opt = new Options(param);
            adminClient.process(opt,
                    new ByteArrayInputStream(deploy.getBytes()));
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    /**
     * Get a new document which has the specified node as the document root
     * 
     * @param target 
     * @return 
     */
    private Document getNewDocumentAsNode(Node target) {
        Document doc = null;
        Node node = null;
        try {
            doc = XMLUtils.newDocument();
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        }
        node = doc.importNode(target, true);
        doc.appendChild(node);
        return doc;
    }

    /**
     * Add needed nodes for monitoring to the specified node
     * <p/>
     * TODO: support JAX-RPC type definition (i.e. <handlerInfoChain/>)
     * 
     * @param target 
     * @return 
     */
    private Node addMonitor(Node target) {
        Document doc = null;
        Node node = null;
        Node newNode = null;
        String ret = null;
        NodeList nl = null;
        final String reqFlow = "requestFlow";
        final String resFlow = "responseFlow";
        final String monitor = "soapmonitor";
        final String handler = "handler";
        final String type = "type";
        doc = getNewDocumentAsNode(target);

        // Add "responseFlow node
        nl = doc.getElementsByTagName(resFlow);
        if (nl.getLength() == 0) {
            node = doc.getDocumentElement().getFirstChild();
            newNode = doc.createElement(resFlow);
            doc.getDocumentElement().insertBefore(newNode, node);
        }

        // Add "requestFlow" node
        nl = doc.getElementsByTagName(reqFlow);
        if (nl.getLength() == 0) {
            node = doc.getDocumentElement().getFirstChild();
            newNode = doc.createElement(reqFlow);
            doc.getDocumentElement().insertBefore(newNode, node);
        }

        // Add "handler" node and "soapmonitor" attribute for "requestFlow"
        nl = doc.getElementsByTagName(reqFlow);
        node = nl.item(0).getFirstChild();
        newNode = doc.createElement(handler);
        ((Element) newNode).setAttribute(type, monitor);
        nl.item(0).insertBefore(newNode, node);

        // Add "handler" node and "soapmonitor" attribute for "responseFlow"
        nl = doc.getElementsByTagName(resFlow);
        node = nl.item(0).getFirstChild();
        newNode = doc.createElement(handler);
        ((Element) newNode).setAttribute(type, monitor);
        nl.item(0).insertBefore(newNode, node);
        
        return (Node) doc.getDocumentElement();
    }

    /**
     * Remove a few nodes for stoping monitor from the specified node
     * <p/>
     * TODO: support JAX-RPC type definition (i.e. <handlerInfoChain/>)
     * 
     * @param target 
     * @return 
     */
    private Node delMonitor(Node target) {
        Document doc = null;
        Node node = null;
        Node newNode = null;
        String ret = null;
        NodeList nl = null;
        final String reqFlow = "requestFlow";
        final String resFlow = "responseFlow";
        final String monitor = "soapmonitor";
        final String handler = "handler";
        final String type = "type";
        doc = getNewDocumentAsNode(target);
        nl = doc.getElementsByTagName(handler);
        int size;
        size = nl.getLength();
        Node[] removeNode = new Node[size];
        if (size > 0) {
            newNode = nl.item(0).getParentNode();
        }
        for (int i = 0; i < size; i++) {
            node = nl.item(i);
            NamedNodeMap map = node.getAttributes();
            ret = map.getNamedItem(type).getNodeValue();
            if (ret.equals(monitor)) {
                removeNode[i] = node;
            }
        }
        for (int i = 0; i < size; i++) {
            Node child = removeNode[i];
            if (child != null) {
                child.getParentNode().removeChild(child);
            }
        }

        return (Node) doc.getDocumentElement();
    }

    /**
     * Get a boolean value whether the specified node is monitoring or not
     * 
     * @param target 
     * @return 
     */
    private boolean isMonitored(Node target) {
        Document doc = null;
        Node node = null;
        String ret = null;
        NodeList nl = null;
        final String monitor = "soapmonitor";
        final String handler = "handler";
        final String type = "type";
        doc = getNewDocumentAsNode(target);
        nl = doc.getElementsByTagName(handler);
        for (int i = 0; i < nl.getLength(); i++) {
            node = nl.item(i);
            NamedNodeMap map = node.getAttributes();
            ret = map.getNamedItem(type).getNodeValue();
            if (ret.equals(monitor)) {
                return true;
            } else {
                return false;
            }
        }
        return false;
    }

    /**
     * Add a few nodes for authentification
     * <p/>
     * TODO: support JAX-RPC type definition (i.e. <handlerInfoChain/>)
     * 
     * @param target 
     * @return 
     */
    private Node addAuthenticate(Node target) {
        Document doc = null;
        Node node = null;
        Node newNode = null;
        String ret = null;
        NodeList nl = null;
        final String reqFlow = "requestFlow";
        final String handler = "handler";
        final String type = "type";
        final String authentication =
                "java:org.apache.axis.handlers.SimpleAuthenticationHandler";
        final String authorization =
                "java:org.apache.axis.handlers.SimpleAuthorizationHandler";
        final String param = "parameter";
        final String name = "name";
        final String role = "allowedRoles";
        final String value = "value";
        final String admin = "admin";
        boolean authNode = false;
        boolean roleNode = false;
        doc = getNewDocumentAsNode(target);

        // Add "requestFlow" node
        nl = doc.getElementsByTagName(reqFlow);
        if (nl.getLength() == 0) {
            node = doc.getDocumentElement().getFirstChild();
            newNode = doc.createElement(reqFlow);
            doc.getDocumentElement().insertBefore(newNode, node);
        }

        // Add "SimpleAuthorizationHandler"
        // (i.e. <handler type="java:org.apache.axis.handlers.SimpleAuthorizationHandler"/>)
        nl = doc.getElementsByTagName(handler);
        for (int i = 0; i < nl.getLength(); i++) {
            node = nl.item(i);
            NamedNodeMap map = node.getAttributes();
            ret = map.getNamedItem(type).getNodeValue();
            if (ret.equals(authorization)) {
                authNode = true;
                break;
            }
        }
        if (!authNode) {
            nl = doc.getElementsByTagName(reqFlow);
            node = nl.item(0).getFirstChild();
            newNode = doc.createElement(handler);
            ((Element) newNode).setAttribute(type, authorization);
            nl.item(0).insertBefore(newNode, node);
        }        

        // Add "SimpleAuthenticationHandler"
        // (i.e. <handler type="java:org.apache.axis.handlers.SimpleAuthenticationHandler"/>)
        authNode = false;
        nl = doc.getElementsByTagName(handler);
        for (int i = 0; i < nl.getLength(); i++) {
            node = nl.item(i);
            NamedNodeMap map = node.getAttributes();
            ret = map.getNamedItem(type).getNodeValue();
            if (ret.equals(authentication)) {
                authNode = true;
                break;
            }
        }
        if (!authNode) {
            nl = doc.getElementsByTagName(reqFlow);
            node = nl.item(0).getFirstChild();
            newNode = doc.createElement(handler);
            ((Element) newNode).setAttribute(type, authentication);
            nl.item(0).insertBefore(newNode, node);
        }

        // Add "allowedRoles" (i.e. <parameter name="allowedRoles" value="admin"/> )
        nl = doc.getElementsByTagName(param);
        for (int i = 0; i < nl.getLength(); i++) {
            node = nl.item(i);
            NamedNodeMap map = node.getAttributes();
            node = map.getNamedItem(name);
            if (node != null) {
                ret = node.getNodeValue();
                if (ret.equals(role)) {
                    roleNode = true;
                    break;
                }
            }
        }
        if (!roleNode) {
            nl = doc.getElementsByTagName(param);
            newNode = doc.createElement(param);
            ((Element) newNode).setAttribute(name, role);
            ((Element) newNode).setAttribute(value, admin);
            doc.getDocumentElement().insertBefore(newNode, nl.item(0));
        }
        return (Node) doc.getDocumentElement();
    }

    /**
     * Handle the window close event
     */
    class MyWindowAdapter extends WindowAdapter {

        /**
         * Method windowClosing
         * 
         * @param e 
         */
        public void windowClosing(WindowEvent e) {
            System.exit(0);
        }
    }

    /**
     * Add a page to the notebook
     * 
     * @param pg 
     */
    private void addPage(SOAPMonitorPage pg) {
        tabbed_pane.addTab("  " + pg.getHost() + "  ", pg);
        pages.addElement(pg);
    }

    /**
     * Del all pages to the notebook
     */
    private void delPage() {
        tabbed_pane.removeAll();
        pages.removeAllElements();
    }

    /**
     * Frame is being displayed
     */
    public void start() {
        // Tell all pages to start talking to the server
        Enumeration e = pages.elements();
        while (e.hasMoreElements()) {
            SOAPMonitorPage pg = (SOAPMonitorPage) e.nextElement();
            if (pg != null) {
                pg.start();
            }
        }
    }

    /*
     * Frame is no longer displayed
     */

    /**
     * Method stop
     */
    public void stop() {
        // Tell all pages to stop talking to the server
        Enumeration e = pages.elements();
        while (e.hasMoreElements()) {
            SOAPMonitorPage pg = (SOAPMonitorPage) e.nextElement();
            if (pg != null) {
                pg.stop();
            }
        }
    }

    /**
     * This class is for the Login Dialog
     */
    class LoginDlg extends JDialog implements ActionListener {

        /**
         * Field ok_button
         */
        private JButton ok_button = null;

        /**
         * Field cancel_button
         */
        private JButton cancel_button = null;

        /**
         * Field user
         */
        private JTextField user = new JTextField(20);

        /**
         * Field pass
         */
        private JPasswordField pass = new JPasswordField(20);

        /**
         * Field url
         */
        private JTextField url = new JTextField(20);

        /**
         * Field loginState
         */
        private boolean loginState = false;

        /**
         * Constructor (create and layout page)
         */
        public LoginDlg() {
            setTitle("SOAP Monitor Login");
            UIManager.put("Label.font", new Font("Dialog", Font.BOLD, 12));
            JPanel panel = new JPanel();
            ok_button = new JButton("OK");
            ok_button.addActionListener(this);
            cancel_button = new JButton("Cancel");
            cancel_button.addActionListener(this);

            // default URL for AxisServlet
            url.setText(axisURL);
            JLabel userLabel = new JLabel("User:");
            JLabel passLabel = new JLabel("Password:");
            JLabel urlLabel = new JLabel("Axis URL:");
            userLabel.setHorizontalAlignment(JTextField.RIGHT);
            passLabel.setHorizontalAlignment(JTextField.RIGHT);
            urlLabel.setHorizontalAlignment(JTextField.RIGHT);
            panel.add(userLabel);
            panel.add(user);
            panel.add(passLabel);
            panel.add(pass);
            panel.add(urlLabel);
            panel.add(url);
            panel.add(ok_button);
            panel.add(cancel_button);
            setContentPane(panel);
            user.setText(SOAPMonitor.axisUser);
            pass.setText(SOAPMonitor.axisPass);
            GridLayout layout = new GridLayout(4, 2);
            layout.setHgap(15);
            layout.setVgap(5);
            panel.setLayout(layout);
            setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
            setModal(true);
            pack();
            Dimension d = getToolkit().getScreenSize();
            setLocation((d.width - getWidth()) / 2,
                    (d.height - getHeight()) / 2);
        }

        /**
         * Listener to handle button actions
         * 
         * @param e 
         */
        public void actionPerformed(ActionEvent e) {
            // Check if the user pressed the OK button
            if (e.getSource() == ok_button) {
                loginState = true;
                SOAPMonitor.axisUser = user.getText();
                SOAPMonitor.axisPass = new String(pass.getPassword());
                this.hide();
            } else if (e.getSource() == cancel_button) {
                this.dispose();
            }
        }

        /**
         * Get the URL of the AxisServlet we are using
         * 
         * @return 
         */
        public String getURL() {
            return url.getText();
        }

        /**
         * Get the login status as a boolean
         * 
         * @return 
         */
        public boolean isLogin() {
            return loginState;
        }
    }

    /**
     * This class provides the contents of a notebook page
     * representing a server connection.
     */
    class SOAPMonitorPage extends JPanel
            implements Runnable, ListSelectionListener, ActionListener {

        /**
         * Status Strings
         */
        private final String STATUS_ACTIVE = "The SOAP Monitor is started.";

        /**
         * Field STATUS_STOPPED
         */
        private final String STATUS_STOPPED = "The SOAP Monitor is stopped.";

        /**
         * Field STATUS_CLOSED
         */
        private final String STATUS_CLOSED =
                "The server communication has been terminated.";

        /**
         * Field STATUS_NOCONNECT
         */
        private final String STATUS_NOCONNECT =
                "The SOAP Monitor is unable to communcate with the server.";

        /**
         * Private data
         */
        private String host = null;

        /**
         * Field socket
         */
        private Socket socket = null;

        /**
         * Field in
         */
        private ObjectInputStream in = null;

        /**
         * Field out
         */
        private ObjectOutputStream out = null;

        /**
         * Field model
         */
        private SOAPMonitorTableModel model = null;

        /**
         * Field table
         */
        private JTable table = null;

        /**
         * Field scroll
         */
        private JScrollPane scroll = null;

        /**
         * Field list_panel
         */
        private JPanel list_panel = null;

        /**
         * Field list_buttons
         */
        private JPanel list_buttons = null;

        /**
         * Field remove_button
         */
        private JButton remove_button = null;

        /**
         * Field remove_all_button
         */
        private JButton remove_all_button = null;

        /**
         * Field filter_button
         */
        private JButton filter_button = null;

        /**
         * Field details_panel
         */
        private JPanel details_panel = null;

        /**
         * Field details_header
         */
        private JPanel details_header = null;

        /**
         * Field details_soap
         */
        private JSplitPane details_soap = null;

        /**
         * Field details_buttons
         */
        private JPanel details_buttons = null;

        /**
         * Field details_time
         */
        private JLabel details_time = null;

        /**
         * Field details_target
         */
        private JLabel details_target = null;

        /**
         * Field details_status
         */
        private JLabel details_status = null;

        /**
         * Field details_time_value
         */
        private JLabel details_time_value = null;

        /**
         * Field details_target_value
         */
        private JLabel details_target_value = null;

        /**
         * Field details_status_value
         */
        private JLabel details_status_value = null;

        /**
         * Field empty_border
         */
        private EmptyBorder empty_border = null;

        /**
         * Field etched_border
         */
        private EtchedBorder etched_border = null;

        /**
         * Field request_panel
         */
        private JPanel request_panel = null;

        /**
         * Field response_panel
         */
        private JPanel response_panel = null;

        /**
         * Field request_label
         */
        private JLabel request_label = null;

        /**
         * Field response_label
         */
        private JLabel response_label = null;

        /**
         * Field request_text
         */
        private SOAPMonitorTextArea request_text = null;

        /**
         * Field response_text
         */
        private SOAPMonitorTextArea response_text = null;

        /**
         * Field request_scroll
         */
        private JScrollPane request_scroll = null;

        /**
         * Field response_scroll
         */
        private JScrollPane response_scroll = null;

        /**
         * Field layout_button
         */
        private JButton layout_button = null;

        /**
         * Field split
         */
        private JSplitPane split = null;

        /**
         * Field status_area
         */
        private JPanel status_area = null;

        /**
         * Field status_buttons
         */
        private JPanel status_buttons = null;

        /**
         * Field start_button
         */
        private JButton start_button = null;

        /**
         * Field stop_button
         */
        private JButton stop_button = null;

        /**
         * Field status_text
         */
        private JLabel status_text = null;

        /**
         * Field status_text_panel
         */
        private JPanel status_text_panel = null;

        /**
         * Field filter
         */
        private SOAPMonitorFilter filter = null;

        /**
         * Field details_header_layout
         */
        private GridBagLayout details_header_layout = null;

        /**
         * Field details_header_constraints
         */
        private GridBagConstraints details_header_constraints = null;

        /**
         * Field reflow_xml
         */
        private JCheckBox reflow_xml = null;

        /**
         * Constructor (create and layout page)
         * 
         * @param host_name 
         */
        public SOAPMonitorPage(String host_name) {
            host = host_name;

            // Set up default filter (show all messages)
            filter = new SOAPMonitorFilter();

            // Use borders to help improve appearance
            etched_border = new EtchedBorder();

            // Build top portion of split (list panel)
            model = new SOAPMonitorTableModel();
            table = new JTable(model);
            table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
            table.setRowSelectionInterval(0, 0);
            table.setPreferredScrollableViewportSize(new Dimension(600, 96));
            table.getSelectionModel().addListSelectionListener(this);
            scroll = new JScrollPane(table);
            remove_button = new JButton("Remove");
            remove_button.addActionListener(this);
            remove_button.setEnabled(false);
            remove_all_button = new JButton("Remove All");
            remove_all_button.addActionListener(this);
            filter_button = new JButton("Filter ...");
            filter_button.addActionListener(this);
            list_buttons = new JPanel();
            list_buttons.setLayout(new FlowLayout());
            list_buttons.add(remove_button);
            list_buttons.add(remove_all_button);
            list_buttons.add(filter_button);
            list_panel = new JPanel();
            list_panel.setLayout(new BorderLayout());
            list_panel.add(scroll, BorderLayout.CENTER);
            list_panel.add(list_buttons, BorderLayout.SOUTH);
            list_panel.setBorder(empty_border);

            // Build bottom portion of split (message details)
            details_time = new JLabel("Time: ", SwingConstants.RIGHT);
            details_target = new JLabel("Target Service: ",
                    SwingConstants.RIGHT);
            details_status = new JLabel("Status: ", SwingConstants.RIGHT);
            details_time_value = new JLabel();
            details_target_value = new JLabel();
            details_status_value = new JLabel();
            Dimension preferred_size = details_time.getPreferredSize();
            preferred_size.width = 1;
            details_time.setPreferredSize(preferred_size);
            details_target.setPreferredSize(preferred_size);
            details_status.setPreferredSize(preferred_size);
            details_time_value.setPreferredSize(preferred_size);
            details_target_value.setPreferredSize(preferred_size);
            details_status_value.setPreferredSize(preferred_size);
            details_header = new JPanel();
            details_header_layout = new GridBagLayout();
            details_header.setLayout(details_header_layout);
            details_header_constraints = new GridBagConstraints();
            details_header_constraints.fill = GridBagConstraints.BOTH;
            details_header_constraints.weightx = 0.5;
            details_header_layout.setConstraints(details_time,
                    details_header_constraints);
            details_header.add(details_time);
            details_header_layout.setConstraints(details_time_value,
                    details_header_constraints);
            details_header.add(details_time_value);
            details_header_layout.setConstraints(details_target,
                    details_header_constraints);
            details_header.add(details_target);
            details_header_constraints.weightx = 1.0;
            details_header_layout.setConstraints(details_target_value,
                    details_header_constraints);
            details_header.add(details_target_value);
            details_header_constraints.weightx = .5;
            details_header_layout.setConstraints(details_status,
                    details_header_constraints);
            details_header.add(details_status);
            details_header_layout.setConstraints(details_status_value,
                    details_header_constraints);
            details_header.add(details_status_value);
            details_header.setBorder(etched_border);
            request_label = new JLabel("SOAP Request", SwingConstants.CENTER);
            request_text = new SOAPMonitorTextArea();
            request_text.setEditable(false);
            request_scroll = new JScrollPane(request_text);
            request_panel = new JPanel();
            request_panel.setLayout(new BorderLayout());
            request_panel.add(request_label, BorderLayout.NORTH);
            request_panel.add(request_scroll, BorderLayout.CENTER);
            response_label =
                    new JLabel("SOAP Response", SwingConstants.CENTER);
            response_text = new SOAPMonitorTextArea();
            response_text.setEditable(false);
            response_scroll = new JScrollPane(response_text);
            response_panel = new JPanel();
            response_panel.setLayout(new BorderLayout());
            response_panel.add(response_label, BorderLayout.NORTH);
            response_panel.add(response_scroll, BorderLayout.CENTER);
            details_soap = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
            details_soap.setTopComponent(request_panel);
            details_soap.setRightComponent(response_panel);
            details_soap.setResizeWeight(.5);
            details_panel = new JPanel();
            layout_button = new JButton("Switch Layout");
            layout_button.addActionListener(this);
            reflow_xml = new JCheckBox("Reflow XML text");
            reflow_xml.addActionListener(this);
            details_buttons = new JPanel();
            details_buttons.setLayout(new FlowLayout());
            details_buttons.add(reflow_xml);
            details_buttons.add(layout_button);
            details_panel.setLayout(new BorderLayout());
            details_panel.add(details_header, BorderLayout.NORTH);
            details_panel.add(details_soap, BorderLayout.CENTER);
            details_panel.add(details_buttons, BorderLayout.SOUTH);
            details_panel.setBorder(empty_border);

            // Add the two parts to the age split pane
            split = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
            split.setTopComponent(list_panel);
            split.setRightComponent(details_panel);

            // Build status area
            start_button = new JButton("Start");
            start_button.addActionListener(this);
            stop_button = new JButton("Stop");
            stop_button.addActionListener(this);
            status_buttons = new JPanel();
            status_buttons.setLayout(new FlowLayout());
            status_buttons.add(start_button);
            status_buttons.add(stop_button);
            status_text = new JLabel();
            status_text.setBorder(new BevelBorder(BevelBorder.LOWERED));
            status_text_panel = new JPanel();
            status_text_panel.setLayout(new BorderLayout());
            status_text_panel.add(status_text, BorderLayout.CENTER);
            status_text_panel.setBorder(empty_border);
            status_area = new JPanel();
            status_area.setLayout(new BorderLayout());
            status_area.add(status_buttons, BorderLayout.WEST);
            status_area.add(status_text_panel, BorderLayout.CENTER);
            status_area.setBorder(etched_border);

            // Add the split and status area to page
            setLayout(new BorderLayout());
            add(split, BorderLayout.CENTER);
            add(status_area, BorderLayout.SOUTH);
        }

        /**
         * Get the name of the host we are displaying
         * 
         * @return 
         */
        public String getHost() {
            return host;
        }

        /**
         * Set the status text
         * 
         * @param txt 
         */
        public void setStatus(String txt) {
            status_text.setForeground(Color.black);
            status_text.setText("  " + txt);
        }

        /**
         * Set the status text to an error
         * 
         * @param txt 
         */
        public void setErrorStatus(String txt) {
            status_text.setForeground(Color.red);
            status_text.setText("  " + txt);
        }

        /**
         * Start talking to the server
         */
        public void start() {
            String codehost = axisHost;
            if (socket == null) {
                try {
                    // Open the socket to the server
                    socket = new Socket(codehost, port);

                    // Create output stream
                    out = new ObjectOutputStream(socket.getOutputStream());
                    out.flush();

                    // Create input stream and start background
                    // thread to read data from the server
                    in = new ObjectInputStream(socket.getInputStream());
                    new Thread(this).start();
                } catch (Exception e) {
                    // Exceptions here are unexpected, but we can't
                    // really do anything (so just write it to stdout
                    // in case someone cares and then ignore it)
                    e.printStackTrace();
                    setErrorStatus(STATUS_NOCONNECT);
                    socket = null;
                }
            } else {
                // Already started
            }
            if (socket != null) {
                // Make sure the right buttons are enabled
                start_button.setEnabled(false);
                stop_button.setEnabled(true);
                setStatus(STATUS_ACTIVE);
            }
        }

        /**
         * Stop talking to the server
         */
        public void stop() {
            if (socket != null) {
                // Close all the streams and socket
                if (out != null) {
                    try {
                        out.close();
                    } catch (IOException ioe) {
                    }
                    out = null;
                }
                if (in != null) {
                    try {
                        in.close();
                    } catch (IOException ioe) {
                    }
                    in = null;
                }
                if (socket != null) {
                    try {
                        socket.close();
                    } catch (IOException ioe) {
                    }
                    socket = null;
                }
            } else {
                // Already stopped
            }

            // Make sure the right buttons are enabled
            start_button.setEnabled(true);
            stop_button.setEnabled(false);
            setStatus(STATUS_STOPPED);
        }

        /**
         * Background thread used to receive data from
         * the server.
         */
        public void run() {
            Long id;
            Integer message_type;
            String target;
            String soap;
            SOAPMonitorData data;
            int selected;
            int row;
            boolean update_needed;
            while (socket != null) {
                try {
                    // Get the data from the server
                    message_type = (Integer) in.readObject();

                    // Process the data depending on its type
                    switch (message_type.intValue()) {
                        case SOAPMonitorConstants.SOAP_MONITOR_REQUEST:

                            // Get the id, target and soap info
                            id = (Long) in.readObject();
                            target = (String) in.readObject();
                            soap = (String) in.readObject();

                            // Add new request data to the table
                            data = new SOAPMonitorData(id, target, soap);
                            model.addData(data);

                            // If "most recent" selected then update
                            // the details area if needed
                            selected = table.getSelectedRow();
                            if ((selected == 0) && model.filterMatch(data)) {
                                valueChanged(null);
                            }
                            break;
                        case SOAPMonitorConstants.SOAP_MONITOR_RESPONSE:

                            // Get the id and soap info
                            id = (Long) in.readObject();
                            soap = (String) in.readObject();
                            data = model.findData(id);
                            if (data != null) {
                                update_needed = false;

                                // Get the selected row
                                selected = table.getSelectedRow();

                                // If "most recent", then always
                                // update details area
                                if (selected == 0) {
                                    update_needed = true;
                                }

                                // If the data being updated is
                                // selected then update details
                                row = model.findRow(data);
                                if ((row != -1) && (row == selected)) {
                                    update_needed = true;
                                }

                                // Set the response and update table
                                data.setSOAPResponse(soap);
                                model.updateData(data);

                                // Refresh details area (if needed)
                                if (update_needed) {
                                    valueChanged(null);
                                }
                            }
                            break;
                    }
                } catch (Exception e) {
                    // Exceptions are expected here when the
                    // server communication has been terminated.
                    if (stop_button.isEnabled()) {
                        stop();
                        setErrorStatus(STATUS_CLOSED);
                    }
                }
            }
        }

        /**
         * Listener to handle table selection changes
         * 
         * @param e 
         */
        public void valueChanged(ListSelectionEvent e) {
            int row = table.getSelectedRow();

            // Check if they selected a specific row
            if (row > 0) {
                remove_button.setEnabled(true);
            } else {
                remove_button.setEnabled(false);
            }

            // Check for "most recent" selection
            if (row == 0) {
                row = model.getRowCount() - 1;
                if (row == 0) {
                    row = -1;
                }
            }
            if (row == -1) {
                // Clear the details panel
                details_time_value.setText("");
                details_target_value.setText("");
                details_status_value.setText("");
                request_text.setText("");
                response_text.setText("");
            } else {
                // Show the details for the row
                SOAPMonitorData soap = model.getData(row);
                details_time_value.setText(soap.getTime());
                details_target_value.setText(soap.getTargetService());
                details_status_value.setText(soap.getStatus());
                if (soap.getSOAPRequest() == null) {
                    request_text.setText("");
                } else {
                    request_text.setText(soap.getSOAPRequest());
                    request_text.setCaretPosition(0);
                }
                if (soap.getSOAPResponse() == null) {
                    response_text.setText("");
                } else {
                    response_text.setText(soap.getSOAPResponse());
                    response_text.setCaretPosition(0);
                }
            }
        }

        /**
         * Listener to handle button actions
         * 
         * @param e 
         */
        public void actionPerformed(ActionEvent e) {
            // Check if the user pressed the remove button
            if (e.getSource() == remove_button) {
                int row = table.getSelectedRow();
                model.removeRow(row);
                table.clearSelection();
                table.repaint();
                valueChanged(null);
            }

            // Check if the user pressed the remove all button
            if (e.getSource() == remove_all_button) {
                model.clearAll();
                table.setRowSelectionInterval(0, 0);
                table.repaint();
                valueChanged(null);
            }

            // Check if the user pressed the filter button
            if (e.getSource() == filter_button) {
                filter.showDialog();
                if (filter.okPressed()) {
                    // Update the display with new filter
                    model.setFilter(filter);
                    table.repaint();
                }
            }

            // Check if the user pressed the start button
            if (e.getSource() == start_button) {
                start();
            }

            // Check if the user pressed the stop button
            if (e.getSource() == stop_button) {
                stop();
            }

            // Check if the user wants to switch layout
            if (e.getSource() == layout_button) {
                details_panel.remove(details_soap);
                details_soap.removeAll();
                if (details_soap.getOrientation()
                        == JSplitPane.HORIZONTAL_SPLIT) {
                    details_soap = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
                } else {
                    details_soap = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
                }
                details_soap.setTopComponent(request_panel);
                details_soap.setRightComponent(response_panel);
                details_soap.setResizeWeight(.5);
                details_panel.add(details_soap, BorderLayout.CENTER);
                details_panel.validate();
                details_panel.repaint();
            }

            // Check if the user is changing the reflow option
            if (e.getSource() == reflow_xml) {
                request_text.setReflowXML(reflow_xml.isSelected());
                response_text.setReflowXML(reflow_xml.isSelected());
            }
        }
    }

    /**
     * This class represend the data for a SOAP request/response pair
     */
    class SOAPMonitorData {

        /**
         * Private data
         */
        private Long id;

        /**
         * Field time
         */
        private String time;

        /**
         * Field target
         */
        private String target;

        /**
         * Field soap_request
         */
        private String soap_request;

        /**
         * Field soap_response
         */
        private String soap_response;

        /**
         * Constructor
         * 
         * @param id           
         * @param target       
         * @param soap_request 
         */
        public SOAPMonitorData(Long id, String target, String soap_request) {
            this.id = id;

            // A null id is used to signal that the "most recent" entry
            // is being created.
            if (id == null) {
                this.time = "Most Recent";
                this.target = "---";
                this.soap_request = null;
                this.soap_response = null;
            } else {
                this.time =
                        DateFormat.getTimeInstance().format(new Date());
                this.target = target;
                this.soap_request = soap_request;
                this.soap_response = null;
            }
        }

        /**
         * Get the id for the SOAP message
         * 
         * @return 
         */
        public Long getId() {
            return id;
        }

        /**
         * Get the time the SOAP request was received by the application
         * 
         * @return 
         */
        public String getTime() {
            return time;
        }

        /**
         * Get the SOAP request target service name
         * 
         * @return 
         */
        public String getTargetService() {
            return target;
        }

        /**
         * Get the status of the request
         * 
         * @return 
         */
        public String getStatus() {
            String status = "---";
            if (id != null) {
                status = "Complete";
                if (soap_response == null) {
                    status = "Active";
                }
            }
            return status;
        }

        /**
         * Get the request SOAP contents
         * 
         * @return 
         */
        public String getSOAPRequest() {
            return soap_request;
        }

        /**
         * Set the resposne SOAP contents
         * 
         * @param response 
         */
        public void setSOAPResponse(String response) {
            soap_response = response;
        }

        /**
         * Get the response SOAP contents
         * 
         * @return 
         */
        public String getSOAPResponse() {
            return soap_response;
        }
    }

    /**
     * This table model is used to manage the table displayed
     * at the top of the page to show all the SOAP messages
     * we have received and to control which message details are
     * to be displayed on the bottom of the page.
     */
    class SOAPMonitorTableModel extends AbstractTableModel {

        /**
         * Column titles
         */
        private final String[] column_names = {"Time", "Target Service",
                                               "Status"};

        /**
         * Private data
         */
        private Vector data;

        /**
         * Field filter_include
         */
        private Vector filter_include;

        /**
         * Field filter_exclude
         */
        private Vector filter_exclude;

        /**
         * Field filter_active
         */
        private boolean filter_active;

        /**
         * Field filter_complete
         */
        private boolean filter_complete;

        /**
         * Field filter_data
         */
        private Vector filter_data;

        /**
         * Constructor
         */
        public SOAPMonitorTableModel() {
            data = new Vector();

            // Add "most recent" entry to top of table
            SOAPMonitorData soap = new SOAPMonitorData(null, null, null);
            data.addElement(soap);
            filter_include = null;
            filter_exclude = null;
            filter_active = false;
            filter_complete = false;
            filter_data = null;

            // By default, exclude NotificationService and
            // EventViewerService messages
            filter_exclude = new Vector();
            filter_exclude.addElement("NotificationService");
            filter_exclude.addElement("EventViewerService");
            filter_data = new Vector();
            filter_data.addElement(soap);
        }

        /**
         * Get column count (part of table model interface)
         * 
         * @return 
         */
        public int getColumnCount() {
            return column_names.length;
        }

        /**
         * Get row count (part of table model interface)
         * 
         * @return 
         */
        public int getRowCount() {
            int count = data.size();
            if (filter_data != null) {
                count = filter_data.size();
            }
            return count;
        }

        /**
         * Get column name (part of table model interface)
         * 
         * @param col 
         * @return 
         */
        public String getColumnName(int col) {
            return column_names[col];
        }

        /**
         * Get value at (part of table model interface)
         * 
         * @param row 
         * @param col 
         * @return 
         */
        public Object getValueAt(int row, int col) {
            SOAPMonitorData soap;
            String value = null;
            soap = (SOAPMonitorData) data.elementAt(row);
            if (filter_data != null) {
                soap = (SOAPMonitorData) filter_data.elementAt(row);
            }
            switch (col) {
                case 0:
                    value = soap.getTime();
                    break;
                case 1:
                    value = soap.getTargetService();
                    break;
                case 2:
                    value = soap.getStatus();
                    break;
            }
            return value;
        }

        /**
         * Check if soap data matches filter
         * 
         * @param soap 
         * @return 
         */
        public boolean filterMatch(SOAPMonitorData soap) {
            boolean match = true;
            if (filter_include != null) {
                // Check for service match
                Enumeration e = filter_include.elements();
                match = false;
                while (e.hasMoreElements() && !match) {
                    String service = (String) e.nextElement();
                    if (service.equals(soap.getTargetService())) {
                        match = true;
                    }
                }
            }
            if (filter_exclude != null) {
                // Check for service match
                Enumeration e = filter_exclude.elements();
                while (e.hasMoreElements() && match) {
                    String service = (String) e.nextElement();
                    if (service.equals(soap.getTargetService())) {
                        match = false;
                    }
                }
            }
            if (filter_active) {
                // Check for active status match
                if (soap.getSOAPResponse() != null) {
                    match = false;
                }
            }
            if (filter_complete) {
                // Check for complete status match
                if (soap.getSOAPResponse() == null) {
                    match = false;
                }
            }

            // The "most recent" is always a match
            if (soap.getId() == null) {
                match = true;
            }
            return match;
        }

        /**
         * Add data to the table as a new row
         * 
         * @param soap 
         */
        public void addData(SOAPMonitorData soap) {
            int row = data.size();
            data.addElement(soap);
            if (filter_data != null) {
                if (filterMatch(soap)) {
                    row = filter_data.size();
                    filter_data.addElement(soap);
                    fireTableRowsInserted(row, row);
                }
            } else {
                fireTableRowsInserted(row, row);
            }
        }

        /**
         * Find the data for a given id
         * 
         * @param id 
         * @return 
         */
        public SOAPMonitorData findData(Long id) {
            SOAPMonitorData soap = null;
            for (int row = data.size(); (row > 0) && (soap == null); row--) {
                soap = (SOAPMonitorData) data.elementAt(row - 1);
                if (soap.getId().longValue() != id.longValue()) {
                    soap = null;
                }
            }
            return soap;
        }

        /**
         * Find the row in the table for a given message id
         * 
         * @param soap 
         * @return 
         */
        public int findRow(SOAPMonitorData soap) {
            int row = -1;
            if (filter_data != null) {
                row = filter_data.indexOf(soap);
            } else {
                row = data.indexOf(soap);
            }
            return row;
        }

        /**
         * Remove all messages from the table (but leave "most recent")
         */
        public void clearAll() {
            int last_row = data.size() - 1;
            if (last_row > 0) {
                data.removeAllElements();
                SOAPMonitorData soap = new SOAPMonitorData(null, null, null);
                data.addElement(soap);
                if (filter_data != null) {
                    filter_data.removeAllElements();
                    filter_data.addElement(soap);
                }
                fireTableDataChanged();
            }
        }

        /**
         * Remove a message from the table
         * 
         * @param row 
         */
        public void removeRow(int row) {
            SOAPMonitorData soap = null;
            if (filter_data == null) {
                soap = (SOAPMonitorData) data.elementAt(row);
                data.remove(soap);
            } else {
                soap = (SOAPMonitorData) filter_data.elementAt(row);
                filter_data.remove(soap);
                data.remove(soap);
            }
            fireTableRowsDeleted(row, row);
        }

        /**
         * Set a new filter
         * 
         * @param filter 
         */
        public void setFilter(SOAPMonitorFilter filter) {
            // Save new filter criteria
            filter_include = filter.getFilterIncludeList();
            filter_exclude = filter.getFilterExcludeList();
            filter_active = filter.getFilterActive();
            filter_complete = filter.getFilterComplete();
            applyFilter();
        }

        /**
         * Refilter the list of messages
         */
        public void applyFilter() {
            // Re-filter using new criteria
            filter_data = null;
            if ((filter_include != null) || (filter_exclude != null)
                    || filter_active || filter_complete) {
                filter_data = new Vector();
                Enumeration e = data.elements();
                SOAPMonitorData soap;
                while (e.hasMoreElements()) {
                    soap = (SOAPMonitorData) e.nextElement();
                    if (filterMatch(soap)) {
                        filter_data.addElement(soap);
                    }
                }
            }
            fireTableDataChanged();
        }

        /**
         * Get the data for a row
         * 
         * @param row 
         * @return 
         */
        public SOAPMonitorData getData(int row) {
            SOAPMonitorData soap = null;
            if (filter_data == null) {
                soap = (SOAPMonitorData) data.elementAt(row);
            } else {
                soap = (SOAPMonitorData) filter_data.elementAt(row);
            }
            return soap;
        }

        /**
         * Update a message
         * 
         * @param soap 
         */
        public void updateData(SOAPMonitorData soap) {
            int row;
            if (filter_data == null) {
                // No filter, so just fire table updated
                row = data.indexOf(soap);
                if (row != -1) {
                    fireTableRowsUpdated(row, row);
                }
            } else {
                // Check if the row was being displayed
                row = filter_data.indexOf(soap);
                if (row == -1) {
                    // Row was not displayed, so check for if it
                    // now needs to be displayed
                    if (filterMatch(soap)) {
                        int index = -1;
                        row = data.indexOf(soap) + 1;
                        while ((row < data.size()) && (index == -1)) {
                            index = filter_data.indexOf(data.elementAt(row));
                            if (index != -1) {
                                // Insert at this location
                                filter_data.add(index, soap);
                            }
                            row++;
                        }
                        if (index == -1) {
                            // Insert at end
                            index = filter_data.size();
                            filter_data.addElement(soap);
                        }
                        fireTableRowsInserted(index, index);
                    }
                } else {
                    // Row was displayed, so check if it needs to
                    // be updated or removed
                    if (filterMatch(soap)) {
                        fireTableRowsUpdated(row, row);
                    } else {
                        filter_data.remove(soap);
                        fireTableRowsDeleted(row, row);
                    }
                }
            }
        }
    }

    /**
     * Panel with checkbox and list
     */
    class ServiceFilterPanel extends JPanel
            implements ActionListener, ListSelectionListener, DocumentListener {

        /**
         * Field service_box
         */
        private JCheckBox service_box = null;

        /**
         * Field filter_list
         */
        private Vector filter_list = null;

        /**
         * Field service_data
         */
        private Vector service_data = null;

        /**
         * Field service_list
         */
        private JList service_list = null;

        /**
         * Field service_scroll
         */
        private JScrollPane service_scroll = null;

        /**
         * Field remove_service_button
         */
        private JButton remove_service_button = null;

        /**
         * Field remove_service_panel
         */
        private JPanel remove_service_panel = null;

        /**
         * Field indent_border
         */
        private EmptyBorder indent_border = null;

        /**
         * Field empty_border
         */
        private EmptyBorder empty_border = null;

        /**
         * Field service_area
         */
        private JPanel service_area = null;

        /**
         * Field add_service_area
         */
        private JPanel add_service_area = null;

        /**
         * Field add_service_field
         */
        private JTextField add_service_field = null;

        /**
         * Field add_service_button
         */
        private JButton add_service_button = null;

        /**
         * Field add_service_panel
         */
        private JPanel add_service_panel = null;

        /**
         * Constructor
         * 
         * @param text 
         * @param list 
         */
        public ServiceFilterPanel(String text, Vector list) {
            empty_border = new EmptyBorder(5, 5, 0, 5);
            indent_border = new EmptyBorder(5, 25, 5, 5);
            service_box = new JCheckBox(text);
            service_box.addActionListener(this);
            service_data = new Vector();
            if (list != null) {
                service_box.setSelected(true);
                service_data = (Vector) list.clone();
            }
            service_list = new JList(service_data);
            service_list.setBorder(new EtchedBorder());
            service_list.setVisibleRowCount(5);
            service_list.addListSelectionListener(this);
            service_list.setEnabled(service_box.isSelected());
            service_scroll = new JScrollPane(service_list);
            service_scroll.setBorder(new EtchedBorder());
            remove_service_button = new JButton("Remove");
            remove_service_button.addActionListener(this);
            remove_service_button.setEnabled(false);
            remove_service_panel = new JPanel();
            remove_service_panel.setLayout(new FlowLayout());
            remove_service_panel.add(remove_service_button);
            service_area = new JPanel();
            service_area.setLayout(new BorderLayout());
            service_area.add(service_scroll, BorderLayout.CENTER);
            service_area.add(remove_service_panel, BorderLayout.EAST);
            service_area.setBorder(indent_border);
            add_service_field = new JTextField();
            add_service_field.addActionListener(this);
            add_service_field.getDocument().addDocumentListener(this);
            add_service_field.setEnabled(service_box.isSelected());
            add_service_button = new JButton("Add");
            add_service_button.addActionListener(this);
            add_service_button.setEnabled(false);
            add_service_panel = new JPanel();
            add_service_panel.setLayout(new BorderLayout());
            JPanel dummy = new JPanel();
            dummy.setBorder(empty_border);
            add_service_panel.add(dummy, BorderLayout.WEST);
            add_service_panel.add(add_service_button, BorderLayout.EAST);
            add_service_area = new JPanel();
            add_service_area.setLayout(new BorderLayout());
            add_service_area.add(add_service_field, BorderLayout.CENTER);
            add_service_area.add(add_service_panel, BorderLayout.EAST);
            add_service_area.setBorder(indent_border);
            setLayout(new BorderLayout());
            add(service_box, BorderLayout.NORTH);
            add(service_area, BorderLayout.CENTER);
            add(add_service_area, BorderLayout.SOUTH);
            setBorder(empty_border);
        }

        /**
         * Get the current list of services
         * 
         * @return 
         */
        public Vector getServiceList() {
            Vector list = null;
            if (service_box.isSelected()) {
                list = service_data;
            }
            return list;
        }

        /**
         * Listener to handle button actions
         * 
         * @param e 
         */
        public void actionPerformed(ActionEvent e) {
            // Check if the user changed the service filter option
            if (e.getSource() == service_box) {
                service_list.setEnabled(service_box.isSelected());
                service_list.clearSelection();
                remove_service_button.setEnabled(false);
                add_service_field.setEnabled(service_box.isSelected());
                add_service_field.setText("");
                add_service_button.setEnabled(false);
            }

            // Check if the user pressed the add service button
            if ((e.getSource() == add_service_button)
                    || (e.getSource() == add_service_field)) {
                String text = add_service_field.getText();
                if ((text != null) && (text.length() > 0)) {
                    service_data.addElement(text);
                    service_list.setListData(service_data);
                }
                add_service_field.setText("");
                add_service_field.requestFocus();
            }

            // Check if the user pressed the remove service button
            if (e.getSource() == remove_service_button) {
                Object[] sels = service_list.getSelectedValues();
                for (int i = 0; i < sels.length; i++) {
                    service_data.removeElement(sels[i]);
                }
                service_list.setListData(service_data);
                service_list.clearSelection();
            }
        }

        /**
         * Handle changes to the text field
         * 
         * @param e 
         */
        public void changedUpdate(DocumentEvent e) {
            String text = add_service_field.getText();
            if ((text != null) && (text.length() > 0)) {
                add_service_button.setEnabled(true);
            } else {
                add_service_button.setEnabled(false);
            }
        }

        /**
         * Handle changes to the text field
         * 
         * @param e 
         */
        public void insertUpdate(DocumentEvent e) {
            changedUpdate(e);
        }

        /**
         * Handle changes to the text field
         * 
         * @param e 
         */
        public void removeUpdate(DocumentEvent e) {
            changedUpdate(e);
        }

        /**
         * Listener to handle service list selection changes
         * 
         * @param e 
         */
        public void valueChanged(ListSelectionEvent e) {
            if (service_list.getSelectedIndex() == -1) {
                remove_service_button.setEnabled(false);
            } else {
                remove_service_button.setEnabled(true);
            }
        }
    }

    /**
     * Class for showing the filter dialog
     */
    class SOAPMonitorFilter implements ActionListener {

        /**
         * Private data
         */
        private JDialog dialog = null;

        /**
         * Field panel
         */
        private JPanel panel = null;

        /**
         * Field buttons
         */
        private JPanel buttons = null;

        /**
         * Field ok_button
         */
        private JButton ok_button = null;

        /**
         * Field cancel_button
         */
        private JButton cancel_button = null;

        /**
         * Field include_panel
         */
        private ServiceFilterPanel include_panel = null;

        /**
         * Field exclude_panel
         */
        private ServiceFilterPanel exclude_panel = null;

        /**
         * Field status_panel
         */
        private JPanel status_panel = null;

        /**
         * Field status_box
         */
        private JCheckBox status_box = null;

        /**
         * Field empty_border
         */
        private EmptyBorder empty_border = null;

        /**
         * Field indent_border
         */
        private EmptyBorder indent_border = null;

        /**
         * Field status_options
         */
        private JPanel status_options = null;

        /**
         * Field status_group
         */
        private ButtonGroup status_group = null;

        /**
         * Field status_active
         */
        private JRadioButton status_active = null;

        /**
         * Field status_complete
         */
        private JRadioButton status_complete = null;

        /**
         * Field filter_include_list
         */
        private Vector filter_include_list = null;

        /**
         * Field filter_exclude_list
         */
        private Vector filter_exclude_list = null;

        /**
         * Field filter_active
         */
        private boolean filter_active = false;

        /**
         * Field filter_complete
         */
        private boolean filter_complete = false;

        /**
         * Field ok_pressed
         */
        private boolean ok_pressed = false;

        /**
         * Constructor
         */
        public SOAPMonitorFilter() {
            // By default, exclude NotificationService and
            // EventViewerService messages
            filter_exclude_list = new Vector();
            filter_exclude_list.addElement("NotificationService");
            filter_exclude_list.addElement("EventViewerService");
        }

        /**
         * Get list of services to be included
         * 
         * @return 
         */
        public Vector getFilterIncludeList() {
            return filter_include_list;
        }

        /**
         * Get list of services to be excluded
         * 
         * @return 
         */
        public Vector getFilterExcludeList() {
            return filter_exclude_list;
        }

        /**
         * Check if filter active messages
         * 
         * @return 
         */
        public boolean getFilterActive() {
            return filter_active;
        }

        /**
         * Check if filter complete messages
         * 
         * @return 
         */
        public boolean getFilterComplete() {
            return filter_complete;
        }

        /**
         * Show the filter dialog
         */
        public void showDialog() {
            empty_border = new EmptyBorder(5, 5, 0, 5);
            indent_border = new EmptyBorder(5, 25, 5, 5);
            include_panel = new ServiceFilterPanel(
                    "Include messages based on target service:",
                    filter_include_list);
            exclude_panel = new ServiceFilterPanel(
                    "Exclude messages based on target service:",
                    filter_exclude_list);
            status_box = new JCheckBox("Filter messages based on status:");
            status_box.addActionListener(this);
            status_active = new JRadioButton("Active messages only");
            status_active.setSelected(true);
            status_active.setEnabled(false);
            status_complete = new JRadioButton("Complete messages only");
            status_complete.setEnabled(false);
            status_group = new ButtonGroup();
            status_group.add(status_active);
            status_group.add(status_complete);
            if (filter_active || filter_complete) {
                status_box.setSelected(true);
                status_active.setEnabled(true);
                status_complete.setEnabled(true);
                if (filter_complete) {
                    status_complete.setSelected(true);
                }
            }
            status_options = new JPanel();
            status_options.setLayout(new BoxLayout(status_options,
                    BoxLayout.Y_AXIS));
            status_options.add(status_active);
            status_options.add(status_complete);
            status_options.setBorder(indent_border);
            status_panel = new JPanel();
            status_panel.setLayout(new BorderLayout());
            status_panel.add(status_box, BorderLayout.NORTH);
            status_panel.add(status_options, BorderLayout.CENTER);
            status_panel.setBorder(empty_border);
            ok_button = new JButton("Ok");
            ok_button.addActionListener(this);
            cancel_button = new JButton("Cancel");
            cancel_button.addActionListener(this);
            buttons = new JPanel();
            buttons.setLayout(new FlowLayout());
            buttons.add(ok_button);
            buttons.add(cancel_button);
            panel = new JPanel();
            panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
            panel.add(include_panel);
            panel.add(exclude_panel);
            panel.add(status_panel);
            panel.add(buttons);
            dialog = new JDialog();
            dialog.setTitle("SOAP Monitor Filter");
            dialog.setContentPane(panel);
            dialog.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
            dialog.setModal(true);
            dialog.pack();
            Dimension d = dialog.getToolkit().getScreenSize();
            dialog.setLocation((d.width - dialog.getWidth()) / 2,
                    (d.height - dialog.getHeight()) / 2);
            ok_pressed = false;
            dialog.show();
        }

        /**
         * Listener to handle button actions
         * 
         * @param e 
         */
        public void actionPerformed(ActionEvent e) {
            // Check if the user pressed the ok button
            if (e.getSource() == ok_button) {
                filter_include_list = include_panel.getServiceList();
                filter_exclude_list = exclude_panel.getServiceList();
                if (status_box.isSelected()) {
                    filter_active = status_active.isSelected();
                    filter_complete = status_complete.isSelected();
                } else {
                    filter_active = false;
                    filter_complete = false;
                }
                ok_pressed = true;
                dialog.dispose();
            }

            // Check if the user pressed the cancel button
            if (e.getSource() == cancel_button) {
                dialog.dispose();
            }

            // Check if the user changed the status filter option
            if (e.getSource() == status_box) {
                status_active.setEnabled(status_box.isSelected());
                status_complete.setEnabled(status_box.isSelected());
            }
        }

        /**
         * Check if the user pressed the ok button
         * 
         * @return 
         */
        public boolean okPressed() {
            return ok_pressed;
        }
    }

    /**
     * Text panel class that supports XML reflow
     */
    class SOAPMonitorTextArea extends JTextArea {

        /**
         * Private data
         */
        private boolean format = false;

        /**
         * Field original
         */
        private String original = "";

        /**
         * Field formatted
         */
        private String formatted = null;

        /**
         * Constructor
         */
        public SOAPMonitorTextArea() {
        }

        /**
         * Override setText to do formatting
         * 
         * @param text 
         */
        public void setText(String text) {
            original = text;
            formatted = null;
            if (format) {
                doFormat();
                super.setText(formatted);
            } else {
                super.setText(original);
            }
        }

        /**
         * Turn reflow on or off
         * 
         * @param reflow 
         */
        public void setReflowXML(boolean reflow) {
            format = reflow;
            if (format) {
                if (formatted == null) {
                    doFormat();
                }
                super.setText(formatted);
            } else {
                super.setText(original);
            }
        }

        /**
         * Reflow XML
         */
        public void doFormat() {
            Vector parts = new Vector();
            char[] chars = original.toCharArray();
            int index = 0;
            int first = 0;
            String part = null;
            while (index < chars.length) {
                // Check for start of tag
                if (chars[index] == '<') {
                    // Did we have data before this tag?
                    if (first < index) {
                        part = new String(chars, first, index - first);
                        part = part.trim();

                        // Save non-whitespace data
                        if (part.length() > 0) {
                            parts.addElement(part);
                        }
                    }

                    // Save the start of tag
                    first = index;
                }

                // Check for end of tag
                if (chars[index] == '>') {
                    // Save the tag
                    part = new String(chars, first, index - first + 1);
                    parts.addElement(part);
                    first = index + 1;
                }

                // Check for end of line
                if ((chars[index] == '\n') || (chars[index] == '\r')) {
                    // Was there data on this line?
                    if (first < index) {
                        part = new String(chars, first, index - first);
                        part = part.trim();

                        // Save non-whitespace data
                        if (part.length() > 0) {
                            parts.addElement(part);
                        }
                    }
                    first = index + 1;
                }
                index++;
            }

            // Reflow as XML
            StringBuffer buf = new StringBuffer();
            Object[] list = parts.toArray();
            int indent = 0;
            int pad = 0;
            index = 0;
            while (index < list.length) {
                part = (String) list[index];
                if (buf.length() == 0) {
                    // Just add first tag (should be XML header)
                    buf.append(part);
                } else {
                    // All other parts need to start on a new line
                    buf.append('\n');

                    // If we're at an end tag then decrease indent
                    if (part.startsWith("</")) {
                        indent--;
                    }

                    // Add any indent
                    for (pad = 0; pad < indent; pad++) {
                        buf.append("  ");
                    }

                    // Add the tag or data
                    buf.append(part);

                    // If this is a start tag then increase indent
                    if (part.startsWith("<") && !part.startsWith("</")
                            && !part.endsWith("/>")) {
                        indent++;

                        // Check for special <tag>data</tag> case
                        if ((index + 2) < list.length) {
                            part = (String) list[index + 2];
                            if (part.startsWith("</")) {
                                part = (String) list[index + 1];
                                if (!part.startsWith("<")) {
                                    buf.append(part);
                                    part = (String) list[index + 2];
                                    buf.append(part);
                                    index = index + 2;
                                    indent--;
                                }
                            }
                        }
                    }
                }
                index++;
            }
            formatted = new String(buf);
        }
    }

    /**
     * Listener to handle button actions
     * 
     * @param e 
     */
    public void actionPerformed(ActionEvent e) {
        Object obj = e.getSource();
        if (obj == add_btn) {
            int selected[] = list1.getSelectedIndices();
            int len = selected.length - 1;
            for (int i = len; i >= 0; i--) {
                model2.addElement(model1.getElementAt(selected[i]));
                model1.remove(selected[i]);
            }
            if (model1.size() == 0) {
                add_btn.setEnabled(false);
            }
            if (model2.size() > 0) {
                del_btn.setEnabled(true);
            }
        } else if (obj == del_btn) {
            int selected[] = list2.getSelectedIndices();
            int len = selected.length - 1;
            for (int i = len; i >= 0; i--) {
                model1.addElement(model2.getElementAt(selected[i]));
                model2.remove(selected[i]);
            }
            if (model2.size() == 0) {
                del_btn.setEnabled(false);
            }
            if (model1.size() > 0) {
                add_btn.setEnabled(true);
            }
        } else if (obj == login_btn) {
            if (doLogin()) {
                delPage();
                addPage(new SOAPMonitorPage(axisHost));
                start();
            } else {
                add_btn.setEnabled(false);
                del_btn.setEnabled(false);
            }
        } else if (obj == save_btn) {
            String service = null;
            Node node = null;
            Node impNode = null;
            Document wsdd = null;
            JOptionPane pane = null;
            JDialog dlg = null;
            String msg = null;
            final String title = "Deployment status";
            final String deploy = "<deployment name=\"SOAPMonitor\""
              + " xmlns=\"http://xml.apache.org/axis/wsdd/\""
              + " xmlns:java=\"http://xml.apache.org/axis/wsdd/providers/java\">\n"
              + " <handler name=\"soapmonitor\""
              + " type=\"java:org.apache.axis.handlers.SOAPMonitorHandler\" />\n"
              + " </deployment>";

            // Create a new wsdd document
            try {
                wsdd = XMLUtils.newDocument(
                        new ByteArrayInputStream(deploy.getBytes()));
            } catch (Exception ex) {
                ex.printStackTrace();
            }
            Collection col = serviceMap.keySet();
            Iterator ite = col.iterator();

            // Add all of service nodes to the new wsdd
            while (ite.hasNext()) {
                service = (String) ite.next();
                node = (Node) serviceMap.get(service);
                if (model2.contains(service)) {
                    if (isMonitored(node)) {    // It's already been monitored
                        impNode = wsdd.importNode(node, true);
                    } else {                    // It's to be monitored
                        impNode = wsdd.importNode(addMonitor(node), true);
                    }
                } else {
                    if (isMonitored(node)) {    // It's not to be monitored
                        impNode = wsdd.importNode(delMonitor(node), true);
                    } else {                    // It's not already been monitored
                        impNode = wsdd.importNode(node, true);
                    }
                }
                if (service.equals("AdminService")) {
                    // Add "SimpleAuthenticationHandler" and "allowedRoles" parameter
                    // with "admin" as a user account
                    impNode = wsdd.importNode(addAuthenticate(impNode), true);
                }
                wsdd.getDocumentElement().appendChild(impNode);
            }

            // Show the result of deployment
            pane = new JOptionPane();
            if (doDeploy(wsdd)) {
                msg = "The deploy was successful.";
                pane.setMessageType(JOptionPane.INFORMATION_MESSAGE);
            } else {
                msg = "The deploy was NOT successful.";
                pane.setMessageType(JOptionPane.WARNING_MESSAGE);
            }
            pane.setOptions(new String[]{"OK"});
            pane.setMessage(msg);
            dlg = pane.createDialog(null, title);
            dlg.setVisible(true);
        }
    }

    /**
     * ChangeListener to handle tab actions
     * 
     * @param e 
     */
    public void stateChanged( javax.swing.event.ChangeEvent e ){
        JTabbedPane tab = (JTabbedPane)e.getSource();
        int item = tab.getSelectedIndex();
        if (item==1) { // "Monitoring" tab is selected.
            start();
        } else {       // "Setting" tab is selected.
            stop();
        }
    }
}