/***
    * TableSorter is a decorator for TableModels; adding sorting
    * functionality to a supplied TableModel. TableSorter does
    * not store or copy the data in its TableModel; instead it maintains
    * a map from the row indexes of the view to the row indexes of the
    * model. As requests are made of the sorter (like getValueAt(row, col))
    * they are passed to the underlying model after the row numbers
    * have been translated via the internal mapping array. This way,
    * the TableSorter appears to hold another copy of the table
   * with the rows in a different order.
   * <p/>
   * TableSorter registers itself as a listener to the underlying model,
   * just as the JTable itself would. Events recieved from the model
   * are examined, sometimes manipulated (typically widened), and then
   * passed on to the TableSorter's listeners (typically the JTable).
   * If a change to the model has invalidated the order of TableSorter's
   * rows, a note of this is made and the sorter will resort the
   * rows the next time a value is requested.
   * <p/>
   * When the tableHeader property is set, either by using the
   * setTableHeader() method or the two argument constructor, the
   * table header may be used as a complete UI for TableSorter.
   * The default renderer of the tableHeader is decorated with a renderer
   * that indicates the sorting status of each column. In addition,
   * a mouse listener is installed with the following behavior:
   * <ul>
   * <li>
   * Mouse-click: Clears the sorting status of all other columns
   * and advances the sorting status of that column through three
   * values: {NOT_SORTED, ASCENDING, DESCENDING} (then back to
   * NOT_SORTED again).
   * <li>
   * SHIFT-mouse-click: Clears the sorting status of all other columns
   * and cycles the sorting status of the column through the same
   * three values, in the opposite order: {NOT_SORTED, DESCENDING, ASCENDING}.
   * <li>
   * CONTROL-mouse-click and CONTROL-SHIFT-mouse-click: as above except
   * that the changes to the column do not cancel the statuses of columns
   * that are already sorting - giving a way to initiate a compound
   * sort.
   * </ul>
   * <p/>
   * This is a long overdue rewrite of a class of the same name that
   * first appeared in the swing table demos in 1997.
   * 
   * @author Philip Milne
   * @author Brendon McLean 
   * @author Dan van Enckevort
   * @author Parwinder Sekhon
   * @version 2.0 02/27/04
   */
  package net.mlw.vlh.swing.support;
  
  import java.awt.Color;
  import java.awt.Component;
  import java.awt.Graphics;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.awt.event.MouseAdapter;
  import java.awt.event.MouseEvent;
  import java.awt.event.MouseListener;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Comparator;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  import javax.swing.Icon;
  import javax.swing.JLabel;
  import javax.swing.JTable;
  import javax.swing.event.TableModelEvent;
  import javax.swing.event.TableModelListener;
  import javax.swing.table.AbstractTableModel;
  import javax.swing.table.JTableHeader;
  import javax.swing.table.TableCellRenderer;
  import javax.swing.table.TableColumnModel;
  import javax.swing.table.TableModel;
  
  import net.mlw.vlh.ValueList;
  import net.mlw.vlh.swing.ValueListHelper;
  import net.mlw.vlh.swing.ValueListTableModel;
  
  public class TableSorter extends AbstractTableModel implements ValueListTableModel, ActionListener
  {
     protected ValueListTableModel valueListTableModel;
  
     protected TableModel tableModel;
  
     public static final int DESCENDING = -1;
  
     public static final int NOT_SORTED = 0;
  
     public static final int ASCENDING = 1;
  
     private static Directive EMPTY_DIRECTIVE = new Directive(-1, NOT_SORTED);
  
     public static final Comparator COMPARABLE_COMAPRATOR = new Comparator()
    {
       public int compare(Object o1, Object o2)
       {
          return ((Comparable) o1).compareTo(o2);
       }
    };
 
    public static final Comparator LEXICAL_COMPARATOR = new Comparator()
    {
       public int compare(Object o1, Object o2)
       {
          return o1.toString().compareTo(o2.toString());
       }
    };
 
    private Row[] viewToModel;
 
    private int[] modelToView;
 
    private JTableHeader tableHeader;
 
    private MouseListener mouseListener;
 
    private TableModelListener tableModelListener;
 
    private Map columnComparators = new HashMap();
 
    private List sortingColumns = new ArrayList();
 
    private ActionListener actionListener;
 
    public TableSorter()
    {
       this.mouseListener = new MouseHandler();
       this.tableModelListener = new TableModelHandler();
    }
 
    public TableSorter(TableModel tableModel)
    {
       this();
       setTableModel(tableModel);
    }
 
    public TableSorter(TableModel tableModel, JTableHeader tableHeader)
    {
       this();
       setTableHeader(tableHeader);
       setTableModel(tableModel);
    }
    
    /***
     * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
     */
    public void actionPerformed(ActionEvent e)
    {
       System.out.println("ooops = " + e);
 
    }
 
    public void addActionListener(ActionListener actionListener)
    {
       this.actionListener = actionListener;
    }
 
    private void clearSortingState()
    {
       viewToModel = null;
       modelToView = null;
    }
 
    public TableModel getTableModel()
    {
       return tableModel;
    }
 
    public void setTableModel(TableModel tableModel)
    {
       if (this.tableModel != null)
       {
          this.tableModel.removeTableModelListener(tableModelListener);
       }
 
       this.tableModel = tableModel;
       
       if (tableModel != null && ValueListTableModel.class.isAssignableFrom(tableModel.getClass()))
       {
          valueListTableModel = (ValueListTableModel) tableModel;
       }
 
       if (this.tableModel != null)
       {
          this.tableModel.addTableModelListener(tableModelListener);
       }
 
       clearSortingState();
       fireTableStructureChanged();
    }
 
    public JTableHeader getTableHeader()
    {
       return tableHeader;
    }
 
    public void setTableHeader(JTableHeader tableHeader)
    {
       if (this.tableHeader != null)
       {
          this.tableHeader.removeMouseListener(mouseListener);
          TableCellRenderer defaultRenderer = this.tableHeader.getDefaultRenderer();
          if (defaultRenderer instanceof SortableHeaderRenderer)
          {
             this.tableHeader.setDefaultRenderer(((SortableHeaderRenderer) defaultRenderer).tableCellRenderer);
          }
       }
       this.tableHeader = tableHeader;
       if (this.tableHeader != null)
       {
          this.tableHeader.addMouseListener(mouseListener);
          this.tableHeader.setDefaultRenderer(new SortableHeaderRenderer(this.tableHeader.getDefaultRenderer()));
       }
    }
 
    public boolean isSorting()
    {
       return sortingColumns.size() != 0;
    }
 
    private Directive getDirective(int column)
    {
       for (int i = 0; i < sortingColumns.size(); i++)
       {
          Directive directive = (Directive) sortingColumns.get(i);
          if (directive.column == column)
          {
             return directive;
          }
       }
       return EMPTY_DIRECTIVE;
    }
 
    public int getSortingStatus(int column)
    {
       return getDirective(column).direction;
    }
 
    public String getSortPropertyName(int column)
    {
       return valueListTableModel.getSortPropertyName(column);
    }
 
    private void sortingStatusChanged()
    {
       clearSortingState();
       fireTableDataChanged();
       if (tableHeader != null)
       {
          tableHeader.repaint();
       }
    }
 
    public void setSortingStatus(int column, int status, boolean fireChange)
    {
       Directive directive = getDirective(column);
       if (directive != EMPTY_DIRECTIVE)
       {
          sortingColumns.remove(directive);
       }
       if (status != NOT_SORTED)
       {
          sortingColumns.add(new Directive(column, status));
       }
       if (fireChange)
       {
          sortingStatusChanged();
       }
    }
 
    protected Icon getHeaderRendererIcon(int column, int size)
    {
       Directive directive = getDirective(column);
       if (directive == EMPTY_DIRECTIVE)
       {
          return null;
       }
       return new Arrow(directive.direction == DESCENDING, size, sortingColumns.indexOf(directive));
    }
 
    private void cancelSorting()
    {
       sortingColumns.clear();
       sortingStatusChanged();
    }
 
    public void setColumnComparator(Class type, Comparator comparator)
    {
       if (comparator == null)
       {
          columnComparators.remove(type);
       }
       else
       {
          columnComparators.put(type, comparator);
       }
    }
 
    protected Comparator getComparator(int column)
    {
       Class columnType = tableModel.getColumnClass(column);
       Comparator comparator = (Comparator) columnComparators.get(columnType);
       if (comparator != null)
       {
          return comparator;
       }
       if (Comparable.class.isAssignableFrom(columnType))
       {
          return COMPARABLE_COMAPRATOR;
       }
       return LEXICAL_COMPARATOR;
    }
 
    private Row[] getViewToModel()
    {
       if (viewToModel == null)
       {
          int tableModelRowCount = tableModel.getRowCount();
          viewToModel = new Row[tableModelRowCount];
          for (int row = 0; row < tableModelRowCount; row++)
          {
             viewToModel[row] = new Row(row);
          }
 
          if (isSorting())
          {
             Arrays.sort(viewToModel);
          }
       }
       return viewToModel;
    }
 
    public int modelIndex(int viewIndex)
    {
       Row[] rows = getViewToModel();
       if (viewIndex < 0 || viewIndex >= rows.length)
       {
          return -1;
       }
       else
       {
          return rows[viewIndex].modelIndex;
       }
    }
 
    public int viewIndex(int modelIndex)
    {
       if (modelIndex < 0)
       {
          return -1;
       }
       int[] modelToView = getModelToView();
       if (modelIndex < 0 || modelIndex >= modelToView.length)
       {
          return modelIndex;
       }
       else
       {
          return modelToView[modelIndex];
       }
    }
 
    private int[] getModelToView()
    {
       if (modelToView == null)
       {
          int n = getViewToModel().length;
          modelToView = new int[n];
          for (int i = 0; i < n; i++)
          {
             modelToView[modelIndex(i)] = i;
          }
       }
       return modelToView;
    }
 
    // TableModel interface methods 
 
    public int getRowCount()
    {
       return (tableModel == null) ? 0 : tableModel.getRowCount();
    }
 
    public int getColumnCount()
    {
       return (tableModel == null) ? 0 : tableModel.getColumnCount();
    }
 
    public String getColumnName(int column)
    {
       return tableModel.getColumnName(column);
    }
 
    public Class getColumnClass(int column)
    {
       return tableModel.getColumnClass(column);
    }
 
    public boolean isCellEditable(int row, int column)
    {
       return tableModel.isCellEditable(modelIndex(row), column);
    }
 
    public Object getValueAt(int row, int column)
    {
       return tableModel.getValueAt(modelIndex(row), column);
    }
 
    public void setValueAt(Object aValue, int row, int column)
    {
       tableModel.setValueAt(aValue, modelIndex(row), column);
    }
 
    /***
     * @return Returns the sortingColumns.
     */
    public List getSortingColumns()
    {
       return sortingColumns;
    }
 
    /***
     * @see net.mlw.vlh.swing.ValueListTableModel#trimFromBottomOfList()
     */
    public synchronized int trimFromList(int maxSize)
    {
       if (valueListTableModel != null)
       {
          int size = valueListTableModel.getRowCount();
          if (size >= maxSize)
          {
             int index = modelIndex(0);
             modelToView = null;
             viewToModel = null;
             valueListTableModel.trimFromList(0);
             fireTableRowsDeleted(0, 1);
             return index;
          }
          else
          {
             return -1;
          }
       }
       else
       {
          throw new IllegalStateException("A ValueListTableModel must be assigned to call this method.");
       }
 
    }
 
    public int addBean(Object bean)
    {
       if (valueListTableModel != null)
       {
          modelToView = null;
          viewToModel = null;
          int size = valueListTableModel.getRowCount();
          valueListTableModel.addBean(bean);
          fireTableRowsInserted(size, size + 1);
          return viewIndex(size);
       }
       else
       {
          throw new IllegalStateException("A ValueListTableModel must be assigned to call this method.");
       }
    }
 
    public int removeBean(Object bean)
    {
       if (valueListTableModel != null)
       {
          int index = valueListTableModel.removeBean(bean);
          modelToView = null;
          viewToModel = null;
 
          fireTableRowsDeleted(index, index + 1);
          return viewIndex(index);
       }
       else
       {
          throw new IllegalStateException("A ValueListTableModel must be assigned to call this method.");
       }
    }
 
    // Helper classes
 
    private class Row implements Comparable
    {
       private int modelIndex;
 
       public Row(int index)
       {
          this.modelIndex = index;
       }
 
       public int compareTo(Object o)
       {
          int row1 = modelIndex;
          int row2 = ((Row) o).modelIndex;
 
          for (Iterator it = sortingColumns.iterator(); it.hasNext();)
          {
             Directive directive = (Directive) it.next();
             int column = directive.column;
             Object o1 = tableModel.getValueAt(row1, column);
             Object o2 = tableModel.getValueAt(row2, column);
 
             int comparison = 0;
             // Define null less than everything, except null.
             if (o1 == null && o2 == null)
             {
                comparison = 0;
             }
             else if (o1 == null)
             {
                comparison = -1;
             }
             else if (o2 == null)
             {
                comparison = 1;
             }
             else
             {
                comparison = getComparator(column).compare(o1, o2);
             }
             if (comparison != 0)
             {
                return directive.direction == DESCENDING ? -comparison : comparison;
             }
          }
          return 0;
       }
    }
 
    private class TableModelHandler implements TableModelListener
    {
       public void tableChanged(TableModelEvent e)
       {
          // If we're not sorting by anything, just pass the event along.             
          if (!isSorting())
          {
             clearSortingState();
             fireTableChanged(e);
             return;
          }
 
          // If the table structure has changed, cancel the sorting; the             
          // sorting columns may have been either moved or deleted from             
          // the model. 
          if (e.getFirstRow() == TableModelEvent.HEADER_ROW)
          {
             cancelSorting();
             fireTableChanged(e);
             return;
          }
 
          // We can map a cell event through to the view without widening             
          // when the following conditions apply: 
          // 
          // a) all the changes are on one row (e.getFirstRow() == e.getLastRow()) and, 
          // b) all the changes are in one column (column != TableModelEvent.ALL_COLUMNS) and,
          // c) we are not sorting on that column (getSortingStatus(column) == NOT_SORTED) and, 
          // d) a reverse lookup will not trigger a sort (modelToView != null)
          //
          // Note: INSERT and DELETE events fail this test as they have column == ALL_COLUMNS.
          // 
          // The last check, for (modelToView != null) is to see if modelToView 
          // is already allocated. If we don't do this check; sorting can become 
          // a performance bottleneck for applications where cells  
          // change rapidly in different parts of the table. If cells 
          // change alternately in the sorting column and then outside of             
          // it this class can end up re-sorting on alternate cell updates - 
          // which can be a performance problem for large tables. The last 
          // clause avoids this problem. 
          int column = e.getColumn();
          if (e.getFirstRow() == e.getLastRow() && column != TableModelEvent.ALL_COLUMNS && getSortingStatus(column) == NOT_SORTED
                && modelToView != null)
          {
             int viewIndex = getModelToView()[e.getFirstRow()];
             fireTableChanged(new TableModelEvent(TableSorter.this, viewIndex, viewIndex, column, e.getType()));
             return;
          }
 
          // Something has happened to the data that may have invalidated the row order. 
          clearSortingState();
          fireTableDataChanged();
          return;
       }
    }
 
    private class MouseHandler extends MouseAdapter
    {
       public void mouseClicked(MouseEvent e)
       {
          JTableHeader h = (JTableHeader) e.getSource();
          TableColumnModel columnModel = h.getColumnModel();
          int viewColumn = columnModel.getColumnIndexAtX(e.getX());
          int column = columnModel.getColumn(viewColumn).getModelIndex();
          if (column != -1)
          {
             int status = getSortingStatus(column);
             if (!e.isControlDown())
             {
                cancelSorting();
             }
             // Cycle the sorting states through {NOT_SORTED, ASCENDING, DESCENDING} or 
             // {NOT_SORTED, DESCENDING, ASCENDING} depending on whether shift is pressed. 
             status = status + (e.isShiftDown() ? -1 : 1);
             status = (status + 4) % 3 - 1; // signed mod, returning {-1, 0, 1}
 
             if (actionListener != null)
             {
                setSortingStatus(column, status, false);
                actionListener.actionPerformed(new ActionEvent(e.getSource(), e.getID(), ValueListHelper.ACTION_COMMAND_SORT, e
                      .getModifiers()));
             }
             else
             {
                setSortingStatus(column, status, true);
             }
 
          }
       }
    }
 
    private static class Arrow implements Icon
    {
       private boolean descending;
 
       private int size;
 
       private int priority;
 
       public Arrow(boolean descending, int size, int priority)
       {
          this.descending = descending;
          this.size = size;
          this.priority = priority;
       }
 
       public void paintIcon(Component c, Graphics g, int x, int y)
       {
          Color color = c == null ? Color.GRAY : c.getBackground();
          // In a compound sort, make each succesive triangle 20% 
          // smaller than the previous one. 
          int dx = (int) (size / 2 * Math.pow(0.8, priority));
          int dy = descending ? dx : -dx;
          // Align icon (roughly) with font baseline. 
          y = y + 5 * size / 6 + (descending ? -dy : 0);
          int shift = descending ? 1 : -1;
          g.translate(x, y);
 
          // Right diagonal. 
          g.setColor(color.darker());
          g.drawLine(dx / 2, dy, 0, 0);
          g.drawLine(dx / 2, dy + shift, 0, shift);
 
          // Left diagonal. 
          g.setColor(color.brighter());
          g.drawLine(dx / 2, dy, dx, 0);
          g.drawLine(dx / 2, dy + shift, dx, shift);
 
          // Horizontal line. 
          if (descending)
          {
             g.setColor(color.darker().darker());
          }
          else
          {
             g.setColor(color.brighter().brighter());
          }
          g.drawLine(dx, 0, 0, 0);
 
          g.setColor(color);
          g.translate(-x, -y);
       }
 
       public int getIconWidth()
       {
          return size;
       }
 
       public int getIconHeight()
       {
          return size;
       }
    }
 
    private class SortableHeaderRenderer implements TableCellRenderer
    {
       private TableCellRenderer tableCellRenderer;
 
       public SortableHeaderRenderer(TableCellRenderer tableCellRenderer)
       {
          this.tableCellRenderer = tableCellRenderer;
       }
 
       public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column)
       {
          Component c = tableCellRenderer.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
          if (c instanceof JLabel)
          {
             JLabel l = (JLabel) c;
             l.setHorizontalTextPosition(JLabel.LEFT);
             int modelColumn = table.convertColumnIndexToModel(column);
             l.setIcon(getHeaderRendererIcon(modelColumn, l.getFont().getSize()));
          }
          return c;
       }
    }
 
    public static class Directive
    {
       private int column;
 
       private int direction;
 
       public Directive(int column, int direction)
       {
          this.column = column;
          this.direction = direction;
       }
 
       /***
        * @return Returns the column.
        */
       public int getColumn()
       {
          return column;
       }
 
       /***
        * @return Returns the direction.
        */
       public int getDirection()
       {
          return direction;
       }
    }
 
    public Object getBean(int row)
    {
       return valueListTableModel.getBean(row);
    }
 
    public void setValueList(ValueList valueList)
    {
       modelToView = null;
       viewToModel = null;
       valueListTableModel.setValueList(valueList);
    }
 
    public boolean contains(Object bean)
    {
       if (valueListTableModel != null)
       {
          return valueListTableModel.contains(bean);
       }
       else
       {
          throw new IllegalStateException("A ValueListTableModel must be assigned to call this method.");
       }
    }
 }