package org.codehaus.plexus.util.xml;
   
   /*
    * Copyright The Codehaus Foundation.
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  import java.io.PrintWriter;
  import java.io.Writer;
  import java.util.LinkedList;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import org.codehaus.plexus.util.StringUtils;
  
  /**
   * Implementation of XMLWriter which emits nicely formatted documents.
   *
   *
   */
  public class PrettyPrintXMLWriter
      implements XMLWriter
  {
      /** Line separator ("\n" on UNIX) */
      protected static final String LS = System.getProperty( "line.separator" );
  
      private PrintWriter writer;
  
      private LinkedList<String> elementStack = new LinkedList<String>();
  
      private boolean tagInProgress;
  
      private int depth;
  
      private String lineIndenter;
  
      private String lineSeparator;
  
      private String encoding;
  
      private String docType;
  
      private boolean readyForNewLine;
  
      private boolean tagIsEmpty;
  
      /**
       * @param writer not null
       * @param lineIndenter could be null, but the normal way is some spaces.
       */
      public PrettyPrintXMLWriter( PrintWriter writer, String lineIndenter )
      {
          this( writer, lineIndenter, null, null );
      }
  
      /**
       * @param writer not null
       * @param lineIndenter could be null, but the normal way is some spaces.
       */
      public PrettyPrintXMLWriter( Writer writer, String lineIndenter )
      {
          this( new PrintWriter( writer ), lineIndenter );
      }
  
      /**
       * @param writer not null
       */
      public PrettyPrintXMLWriter( PrintWriter writer )
      {
          this( writer, null, null );
      }
  
      /**
       * @param writer not null
       */
      public PrettyPrintXMLWriter( Writer writer )
      {
          this( new PrintWriter( writer ) );
      }
  
      /**
       * @param writer not null
       * @param lineIndenter could be null, but the normal way is some spaces.
       * @param encoding could be null or invalid.
       * @param doctype could be null.
       */
      public PrettyPrintXMLWriter( PrintWriter writer, String lineIndenter, String encoding, String doctype )
      {
         this( writer, lineIndenter, LS, encoding, doctype );
     }
 
     /**
      * @param writer not null
      * @param lineIndenter could be null, but the normal way is some spaces.
      * @param encoding could be null or invalid.
      * @param doctype could be null.
      */
     public PrettyPrintXMLWriter( Writer writer, String lineIndenter, String encoding, String doctype )
     {
         this( new PrintWriter( writer ), lineIndenter, encoding, doctype );
     }
 
     /**
      * @param writer not null
      * @param encoding could be null or invalid.
      * @param doctype could be null.
      */
     public PrettyPrintXMLWriter( PrintWriter writer, String encoding, String doctype )
     {
         this( writer, "  ", encoding, doctype );
     }
 
     /**
      * @param writer not null
      * @param encoding could be null or invalid.
      * @param doctype could be null.
      */
     public PrettyPrintXMLWriter( Writer writer, String encoding, String doctype )
     {
         this( new PrintWriter( writer ), encoding, doctype );
     }
 
     /**
      * @param writer not null
      * @param lineIndenter could be null, but the normal way is some spaces.
      * @param lineSeparator could be null, but the normal way is valid line separator ("\n" on UNIX).
      * @param encoding could be null or invalid.
      * @param doctype could be null.
      */
     public PrettyPrintXMLWriter( PrintWriter writer, String lineIndenter, String lineSeparator, String encoding,
                                  String doctype )
     {
         setWriter( writer );
 
         setLineIndenter( lineIndenter );
 
         setLineSeparator( lineSeparator );
 
         setEncoding( encoding );
 
         setDocType( doctype );
 
         if ( doctype != null || encoding != null )
         {
             writeDocumentHeaders();
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public void startElement( String name )
     {
         tagIsEmpty = false;
 
         finishTag();
 
         write( "<" );
 
         write( name );
 
         elementStack.addLast( name );
 
         tagInProgress = true;
 
         setDepth( getDepth() + 1 );
 
         readyForNewLine = true;
 
         tagIsEmpty = true;
     }
 
     /** {@inheritDoc} */
     @Override
     public void writeText( String text )
     {
         writeText( text, true );
     }
 
     /** {@inheritDoc} */
     @Override
     public void writeMarkup( String text )
     {
         writeText( text, false );
     }
 
     private void writeText( String text, boolean escapeXml )
     {
         readyForNewLine = false;
 
         tagIsEmpty = false;
 
         finishTag();
 
         if ( escapeXml )
         {
             text = escapeXml( text );
         }
 
         write( StringUtils.unifyLineSeparators( text, lineSeparator ) );
     }
 
     private static final Pattern amp = Pattern.compile( "&" );
 
     private static final Pattern lt = Pattern.compile( "<" );
 
     private static final Pattern gt = Pattern.compile( ">" );
 
     private static final Pattern dqoute = Pattern.compile( "\"" );
 
     private static final Pattern sqoute = Pattern.compile( "\'" );
 
     private static String escapeXml( String text )
     {
         if ( text.indexOf( '&' ) >= 0 )
         {
             text = amp.matcher( text ).replaceAll( "&amp;" );
         }
         if ( text.indexOf( '<' ) >= 0 )
         {
             text = lt.matcher( text ).replaceAll( "&lt;" );
         }
         if ( text.indexOf( '>' ) >= 0 )
         {
             text = gt.matcher( text ).replaceAll( "&gt;" );
         }
         if ( text.indexOf( '"' ) >= 0 )
         {
             text = dqoute.matcher( text ).replaceAll( "&quot;" );
         }
         if ( text.indexOf( '\'' ) >= 0 )
         {
             text = sqoute.matcher( text ).replaceAll( "&apos;" );
         }
 
         return text;
     }
 
     private static final String crlf_str = "\r\n";
 
     private static final Pattern crlf = Pattern.compile( crlf_str );
 
     private static final Pattern lowers = Pattern.compile( "([\000-\037])" );
 
     private static String escapeXmlAttribute( String text )
     {
         text = escapeXml( text );
 
         // Windows
         Matcher crlfmatcher = crlf.matcher( text );
         if ( text.contains( crlf_str ) )
         {
             text = crlfmatcher.replaceAll( "&#10;" );
         }
 
         Matcher m = lowers.matcher( text );
         StringBuffer b = new StringBuffer();
         while ( m.find() )
         {
             m = m.appendReplacement( b, "&#" + Integer.toString( m.group( 1 ).charAt( 0 ) ) + ";" );
         }
         m.appendTail( b );
 
         return b.toString();
     }
 
     /** {@inheritDoc} */
     @Override
     public void addAttribute( String key, String value )
     {
         write( " " );
 
         write( key );
 
         write( "=\"" );
 
         write( escapeXmlAttribute( value ) );
 
         write( "\"" );
     }
 
     /** {@inheritDoc} */
     @Override
     public void endElement()
     {
         setDepth( getDepth() - 1 );
 
         if ( tagIsEmpty )
         {
             write( "/" );
 
             readyForNewLine = false;
 
             finishTag();
 
             elementStack.removeLast();
         }
         else
         {
             finishTag();
 
             // see issue #51: https://github.com/codehaus-plexus/plexus-utils/issues/51
             // Rationale: replaced 1 write() with string concatenations with 3 write()
             // (this avoids the string concatenation optimization bug detected in Java 7)
             // TODO: change the below code to a more efficient expression when the library
             // be ready to target Java 8.
             write( "</" );
             write( elementStack.removeLast() );
             write( ">" );
         }
 
         readyForNewLine = true;
     }
 
     /**
      * Write a string to the underlying writer
      * 
      * @param str
      */
     private void write( String str )
     {
         getWriter().write( str );
     }
 
     private void finishTag()
     {
         if ( tagInProgress )
         {
             write( ">" );
         }
 
         tagInProgress = false;
 
         if ( readyForNewLine )
         {
             endOfLine();
         }
         readyForNewLine = false;
 
         tagIsEmpty = false;
     }
 
     /**
      * Get the string used as line indenter
      *
      * @return the line indenter
      */
     protected String getLineIndenter()
     {
         return lineIndenter;
     }
 
     /**
      * Set the string used as line indenter
      *
      * @param lineIndenter new line indenter, could be null, but the normal way is some spaces.
      */
     protected void setLineIndenter( String lineIndenter )
     {
         this.lineIndenter = lineIndenter;
     }
 
     /**
      * Get the string used as line separator or LS if not set.
      *
      * @return the line separator
      * @see #LS
      */
     protected String getLineSeparator()
     {
         return lineSeparator;
     }
 
     /**
      * Set the string used as line separator
      *
      * @param lineSeparator new line separator, could be null but the normal way is valid line separator ("\n" on UNIX).
      */
     protected void setLineSeparator( String lineSeparator )
     {
         this.lineSeparator = lineSeparator;
     }
 
     /**
      * Write the end of line character (using specified line separator) and start new line with indentation
      *
      * @see #getLineIndenter()
      * @see #getLineSeparator()
      */
     protected void endOfLine()
     {
         write( getLineSeparator() );
 
         for ( int i = 0; i < getDepth(); i++ )
         {
             write( getLineIndenter() );
         }
     }
 
     private void writeDocumentHeaders()
     {
         write( "<?xml version=\"1.0\"" );
 
         if ( getEncoding() != null )
         {
             write( " encoding=\"" + getEncoding() + "\"" );
         }
 
         write( "?>" );
 
         endOfLine();
 
         if ( getDocType() != null )
         {
             write( "<!DOCTYPE " );
 
             write( getDocType() );
 
             write( ">" );
 
             endOfLine();
         }
     }
 
     /**
      * Set the underlying writer
      *
      * @param writer not null writer
      */
     protected void setWriter( PrintWriter writer )
     {
         if ( writer == null )
         {
             throw new IllegalArgumentException( "writer could not be null" );
         }
 
         this.writer = writer;
     }
 
     /**
      * Get the underlying writer
      *
      * @return the underlying writer
      */
     protected PrintWriter getWriter()
     {
         return writer;
     }
 
     /**
      * Set the depth in the xml indentation
      *
      * @param depth new depth
      */
     protected void setDepth( int depth )
     {
         this.depth = depth;
     }
 
     /**
      * Get the current depth in the xml indentation
      *
      * @return the current depth
      */
     protected int getDepth()
     {
         return depth;
     }
 
     /**
      * Set the encoding in the xml
      *
      * @param encoding new encoding
      */
     protected void setEncoding( String encoding )
     {
         this.encoding = encoding;
     }
 
     /**
      * Get the current encoding in the xml
      *
      * @return the current encoding
      */
     protected String getEncoding()
     {
         return encoding;
     }
 
     /**
      * Set the docType in the xml
      *
      * @param docType new docType
      */
     protected void setDocType( String docType )
     {
         this.docType = docType;
     }
 
     /**
      * Get the docType in the xml
      *
      * @return the current docType
      */
     protected String getDocType()
     {
         return docType;
     }
 
     /**
      * @return the current elementStack;
      */
     protected LinkedList<String> getElementStack()
     {
         return elementStack;
     }
 }