/**
    * This file Copyright (c) 2011-2018 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.ui.workbench.tree;
  
  import info.magnolia.ui.vaadin.grid.MagnoliaTreeTable;
  import info.magnolia.ui.workbench.list.ListViewImpl;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.List;
  import java.util.Set;
  
  import com.vaadin.event.Action;
  import com.vaadin.event.Action.Handler;
  import com.vaadin.event.FieldEvents.BlurEvent;
  import com.vaadin.event.FieldEvents.BlurListener;
  import com.vaadin.event.ShortcutAction;
  import com.vaadin.event.dd.DropHandler;
  import com.vaadin.v7.data.Container;
  import com.vaadin.v7.data.Property;
  import com.vaadin.v7.event.ItemClickEvent;
  import com.vaadin.v7.event.ItemClickEvent.ItemClickListener;
  import com.vaadin.v7.ui.Field;
  import com.vaadin.v7.ui.Table;
  import com.vaadin.v7.ui.Table.ColumnGenerator;
  import com.vaadin.v7.ui.Table.TableDragMode;
  import com.vaadin.v7.ui.Tree.CollapseEvent;
  import com.vaadin.v7.ui.Tree.CollapseListener;
  import com.vaadin.v7.ui.Tree.ExpandEvent;
  import com.vaadin.v7.ui.Tree.ExpandListener;
  import com.vaadin.v7.ui.TreeTable;
  
  /**
   * Default Vaadin implementation of the tree view.
   */
  public class TreeViewImpl extends ListViewImpl implements TreeView {
  
      private TreeTable tree;
  
      private boolean editable;
      private final List<Object> editableColumns = new ArrayList<Object>();
      private InplaceEditingFieldFactory fieldFactory;
      private ExpandListener expandListener;
      private CollapseListener collapseListener;
      private Action.Container shortcutActionManager;
      private EditingKeyboardHandler editingKeyboardHandler;
      private ColumnGenerator bypassedColumnGenerator;
      private TreeRowScroller rowScroller;
  
      @Override
      protected TreeTable createTable(Container container) {
          return new MagnoliaTreeTable(container);
      }
  
      @Override
      protected void initializeTable(Table table) {
          super.initializeTable(table);
          this.tree = (TreeTable) table;
          rowScroller = new TreeRowScroller(tree);
          collapseListener = new CollapsedNodeListener();
          tree.addCollapseListener(collapseListener);
      }
  
      @Override
      public void select(List<Object> itemIds) {
          super.select(itemIds);
          tree.focus();
         if (itemIds != null && !itemIds.isEmpty()) {
             rowScroller.bringRowIntoView(itemIds.get(0));
         }
     }
 
     @Override
     public void expand(Object itemId) {
         rowScroller.expandTreeToNode(itemId, true);
     }
 
     @Override
     protected TreeView.Listener getListener() {
         return (TreeView.Listener) super.getListener();
     }
 
     @Override
     public TreeTable asVaadinComponent() {
         return tree;
     }
 
     @Override
     public void setEditable(boolean editable) {
         if (editable) {
             // field factory
             fieldFactory = new InplaceEditingFieldFactory();
             fieldFactory.setFieldBlurListener(new BlurListener() {
 
                 @Override
                 public void blur(BlurEvent event) {
                     Object source = event.getSource();
                     if (source instanceof Field<?>) {
                         saveItemProperty(((Field<?>) source).getPropertyDataSource());
                     }
                     setEditing(null, null);
                 }
             });
             tree.setTableFieldFactory(fieldFactory);
 
             // expanding tree must turn off editing
             expandListener = new ExpandListener() {
 
                 @Override
                 public void nodeExpand(ExpandEvent event) {
                     setEditing(null, null);
                 }
             };
 
             tree.addExpandListener(expandListener);
 
             // double-click listener
             ItemClickListener clickListener = new ItemClickListener() {
 
                 @Override
                 public void itemClick(ItemClickEvent event) {
                     if (event.isDoubleClick()) {
                         // always show item selection. See MGNLUI-3665
                         tree.select(event.getItemId());
                         setEditing(event.getItemId(), event.getPropertyId());
                     }
                 }
             };
             tree.addItemClickListener(clickListener);
 
             // keyboard shortcuts
             editingKeyboardHandler = new EditingKeyboardHandler(tree);
             if (shortcutActionManager != null) {
                 shortcutActionManager.addActionHandler(editingKeyboardHandler);
             }
 
         } else {
             tree.setTableFieldFactory(null);
             fieldFactory = null;
             tree.removeExpandListener(expandListener);
             expandListener = null;
             if (shortcutActionManager != null) {
                 shortcutActionManager.removeActionHandler(editingKeyboardHandler);
             }
             editingKeyboardHandler = null;
         }
 
         tree.setEditable(editable);
         this.editable = editable;
     }
 
     @Override
     public void setEditableColumns(Object... editablePropertyIds) {
         editableColumns.clear();
         editableColumns.addAll(Arrays.asList(editablePropertyIds));
     }
 
     private void setEditing(Object itemId, Object propertyId) {
 
         // restore generated column if it was disabled for editing
         if (bypassedColumnGenerator != null) {
             tree.addGeneratedColumn(fieldFactory.getEditingPropertyId(), bypassedColumnGenerator);
             bypassedColumnGenerator = null;
         }
 
         if (editable && editableColumns.contains(propertyId)) {
             if (itemId == null || propertyId == null) {
                 tree.focus();
                 fieldFactory.setEditing(null, null);
             } else {
                 // disable generated column for editing
                 if ((bypassedColumnGenerator = tree.getColumnGenerator(propertyId)) != null) {
                     tree.removeGeneratedColumn(propertyId);
                 }
                 fieldFactory.setEditing(itemId, propertyId);
             }
         } else {
             fieldFactory.setEditing(null, null);
         }
         tree.refreshRowCache();
     }
 
     private void saveItemProperty(Property<?> propertyDataSource) {
         getListener().onItemEdited(fieldFactory.getEditingItemId(), fieldFactory.getEditingPropertyId(), propertyDataSource);
     }
 
     @Override
     public void setDragAndDropHandler(DropHandler dropHandler) {
         if (dropHandler != null) {
             tree.setDragMode(TableDragMode.MULTIROW);
             tree.setDropHandler(dropHandler);
         } else {
             tree.setDragMode(TableDragMode.NONE);
             tree.setDropHandler(null);
         }
     }
 
     // KEYBOARD SHORTCUTS
 
     @Override
     public void setActionManager(Action.Container shortcutActionManager) {
         if (editable) {
             shortcutActionManager.addActionHandler(editingKeyboardHandler);
         }
         this.shortcutActionManager = shortcutActionManager;
     }
 
     public void setSortable(boolean sortable) {
         if (tree.getContainerDataSource() instanceof HierarchicalJcrContainer) {
             tree.setSortEnabled(sortable);
             ((HierarchicalJcrContainer) tree.getContainerDataSource()).setSortable(sortable);
         }
     }
 
     private final class CollapsedNodeListener implements CollapseListener {
 
         @Override
         public void nodeCollapse(CollapseEvent event) {
             // collapsing tree must turn off editing
             if (editable) {
                 setEditing(null, null);
             }
             Object collapsedNodeId = event.getItemId();
             // collapsed node descendants should be unselected as they're not visible, yet any ops affect them
             unselectDescendants(collapsedNodeId);
         }
     }
 
     private void unselectDescendants(final Object parentId) {
         if (tree.isMultiSelect()) {
             Set<Object> selectedIds = (Set<Object>) tree.getValue();
             for (Object id : selectedIds) {
                 if (isDescendantOf(id, parentId)) {
                     tree.unselect(id);
                 }
             }
         }
     }
 
     /**
      * @return <code>true</code> if itemId is a descendant of parentId, <code>false</code> otherwise.
      */
     boolean isDescendantOf(final Object itemId, final Object parentId) {
         Container.Hierarchical container = tree.getContainerDataSource();
         Object id = itemId;
         while (!container.isRoot(id)) {
             id = container.getParent(id);
             if (id.equals(parentId)) {
                 return true;
             }
         }
         return false;
     }
 
     /**
      * The Class EditingKeyboardHandler for keyboard shortcuts with inplace editing.
      */
     private class EditingKeyboardHandler implements Handler {
 
         private final ShortcutAction enter = new ShortcutAction("Enter", ShortcutAction.KeyCode.ENTER, null);
 
         private final ShortcutAction tabNext = new ShortcutAction("Tab", ShortcutAction.KeyCode.TAB, null);
 
         private final ShortcutAction tabPrev = new ShortcutAction("Shift+Tab", ShortcutAction.KeyCode.TAB, new int[] { ShortcutAction.ModifierKey.SHIFT });
 
         private final ShortcutAction escape = new ShortcutAction("Esc", ShortcutAction.KeyCode.ESCAPE, null);
 
         private final TreeTable tree;
 
         public EditingKeyboardHandler(TreeTable tree) {
             this.tree = tree;
         }
 
         @Override
         public Action[] getActions(Object target, Object sender) {
             // TODO: Find a better solution for handling tab key events: MGNLUI-1384
             return new Action[] { enter, tabNext, tabPrev, escape };
         }
 
         @Override
         public void handleAction(Action action, Object sender, Object target) {
             /*
              * In case of enter the Action needs to be casted back to
              * ShortcutAction because for some reason the object is not same
              * as this.enter object. In that case keycode is used in comparison.
              */
             if (!(action instanceof ShortcutAction)) {
                 return;
             }
             ShortcutAction shortcut = (ShortcutAction) action;
 
             // Because shortcutActionManager is typically the workbench's keyboardEventPanel, this handler might be called from other content views
             if (tree == null || !tree.isAttached()) {
                 return;
             }
 
             if (target != tree && target instanceof Field) {
                 Object editingItemId = fieldFactory.getEditingItemId();
                 Object editingPropertyId = fieldFactory.getEditingPropertyId();
                 if (shortcut == enter || shortcut.getKeyCode() == enter.getKeyCode()) {
                     saveItemProperty(fieldFactory.getField().getPropertyDataSource());
                     setEditing(null, null);
                     tree.focus();
                 } else if (action == tabNext) {
                     saveItemProperty(fieldFactory.getField().getPropertyDataSource());
                     editNextCell(getSelectedItemId(editingItemId), editingPropertyId);
                 } else if (action == tabPrev) {
                     saveItemProperty(fieldFactory.getField().getPropertyDataSource());
                     editPreviousCell(getSelectedItemId(editingItemId), editingPropertyId);
                 } else if (action == escape) {
                     setEditing(null, null);
                     tree.focus();
                 }
             } else if (target == tree) {
                 if (tree.getValue() == null) {
                     return;
                 }
 
                 if (shortcut == enter || shortcut.getKeyCode() == enter.getKeyCode()) {
                     editFirstCell();
 
                 }
             }
         }
 
         /**
          * Return selected item id from the tree or default value.
          */
         private Object getSelectedItemId(Object defaultItemId) {
             Object selectedItemId = null;
             if (tree.getValue() instanceof Collection<?>) {
                 Collection<?> values = (Collection<?>) tree.getValue();
                 if (!values.isEmpty()) {
                     selectedItemId = values.iterator().next();
                 }
             } else {
                 selectedItemId = tree.getValue();
             }
             return selectedItemId != null ? selectedItemId: defaultItemId;
         }
     }
 
     // EDITING API
 
     private void editNextCell(Object itemId, Object propertyId) {
         List<Object> visibleColumns = Arrays.asList(tree.getVisibleColumns());
         Object newItemId = itemId;
         Object columnId;
         int newColumn = visibleColumns.indexOf(propertyId);
         do {
             if (newColumn == visibleColumns.size() - 1) {
                 newItemId = tree.nextItemId(newItemId);
             }
             newColumn = (newColumn + 1) % visibleColumns.size();
             columnId = visibleColumns.get(newColumn);
         } while (newItemId != null && !(editableColumns.contains(columnId) && tree.getItem(newItemId).getItemProperty(columnId) != null));
 
         updateTreeEditingState(newItemId, columnId);
     }
 
     public void editPreviousCell(Object itemId, Object propertyId) {
         List<Object> visibleColumns = Arrays.asList(tree.getVisibleColumns());
         Object newItemId = itemId;
         Object columnId;
         int newColumn = visibleColumns.indexOf(propertyId);
         do {
             if (newColumn == 0) {
                 newItemId = tree.prevItemId(newItemId);
             }
             newColumn = (newColumn + visibleColumns.size() - 1) % visibleColumns.size();
             columnId = visibleColumns.get(newColumn);
         } while (newItemId != null && !(editableColumns.contains(columnId) && tree.getItem(newItemId).getItemProperty(columnId) != null));
 
         updateTreeEditingState(newItemId, columnId);
     }
 
     public void editFirstCell() {
 
         // get first selected itemId, handles multiple selection mode
         Object firstSelectedId = tree.getValue();
         if (firstSelectedId instanceof Collection) {
             if (((Collection<?>) firstSelectedId).size() > 0) {
                 firstSelectedId = ((Set<?>) firstSelectedId).iterator().next();
             } else {
                 firstSelectedId = null;
             }
         }
 
         // Edit selected row at first column
         Object propertyId = tree.getVisibleColumns()[0];
         if (!editableColumns.contains(propertyId)) {
             editNextCell(firstSelectedId, propertyId);
         } else {
             setEditing(firstSelectedId, propertyId);
         }
     }
 
     private void updateTreeEditingState(Object itemId, Object columnId) {
         if (!tree.isSelected(itemId) && itemId != null) {
             select(Arrays.asList(itemId));
         }
         if (itemId == null) {
             tree.focus();
         }
         setEditing(itemId, columnId);
     }
 }