/**
    * 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;
  
  
  import java.util.Comparator;
  import java.util.Iterator;
  import java.util.Spliterator;
  import java.util.Spliterators;
  import java.util.stream.Stream;
  import java.util.stream.StreamSupport;
  
  import javax.jcr.Item;
  import javax.jcr.Node;
  import javax.jcr.RepositoryException;
  
  import org.apache.commons.collections4.iterators.IteratorChain;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.vaadin.data.provider.Query;
  
  /**
   * Utility class for JCR-based {@link com.vaadin.data.provider.DataProvider}s.
   */
  class JcrDataProviderUtils {
      private static final Logger log = LoggerFactory.getLogger(JcrDataProviderUtils.class);
  
      private JcrDataProviderUtils() {
      }
  
      static Stream<Item> streamJcrItems(Iterator<Item> items) {
          //noinspection unchecked
          return StreamSupport.stream(Spliterators.spliteratorUnknownSize(items, Spliterator.DISTINCT | Spliterator.NONNULL), false);
      }
  
      static Stream<Item> streamQueryResults(Query<Item, DataFilter> query, Iterator<Item> items) {
          return streamJcrItems(items)
                  .filter(node ->
                          query.getFilter()
                                  .map(DataFilter::getPathFilter)
                                  .map(path -> isItemPathMatching(node, path))
                                  .orElse(true)
                  );
      }
  
      static IteratorChain<Item> getChildren(Item item, boolean includeProperties) throws RepositoryException {
          IteratorChain<Item> iteratorChain = new IteratorChain<>();
          if (item.isNode()) {
              Node node = (Node) item;
              iteratorChain.addIterator(node.getNodes());
              if (includeProperties) {
                  final Stream<Item> stream = streamJcrItems(node.getProperties());
                  iteratorChain.addIterator(stream.sorted(Comparator.comparing(property -> {
                      try {
                          return property.getName();
                      } catch (RepositoryException e) {
                          return "";
                      }
                  })).iterator());
              }
          }
          return iteratorChain;
      }
  
      private static Boolean isItemPathMatching(Item item, String pathFragment) {
          try {
              final String itemPath = item.getPath();
             return itemPath.startsWith(pathFragment) || pathFragment.startsWith(itemPath);
         } catch (RepositoryException e) {
             log.warn("Failed to check whether item path [{}] matches prefix [{}}, since the item is missing", item, pathFragment, e.getMessage());
             return false;
         }
     }
 }