/**
    * This file Copyright (c) 2003-2013 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.cms.util;
  
  import info.magnolia.cms.core.Content;
  import info.magnolia.cms.core.HierarchyManager;
  
  import java.io.PrintStream;
  import java.io.PrintWriter;
  import java.io.StringWriter;
  import java.util.Iterator;
  
  import javax.jcr.InvalidItemStateException;
  import javax.jcr.Node;
  import javax.jcr.NodeIterator;
  import javax.jcr.Property;
  import javax.jcr.PropertyIterator;
  import javax.jcr.PropertyType;
  import javax.jcr.RepositoryException;
  import javax.jcr.Session;
  import javax.jcr.Value;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Used to dump 1:1 repository content. The level defines how deep the recursion should go.
   * 
   * @author philipp
   * @version $Revision$ ($Author$)
   */
  public class DumperUtil {
  
      private static Logger log = LoggerFactory.getLogger(DumperUtil.class);
  
      /**
       * @deprecated since 5.2.1. Use {@link #dump(Node)} instead.
       */
      public static String dump(Content content) {
          return dump(content.getJCRNode(), 1);
      }
  
      public static String dump(Node node) {
          return dump(node, 1);
      }
  
      public static String dump(Node node, int level) {
          if (node == null) {
              return "";
          }
  
          StringWriter str = new StringWriter();
          try {
              PrintWriter writer = new PrintWriter(str);
              dump(node, level, writer);
              writer.flush();
          } catch (RepositoryException e) {
              log.error("can't dump", e);
          }
          return str.toString();
      }
  
      /**
       * Used to dump into a String.
       * 
       * @param content
       * @param level
       * @return
      * @deprecated since 5.2.1. Use {@link #dump(Node, int)} instead.
      */
     public static String dump(Content content, int level) {
         return dump(content.getJCRNode(), level);
     }
 
     /**
      * Dump to a stream.
      * 
      * @param content
      * @param level
      * @param out
      * @deprecated since 5.2.1. Use {@link #dump(Node, int, PrintStream)} instead.
      */
     public static void dump(Content content, int level, PrintStream out) {
         dump(content.getJCRNode(), level, out);
     }
 
     public static void dump(Node node, int level, PrintStream out) {
         if (node == null) {
             return;
         }
         try {
             PrintWriter writer = new PrintWriter(out);
             dump(node, level, writer);
             writer.flush();
         } catch (RepositoryException e) {
             log.error("can't dump", e);
         }
     }
 
     /**
      * Dump this node to a stream.
      * 
      * @param content
      * @param out
      * @deprecated since 5.2.1. Use {@link #dump(Node, PrintWriter)} instead.
      */
     public static void dump(Content content, PrintStream out) {
         dump(content, 1, out);
     }
 
     /**
      * Dump a JCR Node to a Writer.
      * 
      * @param n
      * @param level
      * @param out
      * @throws RepositoryException
      */
     public static void dump(Node n, int level, PrintWriter out) throws RepositoryException {
         out.println(n.getPath());
 
         PropertyIterator pit = n.getProperties();
         while (pit.hasNext()) {
             try {
                 Property p = pit.nextProperty();
                 out.print(p.getPath() + "=");
                 if (p.getDefinition().isMultiple()) {
                     Value[] values = p.getValues();
                     for (int i = 0; i < values.length; i++) {
                         if (i > 0) {
                             out.println(",");
                         }
                         out.println(values[i].getString());
                     }
                 } else if (p.getType() == PropertyType.BINARY) {
                     out.print("binary");
                 } else {
                     out.print(p.getString());
                 }
             } catch (InvalidItemStateException e) {
                 // somebody might have removed the item concurrently
                 log.debug(e.getMessage(), e);
             }
             out.println();
         }
 
         level--;
 
         NodeIterator nit = n.getNodes();
         while (nit.hasNext()) {
             Node cn = nit.nextNode();
             if (level > 0) {
                 dump(cn, level, out);
             }
             else {
                 out.println(cn.getPath() + "[" + cn.getPrimaryNodeType().getName() + "]");
             }
         }
     }
 
     /**
      * Dump only this JCR-Node to a writer.
      * 
      * @param n
      * @param out
      * @throws RepositoryException
      */
     public static void dump(Node n, PrintWriter out) throws RepositoryException {
         dump(n, 1, out);
     }
 
     public static void dumpChanges(HierarchyManager hm) {
         PrintWriter writer = new PrintWriter(System.out);
         try {
             dumpChanges(hm.getWorkspace().getSession(), writer);
         } catch (Exception e) {
             log.error("can't dump", e);
         }
         writer.flush();
     }
 
     public static void dumpChanges(Session session, PrintWriter out) throws RepositoryException {
         if (session.hasPendingChanges()) {
             dumpChanges(session.getRootNode(), out);
         }
     }
 
     private static void dumpChanges(Node node, PrintWriter out) throws RepositoryException {
         if (node.isModified()) {
             out.println(node.getPath() + " is modified");
         }
         else if (node.isNew()) {
             out.println(node.getPath() + " is new");
         }
         for (Iterator iter = node.getNodes(); iter.hasNext();) {
             Node child = (Node) iter.next();
             dumpChanges(child, out);
         }
     }
 
 }