package fr.ifremer.quadrige3.ui.swing.table.action;
   
   /*
    * #%L
    * Reef DB :: UI
    * $Id:$
    * $HeadURL:$
    * %%
    * Copyright (C) 2014 - 2015 Ifremer
   * %%
   * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Affero General Public License as published by
   * the Free Software Foundation, either version 3 of the License, or
   * (at your option) any later version.
   * 
   * 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 Affero General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   * #L%
   */
  
  import fr.ifremer.quadrige3.core.dao.technical.Assert;
  import fr.ifremer.quadrige3.ui.swing.table.*;
  import fr.ifremer.quadrige3.ui.swing.table.editor.AbstractCellEditor;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import javax.swing.AbstractAction;
  import javax.swing.SwingUtilities;
  import javax.swing.table.TableCellEditor;
  import java.awt.Component;
  import java.awt.event.ActionEvent;
  
  /**
   * Abstract Action performed on a table responsive on key bindings
   * <p/>
   * Created by Ludovic on 01/06/2015.
   */
  public abstract class AbstractCellSelectionAction extends AbstractAction {
  
      private static final Log LOG = LogFactory.getLog(AbstractCellSelectionAction.class);
      private SwingTable currentTable;
      private final AbstractTableUIHandler handler;
      private final boolean forceStopEditingBeforeAction;
      private boolean previousTerminateEditOnFocusLost;
  
      /**
       * <p>Constructor for AbstractCellSelectionAction.</p>
       *  @param name a {@link String} object.
       * @param handler a {@link AbstractTableUIHandler} object.
       * @param forceStopEditingBeforeAction
       */
      public AbstractCellSelectionAction(String name, AbstractTableUIHandler handler, boolean forceStopEditingBeforeAction) {
          super(name);
          this.handler = handler;
          this.forceStopEditingBeforeAction = forceStopEditingBeforeAction;
      }
  
      private AbstractTableModel getTableModel() {
          return handler.getTableModel();
      }
  
      public SwingTable getCurrentTable() {
          return currentTable;
      }
  
      public void setCurrentTable(SwingTable currentTable) {
          this.currentTable = currentTable;
      }
  
      private SwingTable getMainTable() {
          return handler.getTable();
      }
  
      private SwingTable getLeftTable() {
          return handler.getFixedTable();
      }
  
      protected boolean onLeftTable() {
          return getCurrentTable() == getLeftTable();
      }
  
      protected boolean onMainTable() {
          return getCurrentTable() == getMainTable();
      }
  
      protected void switchToLeftTable() {
          if (onMainTable() && getLeftTable() != null) {
              stopActiveEdition();
              getMainTable().clearSelection();
              setCurrentTable(getLeftTable());
          }
      }
  
      protected void switchToMainTable() {
         if (onLeftTable()) {
             stopActiveEdition();
             getLeftTable().clearSelection();
             setCurrentTable(getMainTable());
         }
     }
 
     @Override
     public void actionPerformed(ActionEvent e) {
         Assert.isInstanceOf(SwingTable.class, e.getSource(), "This action must be performed on a SwingTable");
 
         setCurrentTable((SwingTable) e.getSource());
 
         beforeAction();
         actionPerformed();
         SwingUtilities.invokeLater(this::afterAction);
     }
 
     private void beforeAction() {
         previousTerminateEditOnFocusLost = getMainTable().isTerminateEditOnFocusLost();
         // disable terminate action on focus lost to prevent focus problem switching both tables
         getMainTable().setTerminateEditOnFocusLost(false);
         if (getLeftTable() != null)
             getLeftTable().setTerminateEditOnFocusLost(false);
     }
 
     private void afterAction() {
         getMainTable().setTerminateEditOnFocusLost(previousTerminateEditOnFocusLost);
         if (getLeftTable() != null)
             getLeftTable().setTerminateEditOnFocusLost(previousTerminateEditOnFocusLost);
     }
 
     protected abstract void actionPerformed();
 
     /**
      * <p>isTableEditing.</p>
      *
      * @return a boolean.
      */
     protected boolean isTableEditing() {
         return getCurrentTable().isEditing();
     }
 
     protected boolean isForceStopEditingBeforeAction() {
         return forceStopEditingBeforeAction;
     }
 
     /**
      * <p>isCreateNewRow.</p>
      *
      * @return a boolean.
      */
     protected boolean isCreateNewRow() {
         return getTableModel().isCreateNewRow();
     }
 
     /**
      * <p>addNewRow.</p>
      */
     protected void addNewRow() {
         // stop previous cell editing first
         if (stopActiveEdition()) {
             // add a new row in model
             getTableModel().addNewRow();
         }
     }
 
     /**
      * <p>getRowCount.</p>
      *
      * @return a int.
      */
     protected int getRowCount() {
         return getCurrentTable().getRowCount();
     }
 
     /**
      * <p>getColumnCount.</p>
      *
      * @return a int.
      */
     protected int getColumnCount() {
         return getCurrentTable().getColumnCount();
     }
 
     /**
      * <p>getSelectedRow.</p>
      *
      * @return a int.
      */
     protected int getSelectedRow() {
         return getCurrentTable().getSelectedRow();
     }
 
     /**
      * <p>getSelectedColumn.</p>
      *
      * @return a int.
      */
     protected int getSelectedColumn() {
         return getCurrentTable().getSelectedColumn();
     }
 
     /**
      * <p>getNextColumn.</p>
      *
      * @param column a int.
      * @return a int.
      */
     protected int getNextColumn(int column) {
         int nextColumn = column;
         do {
             nextColumn++;
         } while (nextColumn < getColumnCount() && getCurrentTable().getColumn(nextColumn) instanceof FixedColumn);
 
         if (nextColumn >= getColumnCount() && onLeftTable()) {
             // switch to main table
             switchToMainTable();
             return getNextColumn(-1);
         }
 
         return nextColumn;
     }
 
     /**
      * <p>getPreviousColumn.</p>
      *
      * @param column a int.
      * @return a int.
      */
     protected int getPreviousColumn(int column) {
         int nextColumn = column;
         do {
             nextColumn--;
         } while (nextColumn >= 0 && getCurrentTable().getColumn(nextColumn) instanceof FixedColumn);
 
         if (nextColumn < 0 && onMainTable() && getLeftTable() != null) {
             // switch to left table
             switchToLeftTable();
             return getPreviousColumn(getColumnCount());
         }
 
         return nextColumn;
     }
 
     /**
      * <p>isCellValid.</p>
      *
      * @param row a int.
      * @param column a int.
      * @return a boolean.
      */
     protected boolean isCellValid(int row, int column) {
         return row > -1 && column > -1 && row < getRowCount() && column < getColumnCount();
     }
 
     /**
      * <p>isCellEditable.</p>
      *
      * @param row a int.
      * @param column a int.
      * @return a boolean.
      */
     protected boolean isCellEditable(int row, int column) {
         return isCellValid(row, column)
             && getCurrentTable().isCellEditable(row, column)
             && !(getCurrentTable().getColumn(column) instanceof FixedColumn);
     }
 
     /**
      * <p>selectCell.</p>
      *
      * @param row a int.
      * @param column a int.
      * @return a boolean.
      */
     protected boolean selectCell(int row, int column) {
 
         if (!isCellValid(row, column))
             return false;
 
         // stop previous cell editing first
         if (!stopActiveEdition())
             return false;
 
         getCurrentTable().setColumnSelectionInterval(column, column);
         getCurrentTable().setRowSelectionInterval(row, row);
         getCurrentTable().scrollCellToVisible(row, column);
         return true;
     }
 
     /**
      * <p>editCell.</p>
      *
      * @param row a int.
      * @param column a int.
      */
     protected void editCell(int row, int column) {
         if (selectCell(row, column)) {
             getCurrentTable().editCellAt(row, column);
             TableCellEditor editor = getCurrentTable().getCellEditor();
             if (editor instanceof AbstractCellEditor)
                 ((AbstractCellEditor) editor).getTextField().requestFocus();
         }
     }
 
     /**
      * <p>stopActiveEdition.</p>
      *
      * @return a boolean.
      */
     protected boolean stopActiveEdition() {
 
         TableCellEditor editor = getMainTable().getCellEditor();
         boolean stopped = editor == null || editor.stopCellEditing();
 
         if (getLeftTable() != null) {
             editor = getLeftTable().getCellEditor();
             stopped &= editor == null || editor.stopCellEditing();
         }
 
         return stopped;
     }
 
     /**
      * <p>selectNextComponent.</p>
      */
     protected void selectNextComponent() {
         Component next = handler.getNextComponentToFocus();
         if (next != null) {
             afterAction();
             SwingUtilities.invokeLater(next::requestFocusInWindow);
         }
     }
 
     /**
      * <p>selectPreviousComponent.</p>
      */
     protected void selectPreviousComponent() {
         Component previous = handler.getPreviousComponentToFocus();
         if (previous != null) {
             afterAction();
             SwingUtilities.invokeLater(previous::requestFocusInWindow);
         }
     }
 
     public enum Direction {
         NEXT_CELL, PREVIOUS_CELL, NEXT_ROW, PREVIOUS_ROW
     }
 }