/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code 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 the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.sun.xml.internal.txw2.output;

import org.xml.sax.Attributes;

import org.xml.sax.ContentHandler;

import org.xml.sax.SAXException;

import org.xml.sax.ext.LexicalHandler;

import org.xml.sax.helpers.XMLFilterImpl;

import java.util.Stack;

/**

 * {@link XMLFilterImpl} that does indentation to SAX events.

 *

 * @author Kohsuke Kawaguchi

 */

public class IndentingXMLFilter extends XMLFilterImpl implements LexicalHandler {

    private LexicalHandler lexical;

    public IndentingXMLFilter() {

    }

    public IndentingXMLFilter(ContentHandler handler) {

        setContentHandler(handler);

    }

    public IndentingXMLFilter(ContentHandler handler, LexicalHandler lexical) {

        setContentHandler(handler);

        setLexicalHandler(lexical);

    }

    public LexicalHandler getLexicalHandler() {

        return lexical;

    }

    public void setLexicalHandler(LexicalHandler lexical) {

        this.lexical = lexical;

    }

    /**

     * Return the current indent step.

     *

     * <p>Return the current indent step: each start tag will be

     * indented by this number of spaces times the number of

     * ancestors that the element has.</p>

     *

     * @return The number of spaces in each indentation step,

     *         or 0 or less for no indentation.

     * @see #setIndentStep(int)

     *

     * @deprecated

     *      Only return the length of the indent string.

     */

    public int getIndentStep ()

    {

        return indentStep.length();

    }

    /**

     * Set the current indent step.

     *

     * @param indentStep The new indent step (0 or less for no

     *        indentation).

     * @see #getIndentStep()

     *

     * @deprecated

     *      Should use the version that takes string.

     */

    public void setIndentStep (int indentStep)

    {

        StringBuilder s = new StringBuilder();

        for( ; indentStep>0; indentStep-- )   s.append(' ');

        setIndentStep(s.toString());

    }

    public void setIndentStep(String s) {

        this.indentStep = s;

    }

    ////////////////////////////////////////////////////////////////////

    // Override methods from XMLWriter.

    ////////////////////////////////////////////////////////////////////

    /**

     * Write a start tag.

     *

     * <p>Each tag will begin on a new line, and will be

     * indented by the current indent step times the number

     * of ancestors that the element has.</p>

     *

     * <p>The newline and indentation will be passed on down

     * the filter chain through regular characters events.</p>

     *

     * @param uri The element's Namespace URI.

     * @param localName The element's local name.

     * @param qName The element's qualified (prefixed) name.

     * @param atts The element's attribute list.

     * @exception org.xml.sax.SAXException If there is an error

     *            writing the start tag, or if a filter further

     *            down the chain raises an exception.

     * @see XMLWriter#startElement(String, String, String,Attributes)

     */

    public void startElement (String uri, String localName,

                              String qName, Attributes atts)

        throws SAXException {

        stateStack.push(SEEN_ELEMENT);

        state = SEEN_NOTHING;

        if (depth > 0) {

            writeNewLine();

        }

        doIndent();

        super.startElement(uri, localName, qName, atts);

        depth++;

    }

    private void writeNewLine() throws SAXException {

        super.characters(NEWLINE,0,NEWLINE.length);

    }

    private static final char[] NEWLINE = {'\n'};

    /**

     * Write an end tag.

     *

     * <p>If the element has contained other elements, the tag

     * will appear indented on a new line; otherwise, it will

     * appear immediately following whatever came before.</p>

     *

     * <p>The newline and indentation will be passed on down

     * the filter chain through regular characters events.</p>

     *

     * @param uri The element's Namespace URI.

     * @param localName The element's local name.

     * @param qName The element's qualified (prefixed) name.

     * @exception org.xml.sax.SAXException If there is an error

     *            writing the end tag, or if a filter further

     *            down the chain raises an exception.

     * @see XMLWriter#endElement(String, String, String)

     */

    public void endElement (String uri, String localName, String qName)

        throws SAXException

    {

        depth--;

        if (state == SEEN_ELEMENT) {

            writeNewLine();

            doIndent();

        }

        super.endElement(uri, localName, qName);

        state = stateStack.pop();

    }

//    /**

//     * Write a empty element tag.

//     *

//     * <p>Each tag will appear on a new line, and will be

//     * indented by the current indent step times the number

//     * of ancestors that the element has.</p>

//     *

//     * <p>The newline and indentation will be passed on down

//     * the filter chain through regular characters events.</p>

//     *

//     * @param uri The element's Namespace URI.

//     * @param localName The element's local name.

//     * @param qName The element's qualified (prefixed) name.

//     * @param atts The element's attribute list.

//     * @exception org.xml.sax.SAXException If there is an error

//     *            writing the empty tag, or if a filter further

//     *            down the chain raises an exception.

//     * @see XMLWriter#emptyElement(String, String, String, Attributes)

//     */

//    public void emptyElement (String uri, String localName,

//                              String qName, Attributes atts)

//        throws SAXException

//    {

//        state = SEEN_ELEMENT;

//        if (depth > 0) {

//            super.characters("\n");

//        }

//        doIndent();

//        super.emptyElement(uri, localName, qName, atts);

//    }

    /**

     * Write a sequence of characters.

     *

     * @param ch The characters to write.

     * @param start The starting position in the array.

     * @param length The number of characters to use.

     * @exception org.xml.sax.SAXException If there is an error

     *            writing the characters, or if a filter further

     *            down the chain raises an exception.

     * @see XMLWriter#characters(char[], int, int)

     */

    public void characters (char ch[], int start, int length)

        throws SAXException

    {

        state = SEEN_DATA;

        super.characters(ch, start, length);

    }

    public void comment(char ch[], int start, int length) throws SAXException {

        if (depth > 0) {

            writeNewLine();

        }

        doIndent();

        if(lexical!=null)

            lexical.comment(ch,start,length);

    }

    public void startDTD(String name, String publicId, String systemId) throws SAXException {

        if(lexical!=null)

            lexical.startDTD(name, publicId, systemId);

    }

    public void endDTD() throws SAXException {

        if(lexical!=null)

            lexical.endDTD();

    }

    public void startEntity(String name) throws SAXException {

        if(lexical!=null)

            lexical.startEntity(name);

    }

    public void endEntity(String name) throws SAXException {

        if(lexical!=null)

            lexical.endEntity(name);

    }

    public void startCDATA() throws SAXException {

        if(lexical!=null)

            lexical.startCDATA();

    }

    public void endCDATA() throws SAXException {

        if(lexical!=null)

            lexical.endCDATA();

    }

    ////////////////////////////////////////////////////////////////////

    // Internal methods.

    ////////////////////////////////////////////////////////////////////

    /**

     * Print indentation for the current level.

     *

     * @exception org.xml.sax.SAXException If there is an error

     *            writing the indentation characters, or if a filter

     *            further down the chain raises an exception.

     */

    private void doIndent ()

        throws SAXException

    {

        if (depth > 0) {

            char[] ch = indentStep.toCharArray();

            for( int i=0; i<depth; i++ )

                characters(ch, 0, ch.length);

        }

    }

    ////////////////////////////////////////////////////////////////////

    // Constants.

    ////////////////////////////////////////////////////////////////////

    private final static Object SEEN_NOTHING = new Object();

    private final static Object SEEN_ELEMENT = new Object();

    private final static Object SEEN_DATA = new Object();

    ////////////////////////////////////////////////////////////////////

    // Internal state.

    ////////////////////////////////////////////////////////////////////

    private Object state = SEEN_NOTHING;

    private Stack<Object> stateStack = new Stack<Object>();

    private String indentStep = "";

    private int depth = 0;

}