/**
    * This file Copyright (c) 2017 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.rest.delivery.jcr.decorator;
  
  import info.magnolia.jcr.util.NodeUtil;
  
  import java.math.BigDecimal;
  import java.util.List;
  import java.util.stream.Collectors;
  
  import javax.jcr.Binary;
  import javax.jcr.Item;
  import javax.jcr.ItemVisitor;
  import javax.jcr.Node;
  import javax.jcr.NodeIterator;
  import javax.jcr.PathNotFoundException;
  import javax.jcr.Property;
  import javax.jcr.PropertyIterator;
  import javax.jcr.RepositoryException;
  import javax.jcr.Session;
  import javax.jcr.Value;
  import javax.jcr.lock.Lock;
  import javax.jcr.nodetype.NodeDefinition;
  import javax.jcr.nodetype.NodeType;
  import javax.jcr.version.Version;
  
  import org.apache.jackrabbit.commons.AbstractNode;
  import org.apache.jackrabbit.commons.iterator.NodeIteratorAdapter;
  import org.apache.jackrabbit.commons.iterator.PropertyIteratorAdapter;
  import org.apache.jackrabbit.util.ChildrenCollectorFilter;
  
  /**
   * Read only {@link Node} implementation.
   */
  public class ReadOnlyNode extends AbstractNode {
      private final String name;
      private final Node parent;
      private final List<Property> properties;
      private final List<Node> children;
  
      public ReadOnlyNode(String name, Node parent, List<Node> children, List<Property> properties) {
          this.name = name;
          this.parent = parent;
          this.children = children;
          this.properties = properties;
      }
  
      public ReadOnlyNode(String name, Node parent, List<Item> items) {
          this.name = name;
          this.parent = parent;
          this.children = items.stream()
                  .filter(item -> item.isNode())
                  .map(item -> (Node) item)
                  .collect(Collectors.toList());
          this.properties = items.stream()
                  .filter(item -> !item.isNode())
                  .map(item -> (Property) item)
                  .collect(Collectors.toList());
      }
  
      @Override
      public String getIdentifier() throws RepositoryException {
          //TODO will be fixed with ref improvement feature.
          return "";
      }
  
      @Override
      public String getPath() throws RepositoryException {
         StringBuffer buffer = new StringBuffer(getParent().getPath());
         if (buffer.length() > 1) {
             buffer.append('/');
         }
         buffer.append("@" + this.name);
 
         return buffer.toString();
     }
 
     @Override
     public String getName() throws RepositoryException {
         return this.name;
     }
 
     @Override
     public int getIndex() throws RepositoryException {
         return 0;
     }
 
     @Override
     public boolean isNew() {
         return false;
     }
 
     @Override
     public boolean isModified() {
         return false;
     }
 
     @Override
     public boolean isSame(Item item) throws RepositoryException {
         return false;
     }
 
     @Override
     public void accept(ItemVisitor visitor) throws RepositoryException {
         visitor.visit(this);
     }
 
     @Override
     public Node getParent() throws RepositoryException {
         return parent;
     }
 
     @Override
     public Session getSession() throws RepositoryException {
         return parent.getSession();
     }
 
     @Override
     public NodeType getPrimaryNodeType() throws RepositoryException {
         return parent.getPrimaryNodeType();
     }
 
     @Override
     public Node getNode(String relPath) throws RepositoryException {
         return children.stream()
                 .filter(node -> relPath.equals(NodeUtil.getPathIfPossible(node)))
                 .findFirst()
                 .orElseThrow(() -> new PathNotFoundException(String.format("%s not found!", relPath)));
     }
 
     @Override
     public NodeIterator getNodes() throws RepositoryException {
         return new NodeIteratorAdapter(this.children.iterator());
     }
 
     @Override
     public NodeIterator getNodes(String namePattern) throws RepositoryException {
         return ChildrenCollectorFilter.collectChildNodes(this, namePattern);
     }
 
     @Override
     public NodeIterator getNodes(String[] nameGlobs) throws RepositoryException {
         return ChildrenCollectorFilter.collectChildNodes(this, nameGlobs);
     }
 
     @Override
     public PropertyIterator getProperties() throws RepositoryException {
         return new PropertyIteratorAdapter(this.properties);
     }
 
     @Override
     public PropertyIterator getProperties(String namePattern) throws RepositoryException {
         return ChildrenCollectorFilter.collectProperties(this, namePattern);
     }
 
     @Override
     public PropertyIterator getProperties(String[] nameGlobs) throws RepositoryException {
         return ChildrenCollectorFilter.collectProperties(this, nameGlobs);
     }
 
     @Override
     public void setPrimaryType(String primaryType) throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public Node addNode(String s) throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public Node addNode(String s, String s1) throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public void orderBefore(String s, String s1) throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public Property setProperty(String s, Value value) throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public Property setProperty(String s, Value[] values) throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public Property setProperty(String s, Binary binary) throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public Property setProperty(String s, BigDecimal bigDecimal) throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public PropertyIterator getReferences() throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public PropertyIterator getReferences(String s) throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public PropertyIterator getWeakReferences() throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public PropertyIterator getWeakReferences(String s) throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public Item getPrimaryItem() throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public void addMixin(String s) throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public void removeMixin(String s) throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public boolean canAddMixin(String s) throws RepositoryException {
         return false;
     }
 
     @Override
     public NodeDefinition getDefinition() throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public Version checkin() throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public void checkout() throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public void doneMerge(Version version) throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public void cancelMerge(Version version) throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public void update(String s) throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public NodeIterator merge(String s, boolean b) throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public String getCorrespondingNodePath(String s) throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public NodeIterator getSharedSet() throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public void removeSharedSet() throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public void removeShare() throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public void restore(Version version, String s, boolean b) throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public Version getBaseVersion() throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public Lock lock(boolean b, boolean b1) throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public Lock getLock() throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public void unlock() throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public void followLifecycleTransition(String s) throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public String[] getAllowedLifecycleTransistions() throws RepositoryException {
         return new String[0];
     }
 
     @Override
     public void save() throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public void refresh(boolean b) throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 
     @Override
     public void remove() throws RepositoryException {
         throw new UnsupportedOperationException("Not implemented.");
     }
 }