/*
    * Copyright 2007 - 2007 JEuclid, http://jeuclid.sf.net
    * 
    * 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.
   */
  
  /* $Id: Parser.java,v 2bab6eb875e8 2010/08/11 16:45:50 max $ */
  
  package net.sourceforge.jeuclid.parser;
  
  import java.io.BufferedInputStream;
  import java.io.FilterInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.Reader;
  import java.lang.ref.Reference;
  import java.lang.ref.SoftReference;
  import java.util.Map;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.zip.ZipEntry;
  import java.util.zip.ZipInputStream;
  
  import javax.annotation.concurrent.ThreadSafe;
  import javax.xml.parsers.DocumentBuilder;
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.parsers.ParserConfigurationException;
  import javax.xml.transform.Source;
  import javax.xml.transform.Transformer;
  import javax.xml.transform.TransformerException;
  import javax.xml.transform.TransformerFactory;
  import javax.xml.transform.dom.DOMResult;
  import javax.xml.transform.dom.DOMSource;
  import javax.xml.transform.stream.StreamSource;
  
  import net.sourceforge.jeuclid.ResourceEntityResolver;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.xmlgraphics.image.loader.ImageSource;
  import org.w3c.dom.Document;
  import org.w3c.dom.Node;
  import org.xml.sax.ErrorHandler;
  import org.xml.sax.InputSource;
  import org.xml.sax.SAXException;
  import org.xml.sax.SAXParseException;
  
  /**
   * A JAXP compatible approach to MathML Parsing.
   * 
   * @version $Revision: 2bab6eb875e8 $
   */
  // CHECKSTYLE:OFF
  // This class is too complex.
  @ThreadSafe
  public final class Parser {
      // CHECKSTYLE:ON
  
      private static final class LoggerErrorHandler implements ErrorHandler {
          public LoggerErrorHandler() {
              // Empty on purpose
          }
  
          public void error(final SAXParseException exception)
                  throws SAXException {
              Parser.LOGGER.warn(exception);
          }
  
          public void fatalError(final SAXParseException exception)
                  throws SAXException {
              throw exception;
          }
  
          public void warning(final SAXParseException exception)
                  throws SAXException {
              Parser.LOGGER.debug(exception);
          }
      }
  
      private static final class UnclosableInputStream extends FilterInputStream {
          protected UnclosableInputStream(final InputStream in) {
              super(in);
          }
  
          @Override
          public void close() throws IOException {
              // Do Nothing.
          }
      }
  
     /**
      * Detection buffer size. Rationale: After the first 128 bytes a XML file
      * and a ZIP file should be distinguishable.
      */
     private static final int DETECTION_BUFFER_SIZE = 128;
 
     private static final String BAD_STREAM_SOURCE = "Bad StreamSource: ";
 
     private static final String CONTENT_XML = "content.xml";
 
     private static final String CANNOT_HANDLE_SOURCE = "Cannot handle Source: ";
 
     private static final class SingletonHolder {
         private static final Parser INSTANCE = new Parser();
 
         private SingletonHolder() {
         }
     }
 
     /**
      * Logger for this class.
      */
     private static final Log LOGGER = LogFactory.getLog(Parser.class);
 
     private final Map<Long, Reference<DocumentBuilder>> builders;
 
     /**
      * Default constructor.
      */
     protected Parser() {
         this.builders = new ConcurrentHashMap<Long, Reference<DocumentBuilder>>();
     }
 
     private DocumentBuilder createDocumentBuilder() {
         DocumentBuilder documentBuilder;
         try {
             try {
                 documentBuilder = this.tryCreateDocumentBuilder(true);
             } catch (final UnsupportedOperationException uoe) {
                 Parser.LOGGER.debug("Unsupported Operation: "
                         + uoe.getMessage());
                 documentBuilder = this.tryCreateDocumentBuilder(false);
             } catch (final ParserConfigurationException pce) {
                 Parser.LOGGER.debug("ParserConfigurationException: "
                         + pce.getMessage());
                 documentBuilder = this.tryCreateDocumentBuilder(false);
             }
             documentBuilder.setEntityResolver(new ResourceEntityResolver());
             documentBuilder.setErrorHandler(new LoggerErrorHandler());
         } catch (final ParserConfigurationException pce2) {
             Parser.LOGGER.warn("Could not create Parser: " + pce2.getMessage());
             assert false : "Could not create Parser";
             documentBuilder = null;
         }
         return documentBuilder;
     }
 
     private DocumentBuilder tryCreateDocumentBuilder(final boolean xinclude)
             throws ParserConfigurationException {
         final DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory
                 .newInstance();
         documentBuilderFactory.setNamespaceAware(true);
         if (xinclude) {
             documentBuilderFactory.setXIncludeAware(true);
         }
         final DocumentBuilder documentBuilder = documentBuilderFactory
                 .newDocumentBuilder();
         return documentBuilder;
     }
 
     /**
      * Retrieve the singleton Parser instance.
      * 
      * @return a Parser object.
      */
     public static Parser getInstance() {
         return Parser.SingletonHolder.INSTANCE;
     }
 
     /**
      * use {@link #getInstance()} instead.
      * 
      * @return see {@link #getInstance()}
      * @throws ParserConfigurationException
      *             see {@link #getInstance()}
      * @deprecated use {@link #getInstance()} instead.
      */
     @Deprecated
     public static Parser getParser() throws ParserConfigurationException {
         return Parser.getInstance();
     }
 
     /**
      * Parse a StreamSource and return its Document.
      * <p>
      * This method will auto-detect ODF or XML format and load an appropriate
      * parser.
      * 
      * @param streamSource
      *            A StreamSource.
      * @return A DOM Document representation for this source.
      * @throws SAXException
      *             if a parse error occurred.
      * @throws IOException
      *             if an I/O error occurred.
      */
     public Document parseStreamSource(final StreamSource streamSource)
             throws SAXException, IOException {
         Document retVal = null;
         InputStream inputStream = streamSource.getInputStream();
         if (inputStream != null) {
 
             // Alternative 1: Parse as XML, and fall back to ODF
             if (!inputStream.markSupported()) {
                 inputStream = new BufferedInputStream(inputStream);
             }
             final InputStream filterInput = new UnclosableInputStream(
                     inputStream);
             filterInput.mark(Parser.DETECTION_BUFFER_SIZE);
             try {
                 retVal = this.parseStreamSourceAsXml(new StreamSource(
                         filterInput));
                 inputStream.close();
             } catch (final SAXParseException se) {
                 filterInput.reset();
                 try {
                     retVal = this.parseStreamSourceAsOdf(new StreamSource(
                             filterInput));
                 } catch (final IOException io) {
                     throw se;
                 }
                 inputStream.close();
             }
 
             // Alternative 2: peek for ZIP magic and call matching parser.
 
             // final PushbackInputStream pi = new PushbackInputStream(
             // inputStream, 4);
             // final byte[] magic = new byte[4];
             // pi.read(magic);
             // pi.unread(magic);
             // if ((magic[0] == 'P') && (magic[1] == 'K') && (magic[2] == 3)
             // && (magic[3] == 4)) {
             // retVal = this.parseStreamSourceAsOdf(streamSource);
             // }
         }
         if (retVal == null) {
             retVal = this.parseStreamSourceAsXml(streamSource);
         }
         return retVal;
     }
 
     /**
      * Parse a given StreamSource which represents an ODF document.
      * 
      * @param streamSource
      *            StreamSource to parse.
      * @return the Document contained within.
      * @throws SAXException
      *             if a parse error occurred.
      * @throws IOException
      *             if an I/O error occurred.
      */
     public Document parseStreamSourceAsOdf(final StreamSource streamSource)
             throws IOException, SAXException {
         final InputStream is = streamSource.getInputStream();
         if (is == null) {
             throw new IllegalArgumentException(Parser.BAD_STREAM_SOURCE
                     + streamSource);
         }
         final ZipInputStream zipStream = new ZipInputStream(is);
         Document document = null;
         ZipEntry entry = zipStream.getNextEntry();
         while (entry != null) {
             if (Parser.CONTENT_XML.equals(entry.getName())) {
                 document = this.getDocumentBuilder().parse(zipStream);
                 entry = null;
             } else {
                 entry = zipStream.getNextEntry();
             }
         }
         return document;
     }
 
     /**
      * Parse a given StreamSource which represents an XML document.
      * 
      * @param streamSource
      *            StreamSource to parse.
      * @return the Document contained within.
      * @throws SAXException
      *             if a parse error occurred.
      * @throws IOException
      *             if an I/O error occurred.
      */
     public Document parseStreamSourceAsXml(final StreamSource streamSource)
             throws SAXException, IOException {
         InputSource inp = null;
         final String systemId = streamSource.getSystemId();
         if (systemId != null) {
             inp = new InputSource(systemId);
         }
         final InputStream is = streamSource.getInputStream();
         if ((inp == null) && (is != null)) {
             inp = new InputSource(is);
         }
         final Reader ir = streamSource.getReader();
         if ((inp == null) && (ir != null)) {
             inp = new InputSource(ir);
         }
 
         if (inp == null) {
             throw new IllegalArgumentException(Parser.BAD_STREAM_SOURCE
                     + streamSource);
         }
 
         return this.getDocumentBuilder().parse(inp);
     }
 
     /**
      * Retrieve a DocumentBuilder suitable for MathML parsing.
      * <p>
      * Please note:
      * <ul>
      * <li>There is one instance of the builder per thread.</li>
      * <li>The builder instance is not thread safe, so it may not be passed
      * among threads.</li>
      * <li>Multiple Threads may call getDocumentBuilder concurrently</li>
      * </ul>
      * 
      * @return a DocumentBuilder
      */
     public DocumentBuilder getDocumentBuilder() {
         // Note: No synchronization needed, as id will be different for every
         // thread!
         final long id = Thread.currentThread().getId();
         final Reference<DocumentBuilder> builderRef = this.builders.get(id);
         if (builderRef != null) {
             final DocumentBuilder builder = builderRef.get();
             if (builder != null) {
                 return builder;
             }
         }
         final DocumentBuilder builder = this.createDocumentBuilder();
         this.builders.put(id, new SoftReference<DocumentBuilder>(builder));
         return builder;
     }
 
     /**
      * Extract the top Node from a given Source.
      * 
      * @param source
      *            the Source to use. Currently supported are {@link DOMSource} ,
      *            {@link StreamSource}
      * @return the top NODE.
      * @throws SAXException
      *             if a parse error occurred.
      * @throws IOException
      *             if an I/O error occurred.
      */
     public Node parse(final Source source) throws SAXException, IOException {
         final Node retVal;
         if (source instanceof StreamSource) {
             final StreamSource streamSource = (StreamSource) source;
             retVal = this.parseStreamSource(streamSource);
         } else if (source instanceof ImageSource) {
             final ImageSource imageSource = (ImageSource) source;
             final StreamSource streamSource = new StreamSource(imageSource
                     .getInputStream());
             retVal = this.parseStreamSource(streamSource);
         } else if (source instanceof DOMSource) {
             final DOMSource domSource = (DOMSource) source;
             retVal = domSource.getNode();
         } else {
             try {
                 final Transformer t = TransformerFactory.newInstance()
                         .newTransformer();
                 final DOMResult r = new DOMResult();
                 t.transform(source, r);
                 retVal = r.getNode();
             } catch (final TransformerException e) {
                 Parser.LOGGER.warn(e.getMessage());
                 throw new IllegalArgumentException(Parser.CANNOT_HANDLE_SOURCE
                         + source, e);
             }
         }
         return retVal;
     }
 }