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.File;
  import java.io.IOException;
  import java.io.OutputStream;
  import java.io.OutputStreamWriter;
  import java.io.StringWriter;
  import java.io.Writer;
  import java.nio.file.Files;
  import java.util.Locale;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  /**
   * Character stream that handles (or at least attempts to) all the necessary Voodo to figure out the charset encoding of
   * the XML document written to the stream.
   * 
   * @author <a href="mailto:hboutemy@codehaus.org">Herve Boutemy</a>
   *
   * @since 1.4.4
   */
  public class XmlStreamWriter
      extends Writer
  {
      private static final int BUFFER_SIZE = 4096;
  
      private StringWriter xmlPrologWriter = new StringWriter( BUFFER_SIZE );
  
      private OutputStream out;
  
      private Writer writer;
  
      private String encoding;
  
      public XmlStreamWriter( OutputStream out )
      {
          this.out = out;
      }
  
      public XmlStreamWriter( File file )
          throws IOException
      {
          this( Files.newOutputStream( file.toPath() ) );
      }
  
      public String getEncoding()
      {
          return encoding;
      }
  
      @Override
      public void close()
          throws IOException
      {
          if ( writer == null )
          {
              encoding = "UTF-8";
              writer = new OutputStreamWriter( out, encoding );
              writer.write( xmlPrologWriter.toString() );
          }
          writer.close();
      }
  
      @Override
      public void flush()
          throws IOException
      {
          if ( writer != null )
          {
              writer.flush();
          }
      }
  
      private void detectEncoding( char[] cbuf, int off, int len )
          throws IOException
      {
          int size = len;
          StringBuffer xmlProlog = xmlPrologWriter.getBuffer();
          if ( xmlProlog.length() + len > BUFFER_SIZE )
          {
              size = BUFFER_SIZE - xmlProlog.length();
          }
          xmlPrologWriter.write( cbuf, off, size );
 
         // try to determine encoding
         if ( xmlProlog.length() >= 5 )
         {
             if ( xmlProlog.substring( 0, 5 ).equals( "<?xml" ) )
             {
                 // try to extract encoding from XML prolog
                 int xmlPrologEnd = xmlProlog.indexOf( "?>" );
                 if ( xmlPrologEnd > 0 )
                 {
                     // ok, full XML prolog written: let's extract encoding
                     Matcher m = ENCODING_PATTERN.matcher( xmlProlog.substring( 0, xmlPrologEnd ) );
                     if ( m.find() )
                     {
                         encoding = m.group( 1 ).toUpperCase( Locale.ENGLISH );
                         encoding = encoding.substring( 1, encoding.length() - 1 );
                     }
                     else
                     {
                         // no encoding found in XML prolog: using default encoding
                         encoding = "UTF-8";
                     }
                 }
                 else
                 {
                     if ( xmlProlog.length() >= BUFFER_SIZE )
                     {
                         // no encoding found in first characters: using default encoding
                         encoding = "UTF-8";
                     }
                 }
             }
             else
             {
                 // no XML prolog: using default encoding
                 encoding = "UTF-8";
             }
             if ( encoding != null )
             {
                 // encoding has been chosen: let's do it
                 xmlPrologWriter = null;
                 writer = new OutputStreamWriter( out, encoding );
                 writer.write( xmlProlog.toString() );
                 if ( len > size )
                 {
                     writer.write( cbuf, off + size, len - size );
                 }
             }
         }
     }
 
     @Override
     public void write( char[] cbuf, int off, int len )
         throws IOException
     {
         if ( xmlPrologWriter != null )
         {
             detectEncoding( cbuf, off, len );
         }
         else
         {
             writer.write( cbuf, off, len );
         }
     }
 
     static final Pattern ENCODING_PATTERN = XmlReader.ENCODING_PATTERN;
 }