/*
 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
 *
 * This software is open source.
 * See the bottom of this file for the licence.
 */

package org.dom4j.jaxb;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.URL;
import java.nio.charset.Charset;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.ElementHandler;
import org.dom4j.ElementPath;
import org.dom4j.io.SAXReader;

import org.xml.sax.InputSource;

/**
 * Reads an XML document and creates a DOM4J tree from SAX parsing events.
 * {@link JAXBObjectHandler}objects can be registered to automatically receive
 * unmarshalled XML fragments. Registered {@link org.dom4j.ElementHandler}
 * implementations are notified when a certain element path is encountered
 * 
 * @author Wonne Keysers (Realsoftware.be)
 * 
 * @see org.dom4j.io.SAXReader
 * @see javax.xml.bind.JAXBContext
 */
public class JAXBReader extends JAXBSupport {
    private SAXReader reader;

    private boolean pruneElements;

    /**
     * Creates a new JAXBReader for the given JAXB context path. This is the
     * Java package where JAXB can find the generated XML classes. This package
     * MUST contain jaxb.properties!
     * 
     * @param contextPath
     *            context path to be used
     * 
     * @see javax.xml.bind.JAXBContext
     */
    public JAXBReader(String contextPath) {
        super(contextPath);
    }

    /**
     * Creates a new JAXBReader for the given JAXB context path, using the
     * specified {@link java.lang.ClassLoader}. This is the Java package where
     * JAXB can find the generated XML classes. This package MUST contain
     * jaxb.properties!
     * 
     * @param contextPath
     *            to be used
     * @param classloader
     *            to be used
     * 
     * @see javax.xml.bind.JAXBContext
     */
    public JAXBReader(String contextPath, ClassLoader classloader) {
        super(contextPath, classloader);
    }

    /**
     * Parses the specified {@link java.io.File}
     * 
     * @param source
     *            the file to parse
     * 
     * @return the resulting DOM4J document
     * 
     * @throws DocumentException
     *             when an error occurs while parsing
     */
    public Document read(File source) throws DocumentException {
        return getReader().read(source);
    }

    /**
     * Parses the specified {@link java.io.File}, using the given {@link
     * java.nio.charset.Charset}.
     * 
     * @param file
     *            the file to parse
     * @param charset
     *            the charset to be used
     * 
     * @return the resulting DOM4J document
     * 
     * @throws DocumentException
     *             when an error occurs while parsing
     */
    public Document read(File file, Charset charset) throws DocumentException {
        try {
            Reader xmlReader = new InputStreamReader(new FileInputStream(file),
                    charset);

            return getReader().read(xmlReader);
        } catch (JAXBRuntimeException ex) {
            Throwable cause = ex.getCause();
            throw new DocumentException(cause.getMessage(), cause);
        } catch (FileNotFoundException ex) {
            throw new DocumentException(ex.getMessage(), ex);
        }
    }

    /**
     * Parses the specified {@link org.xml.sax.InputSource}
     * 
     * @param source
     *            the source to parse
     * 
     * @return the resulting DOM4J document
     * 
     * @throws DocumentException
     *             when an error occurs while parsing
     */
    public Document read(InputSource source) throws DocumentException {
        try {
            return getReader().read(source);
        } catch (JAXBRuntimeException ex) {
            Throwable cause = ex.getCause();
            throw new DocumentException(cause.getMessage(), cause);
        }
    }

    /**
     * Parses the specified {@link java.io.InputStream}
     * 
     * @param source
     *            the input stream to parse
     * 
     * @return the resulting DOM4J document
     * 
     * @throws DocumentException
     *             when an error occurs while parsing
     */
    public Document read(InputStream source) throws DocumentException {
        try {
            return getReader().read(source);
        } catch (JAXBRuntimeException ex) {
            Throwable cause = ex.getCause();
            throw new DocumentException(cause.getMessage(), cause);
        }
    }

    /**
     * Parses the specified {@link java.io.InputStream}
     * 
     * @param source
     *            the input stream to parse
     * @param systemId
     *            is the URI for the input
     * 
     * @return the resulting DOM4J document
     * 
     * @throws DocumentException
     *             when an error occurs while parsing
     */
    public Document read(InputStream source, String systemId)
            throws DocumentException {
        try {
            return getReader().read(source);
        } catch (JAXBRuntimeException ex) {
            Throwable cause = ex.getCause();
            throw new DocumentException(cause.getMessage(), cause);
        }
    }

    /**
     * Parses the specified {@link java.io.Reader}
     * 
     * @param source
     *            the input reader to use
     * 
     * @return the resulting DOM4J document
     * 
     * @throws DocumentException
     *             when an error occurs while parsing
     */
    public Document read(Reader source) throws DocumentException {
        try {
            return getReader().read(source);
        } catch (JAXBRuntimeException ex) {
            Throwable cause = ex.getCause();
            throw new DocumentException(cause.getMessage(), cause);
        }
    }

    /**
     * Parses the specified {@link java.io.Reader}
     * 
     * @param source
     *            the input reader to parse
     * @param systemId
     *            is the URI for the input
     * 
     * @return the resulting DOM4J document
     * 
     * @throws DocumentException
     *             when an error occurs while parsing
     */
    public Document read(Reader source, String systemId)
            throws DocumentException {
        try {
            return getReader().read(source);
        } catch (JAXBRuntimeException ex) {
            Throwable cause = ex.getCause();
            throw new DocumentException(cause.getMessage(), cause);
        }
    }

    /**
     * Parses the the given URL or filename.
     * 
     * @param source
     *            the location to parse
     * 
     * @return the resulting DOM4J document
     * 
     * @throws DocumentException
     *             when an error occurs while parsing
     */
    public Document read(String source) throws DocumentException {
        try {
            return getReader().read(source);
        } catch (JAXBRuntimeException ex) {
            Throwable cause = ex.getCause();
            throw new DocumentException(cause.getMessage(), cause);
        }
    }

    /**
     * Parses the the given URL.
     * 
     * @param source
     *            the URL to parse
     * 
     * @return the resulting DOM4J document
     * 
     * @throws DocumentException
     *             when an error occurs while parsing
     */
    public Document read(URL source) throws DocumentException {
        try {
            return getReader().read(source);
        } catch (JAXBRuntimeException ex) {
            Throwable cause = ex.getCause();
            throw new DocumentException(cause.getMessage(), cause);
        }
    }

    /**
     * Registers a {@link JAXBObjectHandler}that will be supplied with the
     * unmarshalled representation of the xml fragment whenever the specified
     * path is encounted.
     * 
     * @param path
     *            the path to listen for
     * @param handler
     *            the handler to be notified
     */
    public void addObjectHandler(String path, JAXBObjectHandler handler) {
        ElementHandler eHandler = new UnmarshalElementHandler(this, handler);
        getReader().addHandler(path, eHandler);
    }

    /**
     * Removes the {@link JAXBObjectHandler}from the event based processor, for
     * the specified element path.
     * 
     * @param path
     *            The path to remove the {@link JAXBObjectHandler}for
     */
    public void removeObjectHandler(String path) {
        getReader().removeHandler(path);
    }

    /**
     * Adds the <code>ElementHandler</code> to be called when the specified
     * path is encounted.
     * 
     * @param path
     *            is the path to be handled
     * @param handler
     *            is the <code>ElementHandler</code> to be called by the event
     *            based processor.
     */
    public void addHandler(String path, ElementHandler handler) {
        getReader().addHandler(path, handler);
    }

    /**
     * Removes the <code>ElementHandler</code> from the event based processor,
     * for the specified path.
     * 
     * @param path
     *            is the path to remove the <code>ElementHandler</code> for.
     */
    public void removeHandler(String path) {
        getReader().removeHandler(path);
    }

    /**
     * Removes all registered {@link JAXBObjectHandler}and {@link
     * org.dom4j.ElementHandler} instances from the event based processor.
     */
    public void resetHandlers() {
        getReader().resetHandlers();
    }

    /**
     * When 'true', the DOM4J document will not be kept in memory while parsing.
     * 
     * @return Returns the pruneElements.
     */
    public boolean isPruneElements() {
        return pruneElements;
    }

    /**
     * Set to true when DOM4J elements must immediately be pruned from the tree.
     * The {@link Document}will not be available afterwards!
     * 
     * @param pruneElements DOCUMENT ME!
     */
    public void setPruneElements(boolean pruneElements) {
        this.pruneElements = pruneElements;

        if (pruneElements) {
            getReader().setDefaultHandler(new PruningElementHandler());
        }
    }

    private SAXReader getReader() {
        if (reader == null) {
            reader = new SAXReader();
        }

        return reader;
    }

    private class UnmarshalElementHandler implements ElementHandler {
        private JAXBReader jaxbReader;

        private JAXBObjectHandler handler;

        public UnmarshalElementHandler(JAXBReader documentReader,
                JAXBObjectHandler handler) {
            this.jaxbReader = documentReader;
            this.handler = handler;
        }

        public void onStart(ElementPath elementPath) {
        }

        public void onEnd(ElementPath elementPath) {
            try {
                org.dom4j.Element elem = elementPath.getCurrent();

                javax.xml.bind.Element jaxbObject 
                        = (javax.xml.bind.Element) jaxbReader.unmarshal(elem);

                if (jaxbReader.isPruneElements()) {
                    elem.detach();
                }

                handler.handleObject(jaxbObject);
            } catch (Exception ex) {
                throw new JAXBRuntimeException(ex);
            }
        }
    }

    private class PruningElementHandler implements ElementHandler {
        public PruningElementHandler() {
        }

        public void onStart(ElementPath parm1) {
        }

        public void onEnd(ElementPath elementPath) {
            Element elem = elementPath.getCurrent();
            elem.detach();
            elem = null;
        }
    }
}

/*
 * Redistribution and use of this software and associated documentation
 * ("Software"), with or without modification, are permitted provided that the
 * following conditions are met:
 * 
 * 1. Redistributions of source code must retain copyright statements and
 * notices. Redistributions must also contain a copy of this document.
 * 
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 * 
 * 3. The name "DOM4J" must not be used to endorse or promote products derived
 * from this Software without prior written permission of MetaStuff, Ltd. For
 * written permission, please contact dom4j-info@metastuff.com.
 * 
 * 4. Products derived from this Software may not be called "DOM4J" nor may
 * "DOM4J" appear in their names without prior written permission of MetaStuff,
 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
 * 
 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
 * 
 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 * 
 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
 */
