package fr.ifremer.allegro.obsdeb.ui.swing.util.treetable;
   
   /*
    * #%L
    * SIH Allegro ObsDeb :: UI
    * $Id:$
    * $HeadURL:$
    * %%
    * Copyright (C) 2013 - 2014 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 com.google.common.collect.Lists;
  import jaxx.runtime.swing.nav.treetable.NavTreeTableHelper;
  import jaxx.runtime.swing.nav.treetable.NavTreeTableModel;
  import org.apache.commons.collections4.CollectionUtils;
  import org.jdesktop.swingx.JXTreeTable;
  
  import javax.swing.*;
  import java.util.Enumeration;
  import java.util.List;
  
  /**
   * abstract helper class to manage treetable (model/node/data provider)
   *
   * @author Ludovic Pecquot (ludovic.pecquot@e-is.pro)
   * @param <H> type of AbstractObsdebTreeTableUIHandler
   * @param <NM> type of NodeUIModel
   * @param <TN> type of TreeTableNode
   * @param <P> type of TreeTableDataProvider
   */
  public abstract class AbstractObsdebTreeTableHelper<H extends AbstractObsdebTreeTableUIHandler,
          NM extends AbstractObsdebNodeUIModel, TN extends AbstractObsdebTreeTableNode<NM, TN>, P extends AbstractObsdebTreeTableDataProvider<NM>>
      extends NavTreeTableHelper<TN> {
  
      protected final H handler;
  
      /**
       * Creates a new node when moving to next editable cell / row ?
       */
      protected final boolean createNewNode;
  
      public AbstractObsdebTreeTableHelper(H handler, P dataProvider, boolean createNewNode) {
          setDataProvider(dataProvider);
          this.handler = handler;
          this.createNewNode = createNewNode;
      }
  
      @Override
      public P getDataProvider() {
          return (P) super.getDataProvider();
      }
  
      public boolean isCreateNewNode() {
          return createNewNode;
      }
  
      public NavTreeTableModel createModel(AbstractObsdebTreeTableModel delegate) {
  
          // create the root node
          TN root = getNewRootNode();
  
          NavTreeTableModel model = createModel(root, delegate);
  
          // populate children's root
          root.populateChilds(getBridge(), getDataProvider());
  
          return model;
      }
  
      public AbstractObsdebTreeTableModel getTreeTableModel() {
          return (AbstractObsdebTreeTableModel) getModel().getDelegate();
      }
  
      /**
       * get the new root node to build the tree
       *
       * @return a tree table node
       */
      protected abstract TN getNewRootNode();
  
      /**
       * get a new node to insert in root
       *
       * @return a tree table node
       */
      protected abstract TN getNewNode();
 
     public void modelChanged() {
 
         // hack to empty the root's children, otherwise, the children are duplicated
         getRootNode().setAllowsChildren(false);
         getRootNode().setAllowsChildren(true);
 
         // reload new children
         getDataProvider().prepareData();
         getRootNode().populateNode(getBridge(), getDataProvider(), true);
 
         // redraw tree table
         getModel().getModelSupport().fireNewRoot();
         getTreeTable().expandAll();
 
         // reselect last node
 //        reselectLastNode();
         handler.onModelRowsChanged();
     }
 
 //    private void reselectLastNode() {
 ////        final TN lastNode = (TN) getTreeTableModel().getLastSelectedNode();
 //        final Integer lastRowIndex = getTreeTableModel().getLastRowIndex();
 //        final Integer lastColmunIndex = getTreeTableModel().getLastColumnIndex();
 //        if (lastRowIndex != null && lastColmunIndex != null) {
 //            SwingUtilities.invokeLater(new Runnable() {
 //
 //                @Override
 //                public void run() {
 ////                    TreePath path = new TreePath(lastNode);
 ////                    setSelectionPath(path);
 //                    getTreeTable().setRowSelectionInterval(lastRowIndex, lastRowIndex);
 //                    getTreeTable().setColumnSelectionInterval(lastColmunIndex, lastColmunIndex);
 //                    getTreeTableModel().setLastCellIndexes(null, null);
 //                }
 //            });
 //        }
 //    }
     public void flushModel() {
         getDataProvider().flushData();
     }
 
     public void addNewNode() {
         // add empty row on root
         TN newNode = getNewNode();
         insertNode(getRootNode(), newNode);
         selectNode(newNode);
     }
 
     public void removeSelectedRows() {
 
         List<TN> selectedNodes = getSelectedNodes();
 
         if (CollectionUtils.isNotEmpty(selectedNodes)) {
 
             // remove each node
             for (TN node : selectedNodes) {
 
                 getDataProvider().removeRow(node.getUserObject());
                 removeNode(node);
 
             }
 
             // nodes/lines have been removed and parent/child relation has changed, let reload the model
             flushModel();
             modelChanged();
 
         }
     }
 
     public void refreshRow(NM row) {
         // find the node containing the row
         TN node = findNode(getRootNode(), row.getNodeId());
         refreshNode(node, false);
     }
 
     public void refreshAll() {
         // try to refresh all nodes and treetable itself for repaint
         refreshNode(getRootNode(), true);
 //        getTreeTable().repaint();
     }
 
     public void duplicateSelectedNode() {
         NM rowToDuplicate = getSelectedNode().getUserObject();
         NM newRow = getDataProvider().getNewRow();
 
         duplicateRow(newRow, rowToDuplicate);
 
         flushModel();
         modelChanged();
     }
 
     /**
      *
      * @param newRow
      * @param rowToDuplicate
      */
     protected void duplicateRow(NM newRow, NM rowToDuplicate) {
         // do nothing by default
     }
 
     public JXTreeTable getTreeTable() {
         return getUI();
     }
 
     @Override
     public TN getSelectedNode() {
         return super.getSelectedNode();
     }
 
     @Override
     public List<TN> getSelectedNodes() {
 
         if (getTreeTable().getSelectionMode() == ListSelectionModel.SINGLE_SELECTION) {
 
             // find selected node models
             return findSelectedNodeModels(getRootNode());
         }
 
         // return selected nodes if selection mode is not single
         return super.getSelectedNodes();
     }
 
     private List<TN> findSelectedNodeModels(TN rootNode) {
 
         List<TN> selectedNodes = Lists.newArrayList();
 
         Enumeration<TN> e = rootNode.children();
         while (e.hasMoreElements()) {
             TN node = e.nextElement();
             if (node.isSelected()) {
                 selectedNodes.add(node);
             }
             if (node.getChildCount() > 0) {
                 selectedNodes.addAll(findSelectedNodeModels(node));
             }
         }
         return selectedNodes;
     }
 
     @Override
     public TN findNode(TN node, String... ids) {
         return super.findNode(node, ids);
     }
 
 }