/*
 * Copyright (c) 2001-2004 World Wide Web Consortium,
 * (Massachusetts Institute of Technology, Institut National de
 * Recherche en Informatique et en Automatique, Keio University). All
 * Rights Reserved. This program is distributed under the W3C's Software
 * Intellectual Property License. This program is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
 * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 * PURPOSE.
 * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
 */

package org.w3c.domts;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.w3c.dom.DOMImplementation;
import org.w3c.dom.Document;

/**
 *   This class implements the generic parser and configuation
 *   abstract class for the DOM implementation of Batik.
 *
 *   @author Curt Arnold
 */
public class BatikTestDocumentBuilderFactory
    extends DOMTestDocumentBuilderFactory {

  /**  dom factory.  */
  private Object domFactory;

  /**  xml reader.    */
  private org.xml.sax.XMLReader xmlReader;

  /**  reflective method to create document in Batik.   **/
  private Method createDocument;

  /**  dom implementation from Batik.   **/
  private DOMImplementation domImpl;

  /**
   * Creates a Batik implementation of DOMTestDocumentBuilderFactory.
   * @param settings array of settings, may be null.
   * @throws DOMTestIncompatibleException
   *     If implementation does not support the specified settings
   */
  public BatikTestDocumentBuilderFactory(
      DocumentBuilderSetting[] settings) throws DOMTestIncompatibleException {
    super(settings);
    domImpl = null;

    //
    //   get the JAXP specified SAX parser's class name
    //
    SAXParserFactory saxFactory = SAXParserFactory.newInstance();
    try {
      SAXParser saxParser = saxFactory.newSAXParser();
      xmlReader = saxParser.getXMLReader();
    } catch (Exception ex) {
      throw new DOMTestIncompatibleException(ex, null);
    }
    String xmlReaderClassName = xmlReader.getClass().getName();

    //
    //   can't change settings, so if not the same as
    //      the default SAX parser then throw an exception
    //
    //    for(int i = 0; i < settings.length; i++) {
    //      if(!settings[i].hasSetting(this)) {
    //        TODO
    //        throw new DOMTestIncompatibleException(null,settings[i]);
    //      }
    //    }
    //
    //   try loading Batik reflectively
    //
    try {
      ClassLoader classLoader = ClassLoader.getSystemClassLoader();
      Class domFactoryClass =
          classLoader.loadClass(
          "org.apache.batik.dom.svg.SAXSVGDocumentFactory");

      Constructor domFactoryConstructor =
          domFactoryClass.getConstructor(new Class[] {String.class});
      domFactory =
          domFactoryConstructor.newInstance(
          new Object[] {xmlReaderClassName});
      createDocument =
          domFactoryClass.getMethod(
          "createDocument",
          new Class[] {String.class, java.io.InputStream.class});
    } catch (InvocationTargetException ex) {
      throw new DOMTestIncompatibleException(
          ex.getTargetException(),
          null);
    } catch (Exception ex) {
      throw new DOMTestIncompatibleException(ex, null);
    }
  }

  /**
   *    Create new instance of document builder factory
   *    reflecting specified settings.
   *    @param newSettings new settings
   *    @return New instance
   *    @throws DOMTestIncompatibleException
   *         if settings are not supported by implementation
   */
  public DOMTestDocumentBuilderFactory newInstance(
      DocumentBuilderSetting[] newSettings)
        throws DOMTestIncompatibleException {
    if (newSettings == null) {
      return this;
    }
    DocumentBuilderSetting[] mergedSettings = mergeSettings(newSettings);
    return new BatikTestDocumentBuilderFactory(mergedSettings);
  }

  /**
   *    Loads specified URL.
   *    @param url url to load
   *    @return DOM document
   *    @throws DOMTestLoadException if unable to load document
   */
  public Document load(java.net.URL url) throws DOMTestLoadException {
    try {
      java.io.InputStream stream = url.openStream();
      return (org.w3c.dom.Document) createDocument.invoke(
          domFactory,
          new Object[] {url.toString(), stream});
    } catch (InvocationTargetException ex) {
      ex.printStackTrace();
      throw new DOMTestLoadException(ex.getTargetException());
    } catch (Exception ex) {
      ex.printStackTrace();
      throw new DOMTestLoadException(ex);
    }
  }

  /**
   *     Gets DOMImplementation.
   *     @return DOM implementation, may be null
   */
  public DOMImplementation getDOMImplementation() {
    //
    //   get DOM implementation
    //
    if (domImpl == null) {
      try {
        Class svgDomImplClass =
            ClassLoader.getSystemClassLoader().loadClass(
            "org.apache.batik.dom.svg.SVGDOMImplementation");
        Method getImpl =
            svgDomImplClass.getMethod(
            "getDOMImplementation",
            new Class[0]);
        domImpl =
            (DOMImplementation) getImpl.invoke(null, new Object[0]);
      } catch (Exception ex) {
        return null;
      }
    }
    return domImpl;
  }

  /**
   *   Determines if the implementation supports the specified feature.
   *   @param feature Feature
   *   @param version Version
   *   @return true if implementation supports the feature
   */
  public boolean hasFeature(String feature, String version) {
    return getDOMImplementation().hasFeature(feature, version);
  }

  /**
   *   Adds any specialized extension required by the implementation.
   *   @param testFileName file name from test
   *   @return possibly modified file name
   */
  public String addExtension(String testFileName) {
    return testFileName + ".svg";
  }

  /**
   *   Indicates whether the implementation combines text and cdata nodes.
   *   @return true if coalescing
   */
  public boolean isCoalescing() {
    return false;
  }

  /**
   *   Indicates whether the implementation expands entity references.
   *   @return true if expanding entity references
   */
  public boolean isExpandEntityReferences() {
    return false;
  }

  /**
   *   Indicates whether the implementation ignores
   *       element content whitespace.
   *   @return true if ignoring element content whitespace
   */
  public boolean isIgnoringElementContentWhitespace() {
    return false;
  }

  /**
   *   Indicates whether the implementation is namespace aware.
   *   @return true if namespace aware
   */
  public boolean isNamespaceAware() {
    return true;
  }

  /**
   *   Indicates whether the implementation is validating.
   *   @return true if validating
   */
  public boolean isValidating() {
    return false;
  }

  /**
   * Gets content type.
   * @return content type, "image/svg+xml"
   */
  public String getContentType() {
    return "image/svg+xml";
  }

}