package org.exolab.castor.xml;
   
   import java.util.List;
   import java.util.Stack;
   
   import javax.xml.namespace.QName;
   import javax.xml.stream.Location;
   import javax.xml.stream.XMLEventReader;
   import javax.xml.stream.XMLStreamConstants;
  import javax.xml.stream.XMLStreamReader;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.xml.sax.Attributes;
  import org.xml.sax.ContentHandler;
  import org.xml.sax.ErrorHandler;
  import org.xml.sax.Locator;
  import org.xml.sax.SAXException;
  
  /**
   * This provides shared code for {@link Sax2EventFromStaxEventProducer} and
   * {@link Sax2EventFromStaxStreamProducer}. It consumes StAX events and 
   * produces SAX2 events.
   * 
   * @author <a href="mailto:philipp DOT erlacher AT gmail DOT com">Philipp
   *         Erlacher</a>
   * 
   */
  public abstract class BaseSax2EventFromStaxProducer implements
          SAX2EventAndErrorProducer {
  
      /**
       * Logger from commons-logging.
       */
      private static final Log LOG = LogFactory
              .getLog(BaseSax2EventFromStaxProducer.class);
  
      /**
       * A stack to keep track when it's time to invoke endPrefixMapping
       */
      private Stack<List<String>> prefixes = new Stack<List<String>>();
  
  
      /**
       * On this interface the SAX methods get invoked
       */
      private ContentHandler contentHandler;
  
      /**
       * Callback Interface to handle errors
       */
      private ErrorHandler errorHandler;
  
      public static SAX2EventAndErrorProducer createSax2EventFromStax(
              XMLStreamReader streamReader) {
          return new Sax2EventFromStaxStreamProducer(streamReader);
      }
  
      public static SAX2EventAndErrorProducer createSax2EventFromStax(
              XMLEventReader eventReader) {
          return new Sax2EventFromStaxEventProducer(eventReader);
      }
  
      public void setContentHandler(ContentHandler contentHandler) {
          this.contentHandler = contentHandler;
      }
  
      public void setErrorHandler(ErrorHandler errorHandler) {
          this.errorHandler = errorHandler;
      }
  
      public Stack<List<String>> getPrefixes() {
          return prefixes;
      }
  
      public ContentHandler getContentHandler() {
          return contentHandler;
      }
  
      public ErrorHandler getErrorHandler() {
          return errorHandler;
      }
  
      /**
       * This method takes an eventType and invokes a method to handle that event.
       * 
       * <p>
       * It also takes information about the depth of the read element. Maybe
       * depth changes due to handling that event.
       * </p>
       * 
       * @param eventType
       *            The event type
       * @param depth
       *            The current depth of the element
       * @return depth The updated depth
       * @throws SAXException
       */
      int handleEventType(int eventType, int depth) throws SAXException {
         switch (eventType) {
         case XMLStreamConstants.START_ELEMENT:
             handleStartElement();
             return ++depth;
         case XMLStreamConstants.END_ELEMENT:
             handleEndElement();
             return --depth;
         case XMLStreamConstants.START_DOCUMENT:
             handleStartDocument();
             return ++depth;
         case XMLStreamConstants.END_DOCUMENT:
             handleEndDocument();
             return --depth;
         case XMLStreamConstants.CHARACTERS:
             handleCharacters();
             return depth;
         case XMLStreamConstants.SPACE:
             handleSpace();
             return depth;
         default:
             return depth;
         }
     }
 
    /**
      * Invoke {@link #handleDocumentLocator()} and {@link
      * getContentHandler().startDocument()};
      * 
      * @throws SAXException
      */
     void handleStartDocument() throws SAXException {
         LOG.info("< handleStartDocument >");
 
         handleDocumentLocator();
 
         contentHandler.startDocument();
     }
 
     /**
      * Handles a end document event.
      * <p>
      * Invoke {@link getContentHandler().endDocument()};
      * </p>
      * 
      * @throws SAXException
      */
     void handleEndDocument() throws SAXException {
         LOG.info("< handleEndDocument >");
         contentHandler.endDocument();
 
     }
 
     /**
      * Handles a start element event.
      * <p>
      * Invoke {@link #doStartPrefixMapping()} and {@link
      * getContentHandler().startElement()};
      * </p>
      * 
      * @throws SAXException
      */
     void handleStartElement() throws SAXException {
         LOG.info("< handleStartElement >");
 
         QName qName = getQName();
         String localName = qName.getLocalPart();
         String uri = qName.getNamespaceURI();
         String prefix = qName.getPrefix();
         String qNameString = getQName(prefix, localName);
 
         Attributes atts = getAttributes();
 
         doStartPrefixMapping();
 
         contentHandler.startElement(uri, localName, qNameString, atts);
 
     }
 
     /**
      * Handles an end element event.
      * <p>
      * Invoke {@link getContentHandler().endElement()} and
      * {@link #doEndPrefixMapping()};
      * </p>
      * 
      * @throws SAXException
      */
     void handleEndElement() throws SAXException {
         LOG.info("< handleEndElement >");
 
         QName qName = getQName();
         String localName = qName.getLocalPart();
         String uri = qName.getNamespaceURI();
         String prefix = qName.getPrefix();
         String qNameString = getQName(prefix, localName);
 
         contentHandler.endElement(uri, localName, qNameString);
 
         doEndPrefixMapping();
     }
 
     /**
      * Handles a space event.
      * 
      * @throws SAXException
      */
     void handleSpace() throws SAXException {
 
     }
 
     /**
      * Handles a character event.
      * <p>
      * If chars is ignorable whitespace {@link
      * getContentHandler().ignorableWhitespace will be called. Otherwise {@link
      * getContentHandler().characters()} will be called with characters(char[],
      * 0, length)
      * 
      * </p>
      * 
      * @throws SAXException
      */
     void handleCharacters() throws SAXException {
         LOG.info("< handleCharacters >");
         char[] chars;
         chars = getCharacters();
 
         if (isIgnorableWhitespace(chars, 0, chars.length))
             contentHandler.ignorableWhitespace(chars, 0, chars.length);
         else
             contentHandler.characters(chars, 0, chars.length);
 
     }
 
     /**
      * @param prefix
      * @param localPart
      * @return qName. If prefix length >=1 then it's like prefix:localPart,
      *         otherwise it's just the localPart
      */
     String getQName(String prefix, String localPart) {
         return getNonEmpty(prefix).length() >= 1 ? prefix + ":" + localPart
                 : localPart;
     }
 
     /**
      * If a chars without leading and trailing whitespaces would be empty, this
      * method returns true, otherwise false,
      * 
      * @param chars
      * @param start
      *            the offset
      * @param length
      * @return
      */
     boolean isIgnorableWhitespace(char[] chars, int start, int length) {
         StringBuffer buffer = new StringBuffer();
         buffer.append(chars, start, length);
         String string = buffer.toString();
         if (string.trim().length() == 0)
             return true;
         return false;
     }
 
     /**
      * If string equals null this returns an empty string, otherwise it returns
      * the string
      * 
      * @param string
      *            the string to check
      * @return a string. If string equals null this returns an empty string,
      *         otherwise it returns the string
      */
     String getNonEmpty(String string) {
         return string == null ? "" : string;
     }
 
     /**
      * @return a Location
      */
     abstract Location getLocation();
 
     /**
      * @return characters of the current event.
      */
     abstract char[] getCharacters();
 
     /**
      * For every declared namespace in the current event {@link
      * getContentHandler().startPrefixMapping()} gets invoked.
      * 
      * @throws SAXException
      */
     abstract void doStartPrefixMapping() throws SAXException;
 
     /**
      * 
      * @throws SAXException
      */
     abstract void doEndPrefixMapping() throws SAXException;
 
     /**
      * @return attributes of the current event
      */
     abstract Attributes getAttributes();
 
     /**
      * @return QName of the current event
      */
     abstract QName getQName();
 
     /**
      * If {@link #getLocation()} gets a location {@link
      * getContentHandler().setDocumentLocator()} will be called, otherwise not.
      */
     private void handleDocumentLocator() {
         Locator locator = getSAXLocator(getLocation());
         contentHandler.setDocumentLocator(locator);
     }
 
     /**
      * Gets a {@link org.xml.sax.Locator} to a given {@link Location}.
      * 
      * @param location
      *            A {@link Location}
      * @return A {@link Locator}
      */
     protected Locator getSAXLocator(Location location) {
         return new Locator() {
             public String getSystemId() {
                 return getLocation().getSystemId();
             }
 
             public String getPublicId() {
                 return getLocation().getPublicId();
             }
 
             public int getLineNumber() {
                 return getLocation().getLineNumber();
             }
 
             public int getColumnNumber() {
                 return getLocation().getColumnNumber();
             }
         };
     }
 }