/*
   Copyright (C) 2000 - 2007 Grid Systems, S.A.
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License, version 2, as
   published by the Free Software Foundation.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
  
  /*
   * Project: KernelConfigurator
   * Created on 05-oct-2004
   *
   * Copyright (c)2004 Grid Systems
   */
  package com.gridsystems.config.modules.tomcat;
  
  import java.awt.Color;
  import java.awt.Component;
  import java.awt.Dimension;
  import java.awt.EventQueue;
  import java.awt.Font;
  import java.awt.GridBagConstraints;
  import java.awt.GridBagLayout;
  import java.awt.Insets;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.awt.event.FocusEvent;
  import java.awt.event.FocusListener;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.MissingResourceException;
  import java.util.ResourceBundle;
  
  import javax.swing.DefaultCellEditor;
  import javax.swing.JButton;
  import javax.swing.JComboBox;
  import javax.swing.JComponent;
  import javax.swing.JLabel;
  import javax.swing.JPanel;
  import javax.swing.JScrollPane;
  import javax.swing.JTable;
  import javax.swing.JTextField;
  import javax.swing.SwingUtilities;
  import javax.swing.event.ListSelectionEvent;
  import javax.swing.event.ListSelectionListener;
  import javax.swing.table.AbstractTableModel;
  import javax.swing.table.DefaultTableCellRenderer;
  import javax.swing.table.DefaultTableColumnModel;
  import javax.swing.table.TableCellRenderer;
  import javax.swing.table.TableColumn;
  import javax.swing.table.TableColumnModel;
  
  /**
   * Swing Component for Connection list edition.
   *
   * @author <a href="mailto:rruiz@gridsystems.com">Rodrigo Ruiz Aguayo</a>
   * @version 1.0
   */
  public class ConnectorEditor extends JPanel {
    /**
     * Preferred component width.
     */
    private static final int COMPONENT_WIDTH = 200;
  
    /**
     * Preferred component height.
     */
    private static final int COMPONENT_HEIGHT = 100;
  
    /**
     * Width of fixed size columns in the table.
     */
    private static final int FIXED_COLUMN_WIDTH = 70;
  
    /**
     * Font used for the 'add' and 'remove' buttons.
     */
    private static final Font BUTTON_FONT = Font.decode("Dialog-PLAIN-11");
  
    /**
     * Resource bundle for i18n.
     */
    private static ResourceBundle bundle = ResourceBundle
                                           .getBundle(TomcatConfigurator.BUNDLE);
  
    /**
     * Table for displaying the connector list.
     */
    private JTable table;
  
   /**
    * Scroller instance that contains the table.
    */
   private JScrollPane scroller;
 
   /**
    * Button for "Add connector" action.
    */
   private JButton btnAdd;
 
   /**
    * Button for "Remove connector" action.
    */
   private JButton btnRemove;
 
   /**
    * Callback to be executed on data changes.
    */
   private Runnable changeCallback;
 
   /**
    * Creates a new instance.
    */
   public ConnectorEditor() {
     super();
     init();
   }
 
   /**
    * Initializes the component layout.
    */
   private void init() {
     this.setLayout(new GridBagLayout());
 
     table = new JTable();
     table.getSelectionModel().addListSelectionListener(new ConnectorSelectionListener());
     scroller = new JScrollPane(table, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
                                       JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
 
     btnAdd = new JButton(getString("ConnectorEditor.btnAdd.text"));
     btnRemove = new JButton(getString("ConnectorEditor.btnRemove.text"));
 
     btnAdd.setFont(BUTTON_FONT);
     btnRemove.setFont(BUTTON_FONT);
 
     btnAdd.addActionListener(new ActionListener() {
       public void actionPerformed(ActionEvent event) {
         addConnector();
       }
     });
 
     btnRemove.addActionListener(new ActionListener() {
       public void actionPerformed(ActionEvent event) {
         removeConnector();
       }
     });
 
     this.add(scroller, new GridBagConstraints(0, 0, 2, 1, 1.0, 1.0,
       GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets(0, 0, 2, 0), 0, 0));
     this.add(btnAdd, new GridBagConstraints(0, 1, 1, 1, 1.0, 0.0,
       GridBagConstraints.EAST, GridBagConstraints.NONE, new Insets(0, 0, 0, 0), 0, 0));
     this.add(btnRemove, new GridBagConstraints(1, 1, 1, 1, 0.0, 0.0,
       GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(0, 2, 0, 0), 0, 0));
 
     this.setPreferredSize(new Dimension(COMPONENT_WIDTH, COMPONENT_HEIGHT));
   }
 
   /**
    * Adds a connector to the table.
    */
   public void addConnector() {
     ConnectorModel model = (ConnectorModel)table.getModel();
     model.newConnector();
     runCallback();
   }
 
   /**
    * Removes the selected connector from the table.
    */
   public void removeConnector() {
     int row = table.getSelectedRow();
     if (row != -1) {
       ConnectorModel model = (ConnectorModel)table.getModel();
       model.deleteConnector(row);
       runCallback();
     }
   }
 
   /**
    * Sets the list of connectors.
    *
    * @param list  the new connector list.
    */
   public void setConnectors(Connector[] list) {
     table.setModel(new ConnectorModel(list));
     setupTable(table);
   }
 
   /**
    * Gets the list of connectors.
    *
    * @return  the connector list
    */
   public Connector[] getConnectors() {
     ConnectorModel model = (ConnectorModel)table.getModel();
     Connector[] c = new Connector[model.list.size()];
     model.list.toArray(c);
     return c;
   }
 
   /**
    * Configures the table for correct display of data.
    *
    * @param table  the table instance
    */
   private void setupTable(JTable table) {
     TableColumnModel cmodel = new DefaultTableColumnModel();
     TableCellRenderer renderer = new ConnectorCellRenderer();
 
     TableColumn c = new TableColumn(0);
     c.setHeaderValue(getString("ConnectorEditor.table.colName"));
     c.setResizable(true);
     c.setCellRenderer(renderer);
     c.setCellEditor(new NameCellEditor());
     cmodel.addColumn(c);
 
     c = new TableColumn(1);
     c.setHeaderValue(getString("ConnectorEditor.table.colScheme"));
     c.setMinWidth(FIXED_COLUMN_WIDTH);
     c.setMaxWidth(FIXED_COLUMN_WIDTH);
     c.setResizable(false);
     c.setCellRenderer(renderer);
     c.setCellEditor(new SchemeCellEditor());
     cmodel.addColumn(c);
 
     c = new TableColumn(2);
     c.setHeaderValue(getString("ConnectorEditor.table.colPort"));
     c.setMinWidth(FIXED_COLUMN_WIDTH);
     c.setMaxWidth(FIXED_COLUMN_WIDTH);
     c.setResizable(false);
     c.setCellRenderer(renderer);
     c.setCellEditor(new PortCellEditor());
     cmodel.addColumn(c);
 
     table.setColumnModel(cmodel);
     table.setRowHeight(20);
   }
 
   /**
    * Sets a runnable that will be invoked whenever a change is made in data.
    *
    * @param callback  the callback to invoke
    */
   public void setChangeCallback(Runnable callback) {
     this.changeCallback = callback;
   }
 
   /**
    * Gets if any of the listed connectors uses SSL.
    *
    * @return  <code>true</code> if at least one of the connectors is secure
    */
   public boolean containSecureConnector() {
     ConnectorModel model = (ConnectorModel)table.getModel();
     for (Iterator it = model.list.iterator(); it.hasNext();) {
       Connector c = (Connector)it.next();
       if (Connector.HTTPS.equalsIgnoreCase(c.getProtocol())) {
         return true;
       }
     }
     return false;
   }
 
   /**
    * Invokes the change callback, if there is any.
    */
   private void runCallback() {
     if (changeCallback != null) {
       SwingUtilities.invokeLater(changeCallback);
     }
   }
 
   /**
    * Gets a localized string.
    *
    * @param key The i18n key
    * @return    The localized string, or null if none found for key
    * @throws NullPointerException if the bundle is not set
    */
   public static String getString(String key) throws NullPointerException {
     if (bundle == null) {
       throw new NullPointerException("Bundle not set");
     }
 
     try {
       return bundle.getString(key);
     } catch (MissingResourceException e) {
       return null;
     }
   }
 
   /**
    * Connector Table Data Model.
    *
    * @author <a href="mailto:rruiz@gridsystems.com">Rodrigo Ruiz Aguayo</a>
    * @version 1.0
    */
   private class ConnectorModel extends AbstractTableModel {
     /**
      * Number of columns in the table.
      */
     private static final int COLUMN_COUNT = 4;
 
     /**
      * The internal data list.
      */
     public ArrayList<Connector> list;
 
     /**
      * Creates a new instance.
      *
      * @param connectors  the list of connectors
      */
     public ConnectorModel(Connector[] connectors) {
       super();
       this.list = new ArrayList<Connector>();
 
       int count = connectors == null ? 0 : connectors.length;
       for (int i = 0; i < count; i++) {
         this.list.add(connectors[i]);
       }
     }
 
     /**
      * {@inheritDoc}
      */
     public int getColumnCount() {
       return COLUMN_COUNT;
     }
 
     /**
      * {@inheritDoc}
      */
     public int getRowCount() {
       return this.list.size();
     }
 
     /**
      * {@inheritDoc}
      */
     public Object getValueAt(int rowIndex, int columnIndex) {
       Connector c = (Connector)list.get(rowIndex);
       return c;
     }
 
     /**
      * {@inheritDoc}
      */
     public void setValueAt(Object value, int rowIndex, int columnIndex) {
       Connector c = (Connector)list.get(rowIndex);
       boolean modified = false;
       switch (columnIndex) {
         case 0:
           modified = !value.equals(c.getName());
           c.setName(value.toString());
           break;
         case 1:
           modified = !c.getProtocol().equals(value);
           c.setProtocol((String)value);
 
           if (Connector.HTTPS.equalsIgnoreCase(c.getProtocol())
             && c.getPort() == TomcatConfigModel.DEFAULT_HTTP_PORT) {
             c.setPort(TomcatConfigModel.DEFAULT_HTTPS_PORT);
             fireTableCellUpdated(rowIndex, 2);
           }
           if (Connector.HTTP.equalsIgnoreCase(c.getProtocol())
             && c.getPort() == TomcatConfigModel.DEFAULT_HTTPS_PORT) {
             c.setPort(TomcatConfigModel.DEFAULT_HTTP_PORT);
             fireTableCellUpdated(rowIndex, 2);
           }
           break;
         case 2:
           try {
             int port = Integer.parseInt(value.toString());
             modified = (port != c.getPort());
             c.setPort(port);
           } catch (Exception e) { }
           break;
         default:
           break;
       }
 
       // Invokes the change callback
       if (modified) {
         runCallback();
       }
     }
 
     /**
      * {@inheritDoc}
      */
     public boolean isCellEditable(int row, int column) {
       Connector c = (Connector)list.get(row);
       return c.isUserCreated() || column == 2;
     }
 
     /**
      * Creates a new connector with default values and adds it to the list.
      */
     public void newConnector() {
       Connector c = new Connector(getString("ConnectorEditor.unnamed.text"),
         TomcatConfigModel.DEFAULT_HTTP_PORT, Connector.HTTP);
       // Searches an unused port
       boolean changed = true;
       while (changed) {
         changed = false;
         for (Iterator it = list.iterator(); it.hasNext();) {
           Connector item = (Connector)it.next();
           if (item.getPort() == c.getPort()) {
             changed = true;
             c.setPort(c.getPort() + 1);
           }
         }
       }
 
       int lastRow = list.size();
       list.add(c);
       fireTableRowsInserted(lastRow, lastRow);
     }
 
     /**
      * Deletes the connector at the specified row.
      *
      * @param row  the row index.
      */
     public void deleteConnector(int row) {
       Connector c = (Connector)list.get(row);
       if (c != null) {
         list.remove(row);
         fireTableRowsDeleted(row, row);
       }
     }
   }
 
   /**
    * Renders cells containing Connector instances.
    *
    * @author <a href="mailto:rruiz@gridsystems.com">Rodrigo Ruiz Aguayo</a>
    * @version 1.0
    */
   private static class ConnectorCellRenderer extends DefaultTableCellRenderer {
     /**
      * Column alignments.
      */
     private static final int[] ALIGNS = { JLabel.LEFT, JLabel.CENTER, JLabel.RIGHT };
 
     /**
      * Background colors.
      */
     private static final Color[] BACKGROUNDS = { Color.WHITE, Color.decode("0xFFFFCC") };
 
     /**
      * Returns the table cell renderer.
      *
      * @param table       the <code>JTable</code>
      * @param value       the value to assign to the cell at <code>[row, column]</code>
      * @param isSelected  true if cell is selected
      * @param hasFocus    true if cell has focus
      * @param row         the row of the cell to render
      * @param column      the column of the cell to render
      * @return the table cell renderer
      */
     public Component getTableCellRendererComponent(JTable table, Object value,
         boolean isSelected, boolean hasFocus, int row, int column) {
 
       Connector conn = (Connector)value;
       switch (column) {
         case 0:
           value = conn.getName();
           break;
         case 1:
           value = conn.getProtocol();
           break;
         case 2:
           value = String.valueOf(conn.getPort());
         default:
           break;
       }
 
       JLabel lbl = (JLabel)super.getTableCellRendererComponent(table, value, isSelected,
           hasFocus, row, column);
 
       lbl.setHorizontalAlignment(ALIGNS[column]);
       boolean editable = (conn.isUserCreated() || column == 2);
       if (!isSelected) {
         lbl.setBackground(BACKGROUNDS[editable ? 0 : 1]);
       }
 
       // The following code ensures that a proper edit action is fired when a cell
       // receives the focus.
       if (hasFocus) {
         final JTable theTable = table;
         final int theRow = row;
         final int theCol = editable ? column : 2;
 
         EventQueue.invokeLater(new Runnable() {
           public void run() {
             // Sets the table in edit mode
             theTable.editCellAt(theRow, theCol);
 
             // Brings the focus to the editor
             Component c = theTable.getEditorComponent();
             if (c != null) {
               c.requestFocusInWindow();
             }
           }
         });
       }
       return lbl;
     }
   }
 
   /**
    * Cell editor for Connector names
    * Type description.
    *
    * @author <a href="mailto:rruiz@gridsystems.com">Rodrigo Ruiz Aguayo</a>
    * @version 1.0
    */
   private static class NameCellEditor extends DefaultCellEditor {
     /**
      * Shared editor instance.
      */
     private static JTextField txt = new JTextField();
 
     /**
      * Shared focus listener to add to the editor.
      */
     private static ConnectorFocusListener fl = new ConnectorFocusListener();
 
     static {
       txt.addFocusListener(fl);
     }
 
     /**
      * Creates a new instance.
      */
     public NameCellEditor() {
       super(txt);
     }
 
     /**
      * Gets the editor component.
      *
      * @param table      The table to edit
      * @param value      The cell value
      * @param isSelected Indicates if the cell is selected
      * @param row        The table selection row
      * @param column     The table selection column
      * @return A configured editor
      */
     public Component getTableCellEditorComponent(JTable table, Object value,
             boolean isSelected, int row, int column) {
       Connector c = (Connector)value;
 
       super.getTableCellEditorComponent(table, c.getName(), isSelected, row, column);
       editorComponent.putClientProperty("cellEditor", this);
       return editorComponent;
     }
   }
 
   /**
    * Cell editor for Connector schemes.
    *
    * @author <a href="mailto:rruiz@gridsystems.com">Rodrigo Ruiz Aguayo</a>
    * @version 1.0
    */
   private static class SchemeCellEditor extends DefaultCellEditor {
 
     /**
      * Shared combo-box instance.
      */
     private static JComboBox cbox = new JComboBox(Connector.getAvailableProtocols());
 
     static {
       cbox.setFont(Font.decode("Dialog-PLAIN-12"));
       cbox.setFocusable(false);
     };
 
     /**
      * Creates a new instance.
      */
     public SchemeCellEditor() {
       super(cbox);
     }
 
     /**
      * Gets the editor component.
      *
      * @param table      The table to edit
      * @param value      The cell value
      * @param isSelected Indicates if the cell is selected
      * @param row        The table selection row
      * @param column     The table selection column
      * @return A configured editor
      */
     public Component getTableCellEditorComponent(JTable table, Object value,
             boolean isSelected, int row, int column) {
       Connector c = (Connector)value;
       value = c.getProtocol();
       super.getTableCellEditorComponent(table, value, isSelected, row, column);
       return cbox;
     }
   }
 
   /**
    * Cell editor for Connector ports.
    *
    * @author <a href="mailto:rruiz@gridsystems.com">Rodrigo Ruiz Aguayo</a>
    * @version 1.0
    */
   private static class PortCellEditor extends DefaultCellEditor {
     /**
      * The internal text editor component.
      */
     private static JTextField txt = new JTextField();
 
     /**
      * Shared focus listener to add to the editor.
      */
     private static ConnectorFocusListener fl = new ConnectorFocusListener();
 
     static {
       txt.addFocusListener(fl);
     }
 
     /**
      * Creates a new instance.
      */
     public PortCellEditor() {
       super(txt);
     }
 
     /**
      * Gets the editor component.
      *
      * @param table      The table to edit
      * @param value      The cell value
      * @param isSelected Indicates if the cell is selected
      * @param row        The table selection row
      * @param column     The table selection column
      * @return A configured editor
      */
     public Component getTableCellEditorComponent(JTable table, Object value,
             boolean isSelected, int row, int column) {
       Connector c = (Connector)value;
       value = "" + c.getPort();
       super.getTableCellEditorComponent(table, value, isSelected, row, column);
       editorComponent.putClientProperty("cellEditor", this);
       return editorComponent;
     }
   }
 
   /**
    * Selection listener for button synchronization.
    *
    * @author <a href="mailto:rruiz@gridsystems.com">Rodrigo Ruiz Aguayo</a>
    * @version 1.0
    */
   private class ConnectorSelectionListener implements ListSelectionListener {
     /**
      * Creates a new instance.
      */
     public ConnectorSelectionListener() { }
 
     /**
      * {@inheritDoc}
      */
     public void valueChanged(ListSelectionEvent event) {
       if (!event.getValueIsAdjusting()) {
         try {
           ConnectorModel model = (ConnectorModel)table.getModel();
           //Connector con = (Connector)model.list.get(table.getSelectedRow());
           if (model.list.size() == 1) {
             btnRemove.setEnabled(false);
           } else {
             btnRemove.setEnabled(true);
           }
         } catch (Exception e) {
           btnRemove.setEnabled(false);
         }
       }
     }
   }
 
   /**
    * Focus listener to use on table cell editors. It forces the edition to stop on
    * focus loss.
    *
    * @author <a href="mailto:rruiz@gridsystems.com">Rodrigo Ruiz Aguayo</a>
    * @version 1.0
    */
   private static class ConnectorFocusListener implements FocusListener {
 
     /**
      * Creates a new instance.
      */
     public ConnectorFocusListener() { }
 
     /**
      * {@inheritDoc}
      */
     public void focusGained(FocusEvent e) {
       Component c = e.getComponent();
       if (c instanceof JTextField) {
         JTextField field = (JTextField)c;
         field.selectAll();
       }
     }
 
     /**
      * {@inheritDoc}
      */
     public void focusLost(FocusEvent e) {
       JComponent c = (JComponent)e.getComponent();
       DefaultCellEditor editor = (DefaultCellEditor)c.getClientProperty("cellEditor");
       if (editor != null) {
         editor.stopCellEditing();
       }
     }
   }
 }