package org.exolab.castor.xml.util;
   
   import java.util.StringTokenizer;
   
   import javax.xml.parsers.ParserConfigurationException;
   import javax.xml.parsers.SAXParser;
   import javax.xml.parsers.SAXParserFactory;
   
   import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.castor.core.util.AbstractProperties;
  import org.castor.core.util.Messages;
  import org.castor.xml.XMLProperties;
  import org.exolab.castor.xml.OutputFormat;
  import org.exolab.castor.xml.Serializer;
  import org.exolab.castor.xml.XMLSerializerFactory;
  import org.xml.sax.Parser;
  import org.xml.sax.SAXException;
  import org.xml.sax.SAXNotRecognizedException;
  import org.xml.sax.SAXNotSupportedException;
  import org.xml.sax.XMLReader;
  
  /**
   * A couple of routines to manipulate XMLParser instances. Mostly extracted
   * from 'old' LocalConfiguration class.
   * 
   * @author Joachim Grueneis, jgrueneis_at_gmail_dot_com
   * @version $Id$
   * @since 1.1.3
   */
  public class XMLParserUtils {
  
      /**
       * Logger to be used.
       */
      static final Log LOG = LogFactory.getFactory().getInstance(XMLParserUtils.class);
      
      /** 
       * To set validation feature of XMLReader.
       */
      private static final String VALIDATION = "http://xml.org/sax/features/validation";
      
      /** 
       * To set namespaces feature of XMLReader. 
       */
      private static final String NAMESPACES = "http://xml.org/sax/features/namespaces";
  
      /**
       * Sets features on XML reader instance.
       * @param properties the Properties to read parser features from
       * @param defaultFeatures any default features to use
       * @param validation Whether to enable validation or not.
       * @param namespaces Whether to enable namespace support for not.
       * @param xmlReader The XMLReader instance to configure.
       */
      public static void setFeaturesOnXmlReader(
              final String parserFeatures,
              final String parserFeaturesToDisable,
              final boolean validation, 
              final boolean namespaces, 
              final XMLReader xmlReader) {
          try {
              xmlReader.setFeature(VALIDATION, validation);
              xmlReader.setFeature(NAMESPACES, namespaces);
              enableFeatures(parserFeatures, xmlReader);
              disableFeatures(parserFeaturesToDisable, xmlReader);
          } catch (SAXException except) {
              LOG.error(Messages.format("conf.configurationError", except));
          }
      }
  
      /**
       * Enables selected features on the XMLReader instance.
       * @param features Features to enable
       * @param xmlReader XMLReader instance to be configured.
       * @throws SAXNotRecognizedException If the feature is not recognized by the XMLReader.
       * @throws SAXNotSupportedException If the feature is not supported by the XMLReader.
       */
      private static void enableFeatures(final String features, final XMLReader xmlReader) 
          throws SAXNotRecognizedException, SAXNotSupportedException {
          StringTokenizer token;
          if (features != null) {
              token = new StringTokenizer(features, ", ");
              while (token.hasMoreTokens()) {
                  xmlReader.setFeature(token.nextToken(), true);
              }
          }
      }
  
      /**
       * Disables selected features on the XMLReader instance.
       * @param features Features to disable
       * @param xmlReader XMLReader instance to be configured.
       * @throws SAXNotRecognizedException If the feature is not recognized by the XMLReader.
       * @throws SAXNotSupportedException If the feature is not supported by the XMLReader.
       */
      private static void disableFeatures(final String features, final XMLReader xmlReader) 
          throws SAXNotRecognizedException, SAXNotSupportedException {
          StringTokenizer token;
         if (features != null) {
             token = new StringTokenizer(features, ", ");
             while (token.hasMoreTokens()) {
                 xmlReader.setFeature(token.nextToken(), false);
             }
         }
     }
     
     /**
      * To get a SAXParser instance which is then used to get either
      * parser or XMLReader.
      * @param validation validation flag to set into parser factory
      * @param namespaces namespace flag to set into parser factory
      * @return the SAXParser for further use
      */
     public static SAXParser getSAXParser(final boolean validation, final boolean namespaces) {
         SAXParser saxParser = null;
 
         SAXParserFactory factory = SAXParserFactory.newInstance();
         factory.setNamespaceAware(namespaces);
         factory.setValidating(validation);
         try {
             saxParser = factory.newSAXParser();
             if (LOG.isDebugEnabled()) {
                 LOG.debug("Successfully instantiated a JAXP SAXParser instance.");
             }
         } catch (ParserConfigurationException pcx) {
             LOG.error(Messages.format("conf.configurationError", pcx));
         } catch (org.xml.sax.SAXException sx) {
             LOG.error(Messages.format("conf.configurationError", sx));
         }
         return saxParser;
     }
 
     /**
      * To get a SAXParser instance from a given {@link SAXParserFactory}, which is then used to obtain either
      * {@link Parser} or {@link XMLReader}.
      * @return the {@link SAXParser} for further use
      */
     public static SAXParser getSAXParser(SAXParserFactory saxParserFactory) {
         SAXParser saxParser = null;
 
         try {
             saxParser = saxParserFactory.newSAXParser();
             if (LOG.isDebugEnabled()) {
                 LOG.debug("Successfully instantiated a JAXP SAXParser instance.");
             }
         } catch (ParserConfigurationException pcx) {
             LOG.error(Messages.format("conf.configurationError", pcx));
         } catch (org.xml.sax.SAXException sx) {
             LOG.error(Messages.format("conf.configurationError", sx));
         }
         return saxParser;
     }
 
     /**
      * To get a SAXParserFactory instance which is then used to obtain an
      * {@link SAXParser} instance.
      * @param namespaces Whether to provide namespace support.
      * @param validation Whether to produce a validating SAX parser.
      * @return the SAXParserFactory for further use
      */
     public static SAXParserFactory getSAXParserFactory(final boolean validation, final boolean namespaces) {
         SAXParserFactory factory = SAXParserFactory.newInstance();
         factory.setNamespaceAware(namespaces);
         factory.setValidating(validation);
         return factory;
     }
 
     /**
      * Instantiates an {@link XMLReader} instance directly, using {@link Class#forName(String)}
      * to obtain the {@link Class} instance, and uses {@link Class#newInstance()}
      * to create the actual instance.
      * @param className The class name of the {@link XMLReader} instance to be instantiated.
      * @return An {@link XMLReader} instance.
      */
     public static XMLReader instantiateXMLReader(final String className) {
         XMLReader xmlReader;
         try {
             Class cls;
             cls = Class.forName(className);
             xmlReader = (XMLReader) cls.newInstance();
             if (LOG.isDebugEnabled()) {
                 LOG.debug("Successfully instantiated " + className);
             }
         } catch (Exception except) {
             throw new RuntimeException(Messages.format(
                     "conf.failedInstantiateParser", className, except));
         }
         return xmlReader;
     }
 
     /**
      * Instantiates an {@link Parser} instance directly, using {@link Class#forName(String)}
      * to obtain the {@link Class} instance, and uses {@link Class#newInstance()}
      * to create the actual instance.
      * @param className The class name of the {@link Parser} instance to be instantiated.
      * @return An {@link Parser} instance.
      */
     public static Parser instantiateParser (final String className) {
         Parser parser;
         try {
             Class cls;
             cls = Class.forName(className);
             parser = (Parser) cls.newInstance();
             if (LOG.isDebugEnabled()) {
                 LOG.debug("Successfully instantiated " + className);
             }
         } catch (Exception except) {
             throw new RuntimeException(Messages.format(
                     "conf.failedInstantiateParser", className, except));
         }
         return parser;
     }
     
     public static Parser getParser(final AbstractProperties properties, final String features) {
         Parser parser = null;
         Boolean validation = properties.getBoolean(XMLProperties.PARSER_VALIDATION);
         Boolean namespaces = properties.getBoolean(XMLProperties.NAMESPACES);
         String parserClassName = properties.getString(XMLProperties.PARSER);
         if ((parserClassName == null) || (parserClassName.length() == 0)) {
             SAXParser saxParser = XMLParserUtils.getSAXParser(
                     validation.booleanValue(), namespaces.booleanValue());
             if (saxParser != null) {
                 try {
                     parser = saxParser.getParser();
                 } catch (SAXException e) {
                     LOG.error(Messages.format("conf.configurationError", e));
                 }
             }
         }
         
         if (parser == null) {
             if ((parserClassName == null) 
                     || (parserClassName.length() == 0) 
                     || (parserClassName.equalsIgnoreCase("xerces"))) {
                 parserClassName = "org.apache.xerces.parsers.SAXParser";
             }
             
             // if a parser class was specified, we try to create it
             parser = XMLParserUtils.instantiateParser(parserClassName);
 
             if (parser instanceof XMLReader) {
                 XMLReader xmlReader = (XMLReader) parser;
                 XMLParserUtils.setFeaturesOnXmlReader(
                         properties.getString(XMLProperties.PARSER_FEATURES, features),
                         properties.getString(XMLProperties.PARSER_FEATURES_DISABLED, ""),
                         validation.booleanValue(),
                         namespaces.booleanValue(),
                         xmlReader);
             }
         }
         return parser;
     }
     
     /**
      * @see org.castor.xml.InternalContext#getSerializer()
      */
     public static Serializer getSerializer(final AbstractProperties properties) {
         Serializer serializer = getSerializerFactory(
                 properties.getString(XMLProperties.SERIALIZER_FACTORY)).getSerializer();
         serializer.setOutputFormat(getOutputFormat(properties));
         return serializer;
     }
     
     /**
      * @see org.castor.xml.InternalContext#getOutputFormat()
      */
     public static OutputFormat getOutputFormat(final AbstractProperties properties) {
 
         boolean indent = properties.getBoolean(XMLProperties.USE_INDENTATION, false);
         
         String version = properties.getString(XMLProperties.XML_VERSION, "1.0");
 
         OutputFormat format = getSerializerFactory(
                 properties.getString(XMLProperties.SERIALIZER_FACTORY)).getOutputFormat();
         format.setMethod(OutputFormat.XML);
         format.setVersion(version);
         format.setIndenting(indent);
         
         // There is a bad interaction between the indentation and the
         // setPreserveSpace option. The indentated output is strangely indented.
         if (!indent) {
             format.setPreserveSpace(true);
         } 
 
         return format;
     } //-- getOutputFormat
     
     /**
      * Returns the currently configured XMLSerializerFactory instance.
      * @param serializerFactoryName the class name of the serializer factory
      * @return XMLSerializerFactory to use by Castor
      */
     public static XMLSerializerFactory getSerializerFactory(final String serializerFactoryName) {
         XMLSerializerFactory serializerFactory;
         
         try {
             serializerFactory = (XMLSerializerFactory) 
             Class.forName(serializerFactoryName).newInstance();
         } catch (Exception except) {
             throw new RuntimeException(
                     Messages.format("conf.failedInstantiateSerializerFactory", 
                             serializerFactoryName, except));
         }
         return serializerFactory;
     }
     
     
 }