/**
    * This file Copyright (c) 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.contentapp.browser;
  
  import static java.util.stream.Collectors.toList;
  
  import java.lang.reflect.Field;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.function.BiPredicate;
  import java.util.function.Predicate;
  
  import com.vaadin.data.Binder;
  import com.vaadin.data.PropertySet;
  import com.vaadin.data.provider.HierarchicalDataCommunicator;
  import com.vaadin.data.provider.HierarchicalDataProvider;
  import com.vaadin.data.provider.HierarchyMapper;
  import com.vaadin.shared.Range;
  import com.vaadin.ui.Grid;
  import com.vaadin.ui.TreeGrid;
  import com.vaadin.ui.components.grid.Editor;
  import com.vaadin.ui.components.grid.EditorImpl;
  
  /**
   * Magnolia-specific {@link TreeGrid} implementation.
   * @param <T> item type.
   */
  public class MagnoliaTreeGrid<T> extends TreeGrid<T> {
  
      private final Predicate<T> itemInteractionAvailability;
      private final BiPredicate<Column, T> cellEditingAvailability;
  
      public MagnoliaTreeGrid(PropertySet<T> propertySet, Predicate<T> itemInteractionAvailability, BiPredicate<Column, T> cellEditingAvailability) {
          super(propertySet, new RemovedChildrenFilteringDataCommunicator<>(itemInteractionAvailability));
          this.itemInteractionAvailability = itemInteractionAvailability;
          this.cellEditingAvailability = cellEditingAvailability;
          setPropertySet(propertySet);
          
          getEditor().addOpenListener(e -> {
              if (!this.itemInteractionAvailability.test(e.getBean())) {
                  getEditor().cancel();
              }
          });
  
          addSelectionListener(e -> e.getAllSelectedItems().forEach(item -> {
              if (!itemInteractionAvailability.test(item)) {
                  deselect(item);
              }
          }));
      }
  
      @Override
      public void select(T item) {
          if (itemInteractionAvailability.test(item)) {
              super.select(item);
          }
      }
  
      @Override
      protected Editor<T> createEditor() {
          return new EditableCellFilteringEditor<>(getPropertySet(), this, itemInteractionAvailability, cellEditingAvailability);
      }
  
      /**
       * Special implementation of {@link HierarchicalDataCommunicator} which
       * will not refresh an item should it be not available according to the
      * {@link ItemInteractionAvailability}, also facilitates a {@link RemovedChildrenFilteringHierarchyMapper}
      * instead of a stock one.
      *
      * @param <T>
      *     item type
      */
     static class RemovedChildrenFilteringDataCommunicator<T> extends HierarchicalDataCommunicator<T> {
 
         private final Predicate<T> itemInteractionAvailability;
 
         RemovedChildrenFilteringDataCommunicator(Predicate<T> itemInteractionAvailability) {
             this.itemInteractionAvailability = itemInteractionAvailability;
         }
 
         @Override
         protected <F> HierarchyMapper<T, F> createHierarchyMapper(HierarchicalDataProvider<T, F> dataProvider) {
             return new RemovedChildrenFilteringHierarchyMapper<>(dataProvider, itemInteractionAvailability);
         }
 
         @Override
         public void refresh(T data) {
             if (itemInteractionAvailability.test(data)) {
                 super.refresh(data);
             }
         }
     }
 
     /**
      * Hierarchy mapper implementation which will purge the removed
      * child items from the internal books when the parent node is
      * collapsed.
      *
      * @param <T>
      *     item type
      * @param <F>
      *     filter type
      */
     static class RemovedChildrenFilteringHierarchyMapper<T, F> extends HierarchyMapper<T, F> {
 
         private final Predicate<T> itemInteractionAvailability;
 
         RemovedChildrenFilteringHierarchyMapper(HierarchicalDataProvider<T, F> provider, Predicate<T> itemInteractionAvailability) {
             super(provider);
             this.itemInteractionAvailability = itemInteractionAvailability;
         }
 
         @Override
         public Range collapse(T item, Integer position) {
             int removedChildren;
             if (itemInteractionAvailability.test(item)) {
                 final Map<T, Set<T>> relationMap = accessChildMap();
                 final Set<T> children = relationMap.get(item);
 
                 removedChildren = (int) children.stream().filter(child -> !itemInteractionAvailability.test(child)).count();
             } else {
                 getDataProvider().refreshAll();
                 return Range.emptyRange();
             }
 
             final Range toCollapse = super.collapse(item, position);
             return Range.between(toCollapse.getStart(), toCollapse.getEnd() + removedChildren);
         }
 
         @SuppressWarnings("unchecked")
         Map<T, Set<T>> accessChildMap() {
             try {
                 final Field childMapField = HierarchyMapper.class.getDeclaredField("childMap");
                 childMapField.setAccessible(true);
                 return (Map<T, Set<T>>) childMapField.get(this);
             } catch (NoSuchFieldException | IllegalAccessException e) {
                 throw new RuntimeException(e);
             }
         }
     }
 
     /**
      * {@link EditorImpl} extension which will prevent certain cells from being
      * edited (based on {@link ItemInteractionAvailability}) by manipulating the
      * underlying {@link Binder} binding set.
      *
      * @param <T>
      *     data type
      */
     private static class EditableCellFilteringEditor<T> extends EditorImpl<T> {
 
         private final Grid<T> grid;
         private final Predicate<T> itemInteractionAvailability;
         private final BiPredicate<Column, T> cellEditingAvailability;
 
         EditableCellFilteringEditor(PropertySet<T> propertySet, Grid<T> grid, Predicate<T> itemInteractionAvailability, BiPredicate<Column, T> cellEditingAvailability) {
             super(propertySet);
             this.grid = grid;
             this.itemInteractionAvailability = itemInteractionAvailability;
             this.cellEditingAvailability = cellEditingAvailability;
             setBinder(new BindingFilterableBinder<>(propertySet));
         }
 
         @Override
         public BindingFilterableBinder<T> getBinder() {
             return (BindingFilterableBinder<T>) super.getBinder();
         }
 
         @Override
         @SuppressWarnings("unchecked")
         protected void doEdit(T bean) {
             if (!itemInteractionAvailability.test(bean)) {
                 cancel();
                 return;
             }
 
             // resolve all the columns that are editable in context of current item
             final List<String> activeColumns = grid.getColumns().stream()
                     .filter(Column::isEditable)
                     .filter(column -> cellEditingAvailability.test(column, bean))
                     .map(Column::getId)
                     .collect(toList());
 
             // collect all the related bindings
             final List<Binder.Binding> binding = activeColumns.stream()
                     .map(grid::getColumn)
                     .map(Column::getId)
                     .map(id -> grid.getColumn(id).getEditorBinding())
                     .collect(toList());
 
             // set the bindings to the binder
             getBinder().setBindings((List) binding);
 
             super.doEdit(bean);
 
             // remove all the currently non-editable cell components from the editor state
             retainOnlyActiveCellComponents(activeColumns);
         }
 
         private void retainOnlyActiveCellComponents(List<String> activeColumns) {
             final Iterator<Map.Entry<String, String>> componentMappings = getState().columnFields.entrySet().iterator();
             final List<String> internalColumnIds = activeColumns.stream()
                     .map(grid::getColumn)
                     .map(this::getInternalIdForColumn)
                     .collect(toList());
 
             while (componentMappings.hasNext()) {
                 final Map.Entry<String, String> mapping = componentMappings.next();
                 if (!internalColumnIds.contains(mapping.getKey())) {
                     componentMappings.remove();
                 }
             }
         }
 
         /**
          * Simple {@link Binder} extension which allows to override
          * the current binding set.
          *
          * @param <TYPE>
          *     bound data type
          */
         static class BindingFilterableBinder<TYPE> extends Binder<TYPE> {
 
             private BindingFilterableBinder(PropertySet<TYPE> propertySet) {
                 super(propertySet);
             }
 
             public void setBindings(List<Binding<TYPE, ?>> bindings) {
                 accessBindings().clear();
                 accessBindings().addAll(bindings);
             }
 
             @SuppressWarnings("unchecked")
             List<Binding> accessBindings() {
                 try {
                     final Field childMapField = Binder.class.getDeclaredField("bindings");
                     childMapField.setAccessible(true);
                     return (List<Binding>) childMapField.get(this);
                 } catch (NoSuchFieldException | IllegalAccessException e) {
                     throw new RuntimeException(e);
                 }
             }
         }
 
     }
 }