/*
    * Copyright (c) 2007 Creative Sphere Limited.
    * All rights reserved. This program and the accompanying materials
    * are made available under the terms of the Eclipse Public License v1.0
    * which accompanies this distribution, and is available at
    * http://www.eclipse.org/legal/epl-v10.html
    *
    * Contributors:
    *
   *   Creative Sphere - initial API and implementation
   *
   */
  package org.abstracthorizon.aequo.gui;
  
  import java.awt.Point;
  import java.awt.Rectangle;
  import java.awt.event.MouseEvent;
  import java.awt.event.MouseListener;
  import java.awt.event.MouseMotionListener;
  
  import javax.swing.JList;
  import javax.swing.JPopupMenu;
  import javax.swing.ListSelectionModel;
  import javax.swing.event.MouseInputListener;
  
  import org.abstracthorizon.aequo.CompareModel;
  import org.abstracthorizon.aequo.ListModelAdapter;
  
  /**
   * Extension of {@link JList} class that provides mouse handling and ties it with {@link CompareModel}.
   *
   * @author Daniel Sendula
   */
  public class CompareList extends JList {
  
      /** Model */
      protected CompareModel<?, ?> model;
      
      /** Focused index */
      protected int focusedIndex;
  
      /**
       * Constructor
       * @param model model
       */
      public CompareList(final CompareModel<?, ?> model) {
          super(new ListModelAdapter(model));
          adjustMouseListeners();
      }
      
      /**
       * Returns focused index
       * @return focused index
       */
      public int getFocusedIndex() {
          return focusedIndex;
      }
      
      /**
       * Returns compare model
       * @return compare model
       */
      public CompareModel<?, ?> getCompareModel() {
          return model;
      }
      
      /**
       * This method adjusts mouse listeners of the component - it removes existing and
       * adds own.
       */
      protected void adjustMouseListeners() {
          MouseListener[] mls = getMouseListeners();
          for (MouseListener ml : mls) {
              removeMouseListener(ml);
          }
          MouseMotionListener[] mmls = getMouseMotionListeners();
          for (MouseMotionListener mml : mmls) {
              removeMouseMotionListener(mml);
          }
          MouseHandler mouseInputHandler = new MouseHandler();
          addMouseListener(mouseInputHandler);
          addMouseMotionListener(mouseInputHandler);
      }
  
      /**
       * Mouse handler that deals with selecting rows and popup menu. 
       */
      public class MouseHandler implements MouseInputListener {
          
          private int startIndex = -1;
          private int lastIndex = -1;
          private int[] startIndices;
          private boolean select = false;
  
          public MouseHandler() {
          }
          
          public void mouseClicked(MouseEvent e) {}
  
         public void mouseEntered(MouseEvent e) {}
 
         public void mouseExited(MouseEvent e) {}
 
         public void mousePressed(MouseEvent e) {
             int i = selectedIndex(e.getPoint());
             focusedIndex = i;
             if ((e.getButton() == MouseEvent.BUTTON1) || ((i >= 0) && !isSelectedIndex(i))) {
                 startIndex = i;
                 lastIndex = -1;
                 if (e.isControlDown()) {
                     if (isSelectedIndex(i)) {
                         select = false;
                         removeSelectionInterval(i, i);
                     } else {
                         select = true;
                         getSelectionModel().addSelectionInterval(i, i);
                     }
                     startIndices = getSelectedIndices();
                 } else {
                     select = true;
                     startIndices = null;
                     setSelectedIndex(i);
                 }
             } else if ((e.getButton() == MouseEvent.BUTTON2) && !isSelectedIndex(i)) {
                 getSelectionModel().addSelectionInterval(i, i);
             } else {
                 startIndex = -1;
             }
             e.getComponent().requestFocus();
         }
 
 
         public void mouseDragged(MouseEvent e) {
             int i = selectedIndex(e.getPoint());
             focusedIndex = i;
 
             // TODO - starting selection upwards doesn't work properly!
             ListSelectionModel selectionModel = getSelectionModel();
             if (i >= 0) {
                 boolean ok = false;
                 if (lastIndex < 0) {
                     if (select) {
                         selectionModel.addSelectionInterval(startIndex, i);
                     } else {
                         selectionModel.removeSelectionInterval(startIndex, i);
                     }
                     ok = true;
                 } else if (startIndex <= lastIndex) {
                     if (lastIndex < i) {
                         if (select) {
                             selectionModel.addSelectionInterval(lastIndex, i);
                         } else {
                             selectionModel.removeSelectionInterval(lastIndex, i);
                         }
                     } else if (i < lastIndex) {
                         restoreSelection(i + 1, lastIndex);
                     }
                     ok = true;
                 } else if (lastIndex < startIndex) {
                     if (i < lastIndex) {
                         if (select) {
                             selectionModel.addSelectionInterval(i, lastIndex);
                         } else {
                             selectionModel.removeSelectionInterval(i, lastIndex);
                         }
                     } else if (lastIndex < i) {
                         restoreSelection(lastIndex, i - 1);
                     }
                     ok = true;
                 }
                 
                 
                 lastIndex = i;
                 if (ok) {
                     scrollRectToVisible(getUI().getCellBounds(CompareList.this, i, i));
                 }
             }
         }
 
         public void mouseMoved(MouseEvent e) {
         }
 
         public void mouseReleased(MouseEvent e) {
             startIndex = -1;
             startIndices = null;
             if (e.getButton() == MouseEvent.BUTTON3) {
                 JPopupMenu menu = getComponentPopupMenu();
                 if (menu != null) {
                     Point p = getPopupLocation(e);
                     if (p != null) {
                         menu.show(CompareList.this, p.x, p.y);
                     }
                 }
             }
         }
      
         /**
          * Returns list of selected indexes
          * @return list of selected indexes
          */
         protected int[] getSelectedIndices() {
             ListSelectionModel selectionModel = getSelectionModel();
             int min = selectionModel.getMinSelectionIndex();
             int max = selectionModel.getMaxSelectionIndex();
 
             if ((min >= 0) && (max >= 0)) {
         
                 int size = 0;
                 int[] res = new int[(max - min) + 1];
                 for (int i = min; i <= max; i++) {
                     if (selectionModel.isSelectedIndex(i)) {
                         res[size] = i;
                         size = size + 1;
                     }
                 }
                 int[] r = new int[size];
                 System.arraycopy(res, 0, r, 0, size);
                 return r;
             } else {
                 return null;
             }
         }
         
         /**
          * Restores selection
          * @param from from index
          * @param to to index
          */
         protected void restoreSelection(int from, int to) {
             if (startIndices == null) {
                 removeSelectionInterval(from, to);
             } else {
                 // TODO 
                 
                 ListSelectionModel selectionModel = getSelectionModel();
                 selectionModel.setValueIsAdjusting(true);
                 selectionModel.removeSelectionInterval(from, to);
                 
                 int i = 0;
                 while ((i < startIndices.length) && (startIndices[i] <= to)) {
                     int ind = startIndices[i];
                     if (ind >= from) {
                         selectionModel.addSelectionInterval(ind,ind);
                     }
                     i = i + 1;
                 }
                 selectionModel.setValueIsAdjusting(false);
             }
         }
 
     }
 
     /**
      * Returns an index of selected entry from given point. 
      * 
      * @param p point 
      * @return index or -1 if outside of extries
      */
     public int selectedIndex(Point p) {
         int i = getUI().locationToIndex(CompareList.this, p);
         Rectangle r = getUI().getCellBounds(CompareList.this, i,  i);
         if (r != null) {
             if (r.contains(p)) {
                 return i;
             }
         }
         return -1;
     }
 }