package org.jdom.input;

import java.io.*;
import java.lang.reflect.*;
import java.net.*;
import java.util.*;

import org.jdom.*;

import org.xml.sax.*;
import org.xml.sax.ext.LexicalHandler;
import org.xml.sax.ext.DeclHandler;
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.helpers.XMLReaderFactory;

/**
 * <p><code>SAXHandler</code> supports SAXBuilder</p>
 *
 * @author Brett McLaughlin
 * @author Jason Hunter
 * @author Philip Nelson
 */
public class SAXHandler extends DefaultHandler implements LexicalHandler,
DeclHandler,
DTDHandler {

	private static final String CVS_ID = 
		"@(#) $RCSfile: SAXHandler.java,v $ $Revision: 1.21 $ $Date: 2001/08/17 18:37:06 $ $Name:  $";

	/** <code>Document</code> object being built */
	private Document document;

	// Note: keeping a "current element" variable to avoid the constant
	// peek() calls to the top of the stack has shown to cause no noticeable 
	// performance improvement.

	/** Element stack */
	protected Stack stack;

	/** Indicator of where in the document we are */
	protected boolean atRoot;

	/** Indicator of whether we are in a DTD */
	protected boolean inDTD = false;

	/** Indicator of whether we are in a CDATA */
	protected boolean inCDATA = false;

	/** Indicator of whether we should expand entities */
	private boolean expand = true;

	/** Indicator of whether we are actively suppressing (non-expanding) a 
	  current entity */
	protected boolean suppress = false;

	/** How many nested entities we're currently within */
	private int entityDepth = 0;

	/** Temporary holder for namespaces that have been declared with
	 * startPrefixMapping, but are not yet available on the element */
	protected LinkedList declaredNamespaces;

	/** The namespaces in scope and actually attached to an element */
	protected LinkedList availableNamespaces;

	private Map externalEntities;

	/** The JDOMFactory used for JDOM object creation */
	private JDOMFactory factory;

	/** Whether to ignore ignorable whitespace */
	private boolean ignoringWhite = false;

	/** Temporary holder for the internal subset */
	private StringBuffer buffer = new StringBuffer();


	/**
	 * <p>
	 * This will create a new <code>SAXHandler</code> that listens to SAX
	 * events and creates a JDOM Document.  The objects will be constructed
	 * using the default factory.
	 * </p>
	 *
	 * @throws IOException when errors occur.
	 */
	public SAXHandler() throws IOException {
		this((JDOMFactory)null);
	}
	/**
	 * <p>
	 * This will set the <code>Document</code> to use.
	 * </p>
	 *
	 * @param document <code>Document</code> being parsed.
	 * @throws IOException when errors occur.
	 *
	 * @deprecated Deprecated in beta7, use SAXHandler() instead and let
	 * SAXHandler create the Document, then retrieve it with getDocument()
	 */
	public SAXHandler(Document document) throws IOException {
		this(new DefaultJDOMFactory());
		this.document = document;
	}
	/**
	 * <p>
	 * This will create a new <code>SAXHandler</code> that listens to SAX
	 * events and creates a JDOM Document.  The objects will be constructed
	 * using the provided factory.
	 * </p>
	 *
	 * @param factory <code>JDOMFactory</code> to be used for constructing
	 * objects
	 * @throws IOException when errors occur.
	 */
	public SAXHandler(JDOMFactory factory) throws IOException {
		if (factory != null) {
			this.factory = factory;
		} else {
			this.factory = new DefaultJDOMFactory();
		}

		atRoot = true;
		stack = new Stack();
		declaredNamespaces = new LinkedList();
		availableNamespaces = new LinkedList();
		availableNamespaces.add(Namespace.XML_NAMESPACE);
		externalEntities = new HashMap();

		document = this.factory.document((Element)null);
	}
	
	/**
	 * <P>
	 * handle an attribute declaration in a DTD
	 * </P>
	 *
	 * @param eName <code>String</code> element name of attribute
	 * @param aName <code>String</code> attribute name
	 * @param type <code>String</code> attribute type
	 * @param valueDefault <code>String</code> default value of attribute
	 * @param value <code>String</code> value of attribute
	 */
	public void attributeDecl(String eName, String aName, String type,
			String valueDefault, String value) {
		buffer.append("  <!ATTLIST ")
			.append(eName)
			.append(" ")
			.append(aName)
			.append(" ")
			.append(type)
			.append(" ");
		if (valueDefault != null) {
			buffer.append(valueDefault);
		} else {
			buffer.append("\"")
				.append(value)
				.append("\"");
		}
		if (valueDefault != null && valueDefault.equals("#FIXED")) {
			buffer.append(" \"")
				.append(value)
				.append("\"");
		}
		buffer.append(">\n");                        

	}
	/**
	 * <p>
	 * This will report character data (within an element).
	 * </p>
	 *
	 * @param ch <code>char[]</code> character array with character data
	 * @param start <code>int</code> index in array where data starts.
	 * @param length <code>int</code> length of data.
	 * @throws SAXException when things go wrong
	 */
	public void characters(char[] ch, int start, int length)
		throws SAXException {

			if (suppress) return;
			if (length == 0) return;

			String data = new String(ch, start, length);

			if (inCDATA) {
				getCurrentElement().addContent(factory.cdata(data));
			}
			else {
				getCurrentElement().addContent(data);
			}
		}
	/**
	 * <p>
	 * This reports that a comments is parsed.  If not in the
	 *   DTD, this comment is added to the current JDOM
	 *   <code>Element</code>, or the <code>Document</code> itself
	 *   if at that level.
	 * </p>
	 *
	 * @param ch <code>ch[]</code> array of comment characters.
	 * @param start <code>int</code> index to start reading from.
	 * @param length <code>int</code> length of data.
	 */
	public void comment(char[] ch, int start, int length)
		throws SAXException {

			if (suppress) return;

			if (inDTD) {
				String comment = new String(ch, start, length);
				buffer.append("  <!--")
					.append(comment)
					.append("-->\n");
				return;
			}

			String commentText = new String(ch, start, length);
			if ((!inDTD) && (!commentText.equals(""))) {
				if (stack.empty()) {
					document.addContent(
							factory.comment(commentText));
				} else {
					getCurrentElement().addContent(
							factory.comment(commentText));
				}
			}
		}

	/**
	 * <P>
	 * handle an element declaration in a DTD
	 * </P>
	 *
	 * @param name <code>String</code> name of element
	 * @param model <code>String</code> model of the element in DTD syntax
	 */
	
	public void elementDecl(String name, String model) {
		buffer.append("  <!ELEMENT ")
			.append(name)
			.append(" ")
			.append(model)
			.append(">\n");
	}
	/**
	 * <p>
	 * Report a CDATA section - ignored in SAXBuilder.
	 * </p>
	 */
	public void endCDATA() throws SAXException {
		if (suppress) return;

		inCDATA = false;
	}
	/**
	 * <p>
	 * This signifies that the reading of the DTD is complete.
	 * </p>
	 */
	public void endDTD() throws SAXException {
		inDTD = false;
		document.getDocType().setInternalSubset(buffer.toString());
	}
	/**
	 * <p>
	 * Indicates the end of an element
	 *   (<code>&lt;/[element name]&gt;</code>) is reached.  Note that
	 *   the parser does not distinguish between empty
	 *   elements and non-empty elements, so this will occur uniformly.
	 * </p>
	 *
	 * @param namespaceURI <code>String</code> URI of namespace this
	 *                     element is associated with
	 * @param localName <code>String</code> name of element without prefix
	 * @param qName <code>String</code> name of element in XML 1.0 form
	 * @throws SAXException when things go wrong
	 */
	public void endElement(String namespaceURI, String localName,
			String qName) throws SAXException {

		if (suppress) return;

		try {
			Element element = (Element)stack.pop();

			// Remove the namespaces that this element makes available
			List addl = element.getAdditionalNamespaces();
			if (addl.size() > 0) {
				availableNamespaces.removeAll(addl);
			}
		}
		catch (EmptyStackException ex1) {
			throw new SAXException(
					"Ill-formed XML document (missing opening tag for " +
					localName + ")");
		}
		if (stack.empty()) {
			atRoot = true;
		}
	}
	public void endEntity(String name) throws SAXException {
		entityDepth--;
		if (entityDepth == 0) {
			// No way are we suppressing if not in an entity,
			// regardless of the "expand" value
			suppress = false;
		}
	}
	/**
	 * <p>
	 * This will add the prefix mapping to the JDOM
	 *   <code>Document</code> object.
	 * </p>
	 *
	 * @param prefix <code>String</code> namespace prefix.
	 * @param uri <code>String</code> namespace URI.
	 */
	public void endPrefixMapping(String prefix)
		throws SAXException {

			if (suppress) return;

			// Remove the namespace from the available list
			// (Should find the namespace fast because recent adds
			// are at the front of the list.  It may not be the head
			// tho because endPrefixMapping calls on the same element
			// can come in any order.)
			Iterator itr = availableNamespaces.iterator();
			while (itr.hasNext()) {
				Namespace ns = (Namespace) itr.next();
				if (prefix.equals(ns.getPrefix())) {
					itr.remove();
					return;
				}
			}
		}
	/**
	 * This is called when the parser encounters an external entity 
	 * declaration.
	 * </p>
	 *
	 * @param name entity name
	 * @param publicId public id
	 * @param systemId system id
	 * @throws SAXException when things go wrong
	 */
	public void externalEntityDecl(String name, 
			String publicId, String systemId)
		throws SAXException {
			// Store the public and system ids for the name
			externalEntities.put(name, new String[]{publicId, systemId});
			buffer.append("  <!ENTITY ")
				.append(name);
			if (publicId != null) {
				buffer.append(" PUBLIC \"")
					.append(publicId)
					.append("\" ");
			}
			if (systemId != null) {
				buffer.append(" SYSTEM \"")
					.append(systemId)
					.append("\" ");
			}
			buffer.append(">\n");
		}
	/**
	 * <p>
	 * Returns the being-parsed element.
	 * </p>
	 *
	 * @return <code>Element</code> - element at the top of the stack.
	 */
	protected Element getCurrentElement() throws SAXException {
		try {
			return (Element)(stack.peek());
		}
		catch (EmptyStackException ex1) {
			throw new SAXException(
					"Ill-formed XML document (multiple root elements detected)");
		}
	}
	/**
	 * <p>
	 * Returns the document.  Should be called after parsing is complete.
	 * </p>
	 *
	 * @return <code>Document</code> - Document that was built
	 */
	public Document getDocument() {
		return document;
	}
	/**
	 * <p>
	 * Returns whether or not entities will be expanded during the
	 * build.
	 * </p>
	 *
	 * @return <code>boolean</code> - whether entity expansion
	 * will occur during build.
	 *
	 * @see #setExpandEntities
	 */
	public boolean getExpandEntities() {
		return expand;
	}
	/**
	 * <p>
	 * Returns the factory used for constructing objects.
	 * </p>
	 *
	 * @return <code>JDOMFactory</code> - the factory used for
	 * constructing objects.
	 *
	 * @see #SAXHandler(org.jdom.input.JDOMFactory)
	 */
	public JDOMFactory getFactory() {
		return factory;
	}
	/**
	 * <p>
	 * Returns whether or not the parser will elminate whitespace in
	 * element content (sometimes known as "ignorable whitespace") when
	 * building the document.
	 * </p>
	 *
	 * @return <code>boolean</code> - whether ignorable whitespace will
	 * be ignored during build.
	 *
	 * @see #setIgnoringElementContentWhitespace
	 */
	public boolean getIgnoringElementContentWhitespace() {
		return ignoringWhite;
	}
	/**
	 * <p>
	 *  For a given namespace prefix, this will return the
	 *    <code>{@link Namespace}</code> object for that prefix,
	 *    within the current scope.
	 * </p>
	 *
	 * @param prefix namespace prefix.
	 * @return <code>Namespace</code> - namespace for supplied prefix.
	 */
	private Namespace getNamespace(String prefix) {
		Iterator i = availableNamespaces.iterator();
		while (i.hasNext()) {
			Namespace ns = (Namespace)i.next();
			if (prefix.equals(ns.getPrefix())) {
				return ns;
			}
		}
		return Namespace.NO_NAMESPACE;
	}
	/**
	 * <p>
	 * Capture ignorable whitespace as text.  If
	 * setIgnoringElementContentWhitespace(true) has been called then this
	 * method does nothing.
	 * </p>
	 *
	 * @param ch <code>[]</code> - char array of ignorable whitespace
	 * @param start <code>int</code> - starting position within array
	 * @param length <code>int</code> - length of whitespace after start
	 * @throws SAXException when things go wrong
	 */
	public void ignorableWhitespace(char[] ch, int start, int length) 
		throws SAXException {
			if (suppress) return;
			if (ignoringWhite) return;
			if (length == 0) return;

			getCurrentElement().addContent(new String(ch, start, length));

		}
	/**
	 * <p>
	 * Handle the declaration of an entity in the internal subset
	 * </p>
	 *
	 * @param name <code>String</code> name of entity listed in DTD
	 * @param value <code>String</code> value of the entity
	 */
	public void internalEntityDecl(String name, String value) {


		buffer.append("  <!ENTITY ")
			.append(name)
			.append(" \"")
			.append(value)
			.append("\">\n");

	}

	/**
	 * <p>
	 * Handle the declaration of a Notation in a DTD
	 * </P>
	 *
	 * @param name java.lang.String
	 * @param publicID java.lang.String
	 * @param systemID java.lang.String
	 */
	public void notationDecl(String name, String publicID, String systemID) {
		buffer.append("  <!NOTATION ")
			.append(name)
			.append(" \"")

			.append(systemID)
			.append("\">\n");	


	}
	/**
	 * <p>
	 * This will indicate that a processing instruction (other than
	 *   the XML declaration) has been encountered.
	 * </p>
	 *
	 * @param target <code>String</code> target of PI
	 * @param data <code>String</code containing all data sent to the PI.
	 *             This typically looks like one or more attribute value
	 *             pairs.
	 * @throws SAXException when things go wrong
	 */
	public void processingInstruction(String target, String data)
		throws SAXException {

			if (suppress) return;

			if (atRoot) {
				document.addContent(factory.processingInstruction(target, data));
			} else {
				getCurrentElement().addContent(
						factory.processingInstruction(target, data));
			}
		}
	/**
	 * <p>
	 * This sets whether or not to expand entities during the build.
	 * A true means to expand entities as normal content.  A false means to
	 * leave entities unexpanded as <code>EntityRef</code> objects.  The
	 * default is true.
	 * </p>
	 *
	 * @param expand <code>boolean</code> indicating whether entity expansion
	 * should occur.
	 */
	public void setExpandEntities(boolean expand) {
		this.expand = expand;
	}
	/**
	 * <p>
	 * Specifies whether or not the parser should elminate whitespace in
	 * element content (sometimes known as "ignorable whitespace") when
	 * building the document.  Only whitespace which is contained within
	 * element content that has an element only content model will be
	 * eliminated (see XML Rec 3.2.1).  For this setting to take effect
	 * requires that validation be turned on.  The default value of this
	 * setting is <code>false</code>.
	 * </p>
	 *
	 * @param ignoringWhite Whether to ignore ignorable whitespace
	 */
	public void setIgnoringElementContentWhitespace(boolean ignoringWhite) {
		this.ignoringWhite = ignoringWhite;
	}
	/**
	 * <p>
	 * Report a CDATA section - ignored in SAXBuilder.
	 * </p>
	 */
	public void startCDATA() throws SAXException {
		if (suppress) return;

		inCDATA = true;
	}
	/**
	 * <p>
	 * This will signify that a DTD is being parsed, and can be
	 *   used to ensure that comments and other lexical structures
	 *   in the DTD are not added to the JDOM <code>Document</code>
	 *   object.
	 * </p>
	 *
	 * @param name <code>String</code> name of element listed in DTD
	 * @param publicId <code>String</code> public ID of DTD
	 * @param systemId <code>String</code> syste ID of DTD
	 */
	public void startDTD(String name, String publicId, String systemId)
		throws SAXException {

			document.setDocType(
					factory.docType(name, publicId, systemId));
			inDTD = true;
		}
	/**
	 * <p>
	 * This reports the occurrence of an actual element.  It will include
	 *   the element's attributes, with the exception of XML vocabulary
	 *   specific attributes, such as
	 *   <code>xmlns:[namespace prefix]</code> and
	 *   <code>xsi:schemaLocation</code>.
	 * </p>
	 *
	 * @param namespaceURI <code>String</code> namespace URI this element
	 *                     is associated with, or an empty
	 *                     <code>String</code>
	 * @param localName <code>String</code> name of element (with no
	 *                  namespace prefix, if one is present)
	 * @param qName <code>String</code> XML 1.0 version of element name:
	 *                [namespace prefix]:[localName]
	 * @param atts <code>Attributes</code> list for this element
	 * @throws SAXException when things go wrong
	 */
	public void startElement(String namespaceURI, String localName,
			String qName, Attributes atts)
		throws SAXException {
			if (suppress) return;

			Element element = null;

			if ((namespaceURI != null) && (!namespaceURI.equals(""))) {
				String prefix = "";

				// Determine any prefix on the Element
				if (localName != qName) {
					int split = qName.indexOf(":");
					prefix = qName.substring(0, split);
				}
				Namespace elementNamespace =
					Namespace.getNamespace(prefix, namespaceURI);
				element = factory.element(localName, elementNamespace);

				// Remove this namespace from those in the temp declared list
				/**
				 * I've commented out these lines to ensure that element's that have a namespace
				 *   make those namespaces available to their attributes, which this seems to
				 *   break. However, I'm not 100% sure that this doesn't cause some other
				 *   problems. My gut feeling is "no", but I'm not sure, so I'm just commenting
				 *   it out. We'll remove for good in the next drop I think.
				 * - Brett, 07/30/2001
				 if (declaredNamespaces.size() > 0) {
				 declaredNamespaces.remove(elementNamespace);
				 }
				 */
			} else {
				element = factory.element(localName);
			}

			// Take leftover declared namespaces and add them to this element's
			// map of namespaces
			if (declaredNamespaces.size() > 0) {
				transferNamespaces(element);
			}

			// Handle attributes
			for (int i=0, len=atts.getLength(); i<len; i++) {
				Attribute attribute = null;

				String attLocalName = atts.getLocalName(i);
				String attQName = atts.getQName(i);

				// Bypass any xmlns attributes which might appear, as we got
				// them already in startPrefixMapping().
				// This is sometimes necessary when SAXHandler is used with
				// another source than SAXBuilder, as with JDOMResult.
				if (attQName.startsWith("xmlns:") || attQName.equals("xmlns")) {
					continue;
				}

				// XXX This is probably an unsafe != unless we set up interning
				if (attLocalName != attQName) {
					String attPrefix = attQName.substring(0, attQName.indexOf(":"));
					attribute = factory.attribute(attLocalName, atts.getValue(i),
							getNamespace(attPrefix));
				} else {
					attribute = factory.attribute(attLocalName, atts.getValue(i));
				}
				element.setAttribute(attribute);
			}

			if (atRoot) {
				document.setRootElement(element);
				stack.push(element);
				atRoot = false;
			} else {
				getCurrentElement().addContent(element);
				stack.push(element);
			}
		}
	public void startEntity(String name)
		throws SAXException {

			entityDepth++;

			if (expand || entityDepth > 1) {
				// Short cut out if we're expanding or if we're nested
				return;
			}

			// Ignore DTD references, and translate the standard 5
			if ((!inDTD) &&
					(!name.equals("amp")) &&
					(!name.equals("lt")) &&
					(!name.equals("gt")) &&
					(!name.equals("apos")) &&
					(!name.equals("quot"))) {

				if (!expand) {
					String pub = null;
					String sys = null;
					String[] ids = (String[]) externalEntities.get(name);
					if (ids != null) {
						pub = ids[0];  // may be null, that's OK
						sys = ids[1];  // may be null, that's OK
					}
					EntityRef entity = factory.entityRef(name, pub, sys);
					getCurrentElement().addContent(entity);
					suppress = true;
				}
			}
		}
	/**
	 * <p>
	 * This will add the prefix mapping to the JDOM
	 *   <code>Document</code> object.
	 * </p>
	 *
	 * @param prefix <code>String</code> namespace prefix.
	 * @param uri <code>String</code> namespace URI.
	 */
	public void startPrefixMapping(String prefix, String uri)
		throws SAXException {

			if (suppress) return;

			Namespace ns = Namespace.getNamespace(prefix, uri);
			declaredNamespaces.add(ns);
		}
	/**
	 * <p>
	 *  This will take the supplied <code>{@link Element}</code> and
	 *    transfer its namespaces to the global namespace storage.
	 * </p>
	 *
	 * @param element <code>Element</code> to read namespaces from.
	 */
	private void transferNamespaces(Element element) {
		Iterator i = declaredNamespaces.iterator();
		while (i.hasNext()) {
			Namespace ns = (Namespace)i.next();
			availableNamespaces.addFirst(ns);
			element.addNamespaceDeclaration(ns);
		}
		declaredNamespaces.clear();
	}
	/**
	 * <P>
	 * handler for unparsed entity declarations in the DTD
	 * </P>
	 *
	 * @param name <code>String</code> of the unparsed entity decl
	 * @param publicId <code>String</code> of the unparsed entity decl
	 * @param systemId <code>String</code> of the unparsed entity decl
	 * @param notationName <code>String</code> of the unparsed entity decl
	 */
	public void unparsedEntityDecl(String name, String publicId,
			String systemId, String notationName)
		throws SAXException { 

			buffer.append("  <!ENTITY ")
				.append(name);
			if (publicId != null) {
				buffer.append(" PUBLIC \"")
					.append(publicId)
					.append("\" ");
			}
			if (systemId != null) {
				buffer.append(" SYSTEM \"")
					.append(systemId)
					.append("\" ");
			}

			buffer.append(" NDATA ")
				.append(notationName);
			buffer.append(">\n");}
}