/**
    * This file Copyright (c) 2013-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.module.groovy.support.nodes;
  
  import groovy.lang.DelegatingMetaClass;
  import groovy.lang.GroovySystem;
  import groovy.lang.MetaClass;
  
  import info.magnolia.cms.security.AccessDeniedException;
  import info.magnolia.jcr.RuntimeRepositoryException;
  import info.magnolia.jcr.iterator.DelegatingNodeIterator;
  import info.magnolia.jcr.util.MetaDataUtil;
  import info.magnolia.jcr.util.NodeTypes;
  import info.magnolia.jcr.util.NodeUtil;
  import info.magnolia.jcr.util.PropertyUtil;
  import info.magnolia.jcr.wrapper.DelegateNodeWrapper;
  
  import java.math.BigDecimal;
  import java.util.ArrayList;
  import java.util.List;
  
  import javax.jcr.Node;
  import javax.jcr.NodeIterator;
  import javax.jcr.PathNotFoundException;
  import javax.jcr.Property;
  import javax.jcr.PropertyIterator;
  import javax.jcr.PropertyType;
  import javax.jcr.RepositoryException;
  import javax.jcr.Value;
  import javax.jcr.ValueFormatException;
  
  import org.apache.commons.lang3.StringUtils;
  import org.apache.jackrabbit.commons.iterator.NodeIteratorAdapter;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Implementation of wrapped Node object used in Groovy console context.
   * This makes it possible, for example, navigating the nodes in a Magnolia repository
   * with a <code>. (dot)</code> notation and access their properties with <code>.</code> or <code>.@</code> notation
   * much like it happens when using the result of parsing an xml with groovy's {@link groovy.util.XmlSlurper#XmlSlurper}.
   * For example, here is how, in a groovy script, one could navigate to and print the node data named <em>abstract</em>:
   * 
   * <pre>
   * session = ctx.getJCRSession('website')
   * node = session.getNode('/demo-project')
   * println node.about.history.abstract
   * </pre>
   * 
   * The above example can also be made more groovy-like by using the <code>@</code> notation to access the property
   * 
   * <pre>
   * node.about.history.@abstract
   * </pre>
   * 
   * As <code>node</code> is also a {@link Node}, you can call any of its
   * methods. E.g.
   * 
   * <pre>
   * println node.metaData.template
   * println node.about.title
   * println node.about.parent <strong>(this can return null)</strong>
   * </pre>
   * 
   * <br/>
   * If you want to iterate over <i>properties</i> for a certain node you can do for instance
   * 
   * <pre>
  * node.about.properties.each {println it.name}
  * </pre>
  * 
  * It is also possible to assign values to properties or create new ones. E.g.
  * 
  * <pre>
  * node.foo = 3.14d
  * node.bar = true
  * node.baz = 'some text'
  * node.qux = 100
  * </pre>
  * 
  * will assign the values on the right hand side to the node data on left hand side. Should those not exist, they will
  * be automatically created. Furthermore, the correct type will be detected based on the value assigned (i.e. Boolean,
  * String, Calendar, Long or Double). <br/>
  * <br/>
  * <strong>IMPORTANT:</strong> All the above assignments will be in-memory only unless explicitly persisted via a call
  * to <code>save()</code> on a parent node.
  */
 public class MgnlGroovyJCRNode extends DelegateNodeWrapper {
 
     static {
         // wrap the standard MetaClass with the delegate
         setMetaClass(GroovySystem.getMetaClassRegistry().getMetaClass(MgnlGroovyJCRNode.class), MgnlGroovyJCRNode.class);
     }
 
     protected static final Logger log = LoggerFactory.getLogger(MgnlGroovyJCRNode.class);
 
     private String name;
 
     public MgnlGroovyJCRNode(Node node) {
         super(node);
         try {
             this.name = "/".equals(node.getPath()) ? "/root" : getName();
         } catch (RepositoryException e) {
             throw new RuntimeRepositoryException(e);
         }
     }
 
     protected static void setMetaClass(final MetaClass metaClass, Class nodeClass) {
         final MetaClass newMetaClass = new DelegatingMetaClass(metaClass) {
 
             @Override
             public Object getAttribute(final Object object, final String attribute) {
                 MgnlGroovyJCRNode n = (MgnlGroovyJCRNode) object;
                 try {
                     return n.get("@" + attribute);
                 } catch (ValueFormatException e) {
                     log.error(e.getMessage());
                 } catch (RepositoryException e) {
                     log.error(e.getMessage());
                 }
                 return null;
             }
 
             @Override
             public void setAttribute(final Object object, final String attribute, final Object newValue) {
                 MgnlGroovyJCRNode n = (MgnlGroovyJCRNode) object;
                 try {
                     PropertyUtil.setProperty(n, attribute, newValue);
                 }
                 catch (AccessDeniedException e) {
                     log.error(e.getMessage());
                 }
                 catch (PathNotFoundException e) {
                     log.error(e.getMessage());
                 }
                 catch (RepositoryException e) {
                     log.error(e.getMessage());
                 }
             }
 
             @Override
             public Object getProperty(Object object, String property) {
                 if (object instanceof MgnlGroovyJCRNode) {
                     MgnlGroovyJCRNode n = (MgnlGroovyJCRNode) object;
                     try {
                         return n.get(property);
                     } catch (ValueFormatException e) {
                         log.error(e.getMessage());
                     } catch (RepositoryException e) {
                         log.error(e.getMessage());
                     }
                     return null;
                 }
                 return super.getProperty(object, property);
             }
 
             @Override
             public void setProperty(Object object, String property, Object newValue) {
                 String attribute = null;
                 if (property.startsWith("@")) {
                     attribute = property.substring(1);
                 } else {
                     attribute = property;
                 }
                 MgnlGroovyJCRNode n = (MgnlGroovyJCRNode) object;
                 try {
                     // else you get java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.Long
                     if (newValue instanceof Integer) {
                         newValue = ((Integer) newValue).longValue();
                     }
                     PropertyUtil.setProperty(n, attribute, newValue);
                 }
                 catch (AccessDeniedException e) {
                     log.error(e.getMessage());
                 }
                 catch (PathNotFoundException e) {
                     log.error(e.getMessage());
                 }
                 catch (RepositoryException e) {
                     log.error(e.getMessage());
                 }
             }
         };
 
         GroovySystem.getMetaClassRegistry().setMetaClass(nodeClass, newMetaClass);
     }
 
     public String name() {
         return name;
     }
 
     /**
      * Provides lookup of elements by non-namespaced name.
      * 
      * @param key the name (or shortcut key) of the node(s) of interest
      * @return the nodes which match key
      * @throws RepositoryException
      * @throws ValueFormatException
      */
     public Object get(String key) throws ValueFormatException, RepositoryException {
         if (key != null && key.charAt(0) == '@') {
             String attributeName = key.substring(1);
             Property property = PropertyUtil.getPropertyOrNull(getWrappedNode(), attributeName);
             return getPropertyValue(property);
         }
         try {
             if ("parent".equals(key)) {
                 return getParent();
             }
             if ("children".equals(key) || "nodes".equals(key)) {
                 Iterable<Node> iterable = NodeUtil.getNodes(getWrappedNode());
                 return new MgnlGroovyWrappingNodeIterator(new NodeIteratorAdapter(iterable.iterator()));
             }
             if ("metaData".equals(key)) {
                 return MetaDataUtil.getMetaData(getWrappedNode());
             }
             if ("properties".equals(key)) {
                 return getProperties();
             }
             if ("name".equals(key)) {
                 return name;
             }
             return new MgnlGroovyJCRNode(getNode(key));
 
         } catch (RepositoryException e) {
             log.info(e.getMessage());
         }
 
         // last attempt: lets assume the client requested for an attribute without the @ notation
         Property property = PropertyUtil.getPropertyOrNull(getWrappedNode(), key);
         return getPropertyValue(property);
     }
 
     /**
      * Returns the value for the given property.
      * The Java types returned vary according to the underlying {@link PropertyType}.
      * <ul>
      * <li> {@link PropertyType#STRING} returns a {@link String}
      * <li> {@link PropertyType#DATE} returns a {@link java.util.Calendar}
      * <li> {@link PropertyType#DOUBLE} returns a {@link BigDecimal}
      * <li> {@link PropertyType#LONG} returns a {@link BigDecimal}
      * <li> {@link PropertyType#BINARY} returns the {@link java.io.InputStream} value.
      * <li>All other property types will be returned as {@link String}(s)
      * </ul>
      */
     protected Object getPropertyValue(Property property) throws RepositoryException, ValueFormatException {
         if (property == null) {
             return "unknown property";
         }
         if (property.isMultiple()) {
             List<Object> values = new ArrayList<Object>();
             for (Value value : property.getValues()) {
                 values.add(getPropertyValueInternal(value));
             }
             return values;
         } else {
             return getPropertyValueInternal(property.getValue());
         }
 
     }
 
     public String print() {
         StringBuilder retVal = new StringBuilder();
         try {
             Iterable<Node> nodes = NodeUtil.getNodes(getWrappedNode());
             retVal.append("(+) " + name + "\n");
             for (Node node : nodes) {
                 if (!showNode(node)) {
                     continue;
                 }
                 if ((NodeUtil.getNodes(node).iterator().hasNext())) {
                     retVal.append("\t(+) ");
                 } else {
                     retVal.append("\t(-) ");
                 }
                 retVal.append(node.getName() + "\n");
             }
 
             if (getProperties().getSize() > 0) {
                 PropertyIterator it = super.getProperties();
                 while (it.hasNext()) {
                     Property property = it.nextProperty();
                     if (!showProperty(property)) {
                         continue;
                     }
                     String name = property.getName();
 
                     retVal.append("\t\t* " + name + ": ["
                             + StringUtils.abbreviate(getPropertyValue(property).toString(), 80)
                             + "]\n");
 
                 }
 
             }
         } catch (ValueFormatException e) {
             e.printStackTrace();
         } catch (RepositoryException e) {
             e.printStackTrace();
         }
 
         return retVal.toString();
     }
 
     @Override
     public int hashCode() {
         final int prime = 31;
         int result = 1;
         result = prime * result + ((name == null) ? 0 : name.hashCode());
         return result;
     }
 
     @Override
     public boolean equals(Object obj) {
         if (this == obj)
             return true;
         if (obj == null)
             return false;
         if (getClass() != obj.getClass())
             return false;
         MgnlGroovyJCRNode other = (MgnlGroovyJCRNode) obj;
         if (name == null) {
             if (other.name != null)
                 return false;
         } else
             try {
                 if (!getIdentifier().equals(other.getIdentifier()))
                     return false;
             } catch (RepositoryException e) {
                 return false;
             }
         return true;
     }
 
     /**
      * MgnlGroovyWrappingNodeIterator.
      */
     protected class MgnlGroovyWrappingNodeIterator extends DelegatingNodeIterator {
         public MgnlGroovyWrappingNodeIterator(NodeIterator iterator) {
             super(iterator);
         }
 
         @Override
         public Node nextNode() {
             return new MgnlGroovyJCRNode(super.nextNode());
         }
 
         @Override
         public Object next() {
             return new MgnlGroovyJCRNode((Node) super.next());
         }
     }
 
     protected boolean showNode(Node node) {
         try {
             if (NodeTypes.MetaData.NAME.equals(node.getPrimaryNodeType().getName())
                     || node.getName().startsWith("jcr:")
                     || node.getName().startsWith("rep:")) {
                 return false;
             }
         } catch (RepositoryException e) {
             log.error(e.getMessage());
             return false;
         }
         return true;
     }
 
     protected boolean showProperty(Property property) {
         try {
             if (property.getName().startsWith("jcr:")) {
                 return false;
             }
         } catch (RepositoryException e) {
             log.error(e.getMessage());
             return false;
         }
         return true;
     }
 
     private Object getPropertyValueInternal(Value property) throws RepositoryException {
         switch (property.getType()) {
         case PropertyType.STRING:
             return property.getString();
         case PropertyType.BOOLEAN:
             return property.getBoolean();
         case PropertyType.BINARY:
             return property.getBinary().getStream();
         case PropertyType.DATE:
             return property.getDate();
         case PropertyType.DECIMAL:
             return property.getDecimal();
         case PropertyType.DOUBLE:
             return BigDecimal.valueOf(property.getDouble());
         case PropertyType.LONG:
             return BigDecimal.valueOf(property.getLong());
         default:
             return property.getString();
         }
     }
 
 }