/**
    * This file Copyright (c) 2003-2010 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 groovy.xml.QName;
  import info.magnolia.cms.core.Content;
  import info.magnolia.cms.core.ItemType;
  import info.magnolia.cms.core.NodeData;
  import info.magnolia.cms.security.AccessDeniedException;
  import info.magnolia.cms.util.ContentWrapper;
  
  import java.math.BigDecimal;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.List;
  
  import javax.jcr.PathNotFoundException;
  import javax.jcr.PropertyType;
  import javax.jcr.RepositoryException;
  import javax.jcr.Value;
  import javax.jcr.ValueFormatException;
  
  import org.apache.commons.collections.IteratorUtils;
  import org.apache.commons.lang.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  
  /**
   * A special <em>groovish</em> implementation of Magnolia's {@link ContentWrapper}.
   * 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 XmlSlurper}. For example, here is how, in a groovy
   * script, one could navigate to and print the node data named <em>abstract</em>:
   * <pre>
   * hm = ctx.getHierarchyManager('website')
   * node = hm.getContent(hm, '/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 attribute
   * <pre>
   * node.about.history.@abstract
   * </pre>
   * As <code>node</code> is also a {@link Content}, you can call any of its
   * methods. E.g.
   * <pre>
   * println node.metaData.template
   * println node.about.children.title
   * println node.about.parent <strong>(this can return null)</strong>
   * </pre>
   * <strong>IMPORTANT:</strong> The <code>.children</code> shortcut, unlikely {@link Content#getChildren()}, <strong>always returns {@link ItemType#CONTENT}s AND {@link ItemType#CONTENTNODE}s </strong>.
   * If you only need either type, then call directly one of the {@link Content#getChildren()} methods on the parent node.
   *<br/>
   *<br/>
  
   * If you want to look at the <i>attributes</i> or <i>data</i> for a certain node you can simply call
   * <pre>
   * println node.about.nodeData
   * </pre>
   *
   * It is also possible to assign values to node data or create new ones. E.g.
   * <pre>
   * node.boo = 3.14d
  * node.coo = true
  * node.foo = 'some text'
  * node.doo = 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, 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.
  *
  * @author fgrilli
  * @version $Id$
  */
 public class MgnlGroovyNode extends ContentWrapper {
 
     static {
         // wrap the standard MetaClass with the delegate
         setMetaClass(GroovySystem.getMetaClassRegistry().getMetaClass(MgnlGroovyNode.class), MgnlGroovyNode.class);
     }
 
     protected static final Logger log = LoggerFactory.getLogger(MgnlGroovyNode.class);
 
     private String name;
 
     public MgnlGroovyNode(Content content) {
         super(content);
         this.name = content.getName();
     }
 
     protected static void setMetaClass(final MetaClass metaClass, Class nodeClass) {
         final MetaClass newMetaClass = new DelegatingMetaClass(metaClass) {
 
             public Object getAttribute(final Object object, final String attribute) {
                 MgnlGroovyNode n = (MgnlGroovyNode) object;
                 return n.get("@" + attribute);
             }
 
             public void setAttribute(final Object object, final String attribute, final Object newValue) {
                 MgnlGroovyNode n = (MgnlGroovyNode) object;
                 try {
                     n.setNodeData(attribute, newValue);
                 }
                 catch (AccessDeniedException e) {
                     log.error(e.getMessage());
                 }
                 catch (PathNotFoundException e) {
                     log.error(e.getMessage());
                 }
                 catch (RepositoryException e) {
                     log.error(e.getMessage());
                 }
             }
 
             public Object getProperty(Object object, String property) {
                 if (object instanceof MgnlGroovyNode) {
                     MgnlGroovyNode n = (MgnlGroovyNode) object;
                     return n.get(property);
                 }
                 return super.getProperty(object, property);
             }
 
             public void setProperty(Object object, String property, Object newValue) {
                 String attribute = null;
                 if (property.startsWith("@")) {
                     attribute = property.substring(1);
                 } else {
                     attribute = property;
                 }
                 MgnlGroovyNode n = (MgnlGroovyNode) 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();
                     }
                     n.setNodeData(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 Iterator<Content> iterator(){
         return getChainedChildrenIterator();
     }
 
     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
      */
     public Object get(String key) {
         if (key != null && key.charAt(0) == '@') {
             String attributeName = key.substring(1);
             return getNodeDataValue(attributeName);
         }
         if ("parent".equals(key)) {
             try {
                 return getParent();
             }
             catch (RepositoryException e) {
                 return null;
             }
         }
         if ("children".equals(key)) {
             Collection<Content> retVal = getChildren();
             retVal.addAll(getChildren(ItemType.CONTENTNODE));
             return retVal;
         }
         if("metaData".equals(key)){
             return getMetaData();
         }
         if("nodeData".equals(key)){
             return getNodeDataCollection();
         }
         Content retVal = getByName(key);
         if(retVal != null){
             return retVal;
         }
         //last attempt: lets assume the client requested for an attribute without the @ notation
         return getNodeDataValue(key);
     }
 
     @Override
     protected Content wrap(Content node) {
         return new MgnlGroovyNode(node);
     }
 
     /**
      * Returns  the value for the given attribute (nodeData).
      * 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 Calendar}
      * <li> {@link PropertyType#DOUBLE} returns a {@link BigDecimal}
      * <li> {@link PropertyType#LONG} returns a {@link BigDecimal}
      * <li> {@link PropertyType#BINARY} returns the {@link BinaryNodeData} value.
      * <li> All other property types will be returned as {@link String}(s)
      * </ul>
      */
     protected Object getNodeDataValue(String attributeName) {
         Collection<NodeData> data = getNodeDataCollection(attributeName);
         Iterator<NodeData> it = data.iterator();
         if(!it.hasNext()) {
             return null;
         }
         NodeData nodeData = it.next();
         Value propertyValue = nodeData.getValue();
         Object value = null;
         if (propertyValue != null) {
             try {
                 switch (propertyValue.getType()) {
                     case PropertyType.STRING :
                         value = propertyValue.getString();
                         break;
                     case PropertyType.BINARY :
                         value = propertyValue;
                         break;
                     case PropertyType.DATE :
                         value = propertyValue.getDate();
                         break;
                     case PropertyType.DOUBLE:
                         value = BigDecimal.valueOf(propertyValue.getDouble());
                         break;
                     case  PropertyType.LONG:
                         value = BigDecimal.valueOf(propertyValue.getLong());
                         break;
                     default :
                         value = propertyValue.getString();
                 }
             }
             catch (ValueFormatException e) {
                 log.warn(e.getMessage());
             }
             catch (IllegalStateException e) {
                 log.warn(e.getMessage());
             }
             catch (RepositoryException e) {
                 log.warn(e.getMessage());
             }
         }
         return value;
     }
 
     /**
      * Provides lookup of elements by QName.
      * @param name the QName of interest
      * @return the nodes matching name
      * @deprecated This method is wrong and luckily unused by this module. Use {@link MgnlGroovyNode#getByName(String)} instead.
      */
     public List<Content> getAt(QName name) {
         List<Content> answer = new ArrayList<Content>();
         for (Iterator<Content> iter = getChainedChildrenIterator(); iter.hasNext();) {
                 Content childNode = iter.next();
                 Object childNodeName = childNode.getName();
                 if (name.matches(childNodeName)) {
                     answer.add(childNode);
                 }
         }
         return answer;
     }
 
     /**
      * Provides lookup of elements by name. Also handles {@link QName}s
      * @param name the name of interest
      * @return the nodes matching name
      */
     protected Content getByName(String name) {
         for (Iterator<Content> iter = getChainedChildrenIterator(); iter.hasNext();) {
             Content childNode = iter.next();
             Object childNodeName = childNode.getName();
             if (childNodeName instanceof QName) {
                 QName qn = (QName) childNodeName;
                 if (qn.matches(name)) {
                     return childNode;
                 }
             }
             else if (name.equals(childNodeName)) {
                 return childNode;
             }
         }
         return null;
     }
 
     public String toString() {
         StringBuilder retVal = new StringBuilder();
         Iterator<Content> iterator = getChainedChildrenIterator();
         retVal.append("(+) " + name + "\n");
         while (iterator.hasNext()) {
             Content c = iterator.next();
             if (hasMoreChildren(c)) {
                 retVal.append("\t(+) ");
             } else {
                 retVal.append("\t(-) ");
             }
             retVal.append(c.getName() + "\n");
         }
 
         if (!getNodeDataCollection().isEmpty()) {
             for (NodeData nodeData : getNodeDataCollection()) {
                 retVal.append("\t\t* " + nodeData.getName() + ": ["
                         + StringUtils.abbreviate(nodeData.getString(), 80)
                         + "]\n");
             }
 
         }
 
         return retVal.toString();
     }
 
     @SuppressWarnings("unchecked")
     private Iterator<Content> getChainedChildrenIterator() {
         return IteratorUtils.chainedIterator(getChildren().iterator(), getChildren(ItemType.CONTENTNODE).iterator());
     }
 
     private boolean hasMoreChildren(Content c){
         return c.hasChildren() || c.hasChildren(ItemType.CONTENTNODE.getSystemName());
     }
 
     @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;
         MgnlGroovyNode other = (MgnlGroovyNode) obj;
         if (name == null) {
             if (other.name != null)
                 return false;
         } else if (!getHandle().equals(other.getHandle()))
             return false;
         return true;
     }
 
     /*TODO
      * public void print(PrintWriter out) {
        new MgnlGroovyNodePrinter(out).print(this);
     }
     */
 
 
 }