/*
    * Copyright 2002 - 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: DOMBuilder.java,v 2bab6eb875e8 2010/08/11 16:45:50 max $ */
  
  package net.sourceforge.jeuclid;
  
  import javax.annotation.concurrent.GuardedBy;
  import javax.annotation.concurrent.ThreadSafe;
  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.elements.generic.DocumentElement;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.w3c.dom.DOMException;
  import org.w3c.dom.Document;
  import org.w3c.dom.DocumentFragment;
  import org.w3c.dom.Element;
  import org.w3c.dom.Node;
  
  /**
   * Builds a MathML tree from a given DOM tree.
   * 
   * @version $Revision: 2bab6eb875e8 $
   */
  @ThreadSafe
  public final class DOMBuilder {
      /**
       * Logger for this class
       */
      private static final Log LOGGER = LogFactory.getLog(DOMBuilder.class);
  
      private static final class SingletonHolder {
          private static final DOMBuilder INSTANCE = new DOMBuilder();
  
          private SingletonHolder() {
          }
      }
  
      @GuardedBy("itself")
      private final Transformer contentTransformer;
  
      @GuardedBy("itself")
      private final Transformer identityTransformer;
  
      @GuardedBy("itself")
      private final Transformer namespaceTransformer;
  
      /**
       * Default constructor.
       */
      protected DOMBuilder() {
          this.identityTransformer = this.createIdentityTransformer();
          this.contentTransformer = this.createTransformer(
                  "/net/sourceforge/jeuclid/content/mathmlc2p.xsl",
                  this.identityTransformer);
          this.namespaceTransformer = this.createTransformer(
                  "/net/sourceforge/jeuclid/addMathMLNamespace.xsl",
                  this.identityTransformer);
      }
  
      private Transformer createIdentityTransformer() {
          Transformer t;
          try {
              t = TransformerFactory.newInstance().newTransformer();
          } catch (final TransformerException e) {
              DOMBuilder.LOGGER.warn(e.getMessage());
              t = null;
              assert false;
          }
          return t;
      }
  
      private Transformer createTransformer(final String sourceFile,
              final Transformer fallback) {
          Transformer t;
          try {
              t = TransformerFactory.newInstance().newTemplates(
                      new StreamSource(DOMBuilder.class
                              .getResourceAsStream(sourceFile))).newTransformer();
         } catch (final TransformerException e) {
             DOMBuilder.LOGGER.warn(e.getMessage());
             t = fallback;
         }
         return t;
     }
 
     /**
      * @return the singleton instance of the DOMBuilder
      */
     public static DOMBuilder getInstance() {
         return DOMBuilder.SingletonHolder.INSTANCE;
     }
 
     /**
      * use {@link #getInstance()} instead.
      * 
      * @return see {@link #getInstance()}
      * @deprecated use {@link #getInstance()} instead.
      */
     @Deprecated
     public static DOMBuilder getDOMBuilder() {
         return DOMBuilder.getInstance();
     }
 
     /**
      * Constructs a builder with content math support.
      * 
      * @param node
      *            The MathML document. Can be an instance of Document, Element
      *            or DocumentFragment with Element child
      * @return the parsed Document
      * @see #createJeuclidDom(Node, boolean)
      */
     public DocumentElement createJeuclidDom(final Node node) {
         return this.createJeuclidDom(node, true);
     }
 
     /**
      * Constructs a builder.
      * <p>
      * This constructor needs a valid DOM Tree. To obtain a DOM tree, you may
      * use {@link MathMLParserSupport}.
      * 
      * @param node
      *            The MathML document. Can be an instance of Document, Element
      *            or DocumentFragment with Element child
      * @param supportContent
      *            if set to true, content Math will be supported. This impacts
      *            performance.
      * @return the parsed Document
      * @see MathMLParserSupport
      */
     public DocumentElement createJeuclidDom(final Node node,
             final boolean supportContent) {
         return this.createJeuclidDom(node, supportContent, false);
     }
 
     /**
      * Constructs a builder.
      * <p>
      * This constructor needs a valid DOM Tree. To obtain a DOM tree, you may
      * use {@link MathMLParserSupport}.
      * 
      * @param node
      *            The MathML document. Can be an instance of Document, Element
      *            or DocumentFragment with Element child
      * @param supportContent
      *            if set to true, content Math will be supported. This impacts
      *            performance.
      * @param addNamespace
      *            if set to true, the MathML namespace will be added to all
      *            elements.
      * @return the parsed Document
      * @see MathMLParserSupport
      */
     public DocumentElement createJeuclidDom(final Node node,
             final boolean supportContent, final boolean addNamespace) {
         Node documentElement;
         if (node instanceof Document) {
             documentElement = ((Document) node).getDocumentElement();
         } else if (node instanceof Element) {
             documentElement = node;
         } else if (node instanceof DocumentFragment) {
             final Node child = node.getFirstChild();
             if (!(child instanceof Element)) {
                 throw new IllegalArgumentException(
                         "Expected DocumentFragment with Element child");
             }
             documentElement = child;
         } else {
             throw new IllegalArgumentException("Unsupported node: " + node
                     + ". Expected either Document, Element or DocumentFragment");
         }
 
         if (addNamespace) {
             documentElement = this.applyTransform(documentElement,
                     this.namespaceTransformer);
         }
 
         final DocumentElement d;
         if (supportContent) {
             d = this.applyTransform(documentElement, this.contentTransformer);
         } else {
             d = this.applyTransform(documentElement, this.identityTransformer);
         }
         return d;
     }
 
     private DocumentElement applyTransform(final Node src,
             final Transformer transformer) {
         DocumentElement d;
         try {
             final DOMSource source = new DOMSource(src);
             d = new DocumentElement();
             final DOMResult result = new DOMResult(d);
             synchronized (transformer) {
                 transformer.transform(source, result);
             }
         } catch (final TransformerException e) {
             d = null;
             DOMBuilder.LOGGER.warn(e.getMessage());
         } catch (final NullPointerException e) {
             d = null;
             // Happens if the stylesheet was not loaded correctly
             DOMBuilder.LOGGER.warn(e.getMessage());
         } catch (final DOMException e) {
             d = null;
             DOMBuilder.LOGGER.warn(e.getMessage());
         }
         return d;
     }
 
 }