/*

 * Copyright (c) 1998, 2006, Oracle and/or its affiliates. All rights reserved.

 * 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 javax.swing.text;

import java.io.Writer;

import java.io.IOException;

import java.util.Enumeration;

/**

 * AbstractWriter is an abstract class that actually

 * does the work of writing out the element tree

 * including the attributes.  In terms of how much is

 * written out per line, the writer defaults to 100.

 * But this value can be set by subclasses.

 *

 * @author Sunita Mani

 */

public abstract class AbstractWriter {

    private ElementIterator it;

    private Writer out;

    private int indentLevel = 0;

    private int indentSpace = 2;

    private Document doc = null;

    private int maxLineLength = 100;

    private int currLength = 0;

    private int startOffset = 0;

    private int endOffset = 0;

    // If (indentLevel * indentSpace) becomes >= maxLineLength, this will

    // get incremened instead of indentLevel to avoid indenting going greater

    // than line length.

    private int offsetIndent = 0;

    /**

     * String used for end of line. If the Document has the property

     * EndOfLineStringProperty, it will be used for newlines. Otherwise

     * the System property line.separator will be used. The line separator

     * can also be set.

     */

    private String lineSeparator;

    /**

     * True indicates that when writing, the line can be split, false

     * indicates that even if the line is > than max line length it should

     * not be split.

     */

    private boolean canWrapLines;

    /**

     * True while the current line is empty. This will remain true after

     * indenting.

     */

    private boolean isLineEmpty;

    /**

     * Used when indenting. Will contain the spaces.

     */

    private char[] indentChars;

    /**

     * Used when writing out a string.

     */

    private char[] tempChars;

    /**

     * This is used in <code>writeLineSeparator</code> instead of

     * tempChars. If tempChars were used it would mean write couldn't invoke

     * <code>writeLineSeparator</code> as it might have been passed

     * tempChars.

     */

    private char[] newlineChars;

    /**

     * Used for writing text.

     */

    private Segment segment;

    /**

     * How the text packages models newlines.

     * @see #getLineSeparator

     */

    protected static final char NEWLINE = '\n';

    /**

     * Creates a new AbstractWriter.

     * Initializes the ElementIterator with the default

     * root of the document.

     *

     * @param w a Writer.

     * @param doc a Document

     */

    protected AbstractWriter(Writer w, Document doc) {

        this(w, doc, 0, doc.getLength());

    }

    /**

     * Creates a new AbstractWriter.

     * Initializes the ElementIterator with the

     * element passed in.

     *

     * @param w a Writer

     * @param doc an Element

     * @param pos The location in the document to fetch the

     *   content.

     * @param len The amount to write out.

     */

    protected AbstractWriter(Writer w, Document doc, int pos, int len) {

        this.doc = doc;

        it = new ElementIterator(doc.getDefaultRootElement());

        out = w;

        startOffset = pos;

        endOffset = pos + len;

        Object docNewline = doc.getProperty(DefaultEditorKit.

                                       EndOfLineStringProperty);

        if (docNewline instanceof String) {

            setLineSeparator((String)docNewline);

        }

        else {

            String newline = null;

            try {

                newline = System.getProperty("line.separator");

            } catch (SecurityException se) {}

            if (newline == null) {

                // Should not get here, but if we do it means we could not

                // find a newline string, use \n in this case.

                newline = "\n";

            }

            setLineSeparator(newline);

        }

        canWrapLines = true;

    }

    /**

     * Creates a new AbstractWriter.

     * Initializes the ElementIterator with the

     * element passed in.

     *

     * @param w a Writer

     * @param root an Element

     */

    protected AbstractWriter(Writer w, Element root) {

        this(w, root, 0, root.getEndOffset());

    }

    /**

     * Creates a new AbstractWriter.

     * Initializes the ElementIterator with the

     * element passed in.

     *

     * @param w a Writer

     * @param root an Element

     * @param pos The location in the document to fetch the

     *   content.

     * @param len The amount to write out.

     */

    protected AbstractWriter(Writer w, Element root, int pos, int len) {

        this.doc = root.getDocument();

        it = new ElementIterator(root);

        out = w;

        startOffset = pos;

        endOffset = pos + len;

        canWrapLines = true;

    }

    /**

     * Returns the first offset to be output.

     *

     * @since 1.3

     */

    public int getStartOffset() {

        return startOffset;

    }

    /**

     * Returns the last offset to be output.

     *

     * @since 1.3

     */

    public int getEndOffset() {

        return endOffset;

    }

    /**

     * Fetches the ElementIterator.

     *

     * @return the ElementIterator.

     */

    protected ElementIterator getElementIterator() {

        return it;

    }

    /**

     * Returns the Writer that is used to output the content.

     *

     * @since 1.3

     */

    protected Writer getWriter() {

        return out;

    }

    /**

     * Fetches the document.

     *

     * @return the Document.

     */

    protected Document getDocument() {

        return doc;

    }

    /**

     * This method determines whether the current element

     * is in the range specified.  When no range is specified,

     * the range is initialized to be the entire document.

     * inRange() returns true if the range specified intersects

     * with the element's range.

     *

     * @param  next an Element.

     * @return boolean that indicates whether the element

     *         is in the range.

     */

    protected boolean inRange(Element next) {

        int startOffset = getStartOffset();

        int endOffset = getEndOffset();

        if ((next.getStartOffset() >= startOffset &&

             next.getStartOffset()  < endOffset) ||

            (startOffset >= next.getStartOffset() &&

             startOffset < next.getEndOffset())) {

            return true;

        }

        return false;

    }

    /**

     * This abstract method needs to be implemented

     * by subclasses.  Its responsibility is to

     * iterate over the elements and use the write()

     * methods to generate output in the desired format.

     */

    abstract protected void write() throws IOException, BadLocationException;

    /**

     * Returns the text associated with the element.

     * The assumption here is that the element is a

     * leaf element.  Throws a BadLocationException

     * when encountered.

     *

     * @param     elem an <code>Element</code>

     * @exception BadLocationException if pos represents an invalid

     *            location within the document

     * @return    the text as a <code>String</code>

     */

    protected String getText(Element elem) throws BadLocationException {

        return doc.getText(elem.getStartOffset(),

                           elem.getEndOffset() - elem.getStartOffset());

    }

    /**

     * Writes out text.  If a range is specified when the constructor

     * is invoked, then only the appropriate range of text is written

     * out.

     *

     * @param     elem an Element.

     * @exception IOException on any I/O error

     * @exception BadLocationException if pos represents an invalid

     *            location within the document.

     */

    protected void text(Element elem) throws BadLocationException,

                                             IOException {

        int start = Math.max(getStartOffset(), elem.getStartOffset());

        int end = Math.min(getEndOffset(), elem.getEndOffset());

        if (start < end) {

            if (segment == null) {

                segment = new Segment();

            }

            getDocument().getText(start, end - start, segment);

            if (segment.count > 0) {

                write(segment.array, segment.offset, segment.count);

            }

        }

    }

    /**

     * Enables subclasses to set the number of characters they

     * want written per line.   The default is 100.

     *

     * @param l the maximum line length.

     */

    protected void setLineLength(int l) {

        maxLineLength = l;

    }

    /**

     * Returns the maximum line length.

     *

     * @since 1.3

     */

    protected int getLineLength() {

        return maxLineLength;

    }

    /**

     * Sets the current line length.

     *

     * @since 1.3

     */

    protected void setCurrentLineLength(int length) {

        currLength = length;

        isLineEmpty = (currLength == 0);

    }

    /**

     * Returns the current line length.

     *

     * @since 1.3

     */

    protected int getCurrentLineLength() {

        return currLength;

    }

    /**

     * Returns true if the current line should be considered empty. This

     * is true when <code>getCurrentLineLength</code> == 0 ||

     * <code>indent</code> has been invoked on an empty line.

     *

     * @since 1.3

     */

    protected boolean isLineEmpty() {

        return isLineEmpty;

    }

    /**

     * Sets whether or not lines can be wrapped. This can be toggled

     * during the writing of lines. For example, outputting HTML might

     * set this to false when outputting a quoted string.

     *

     * @since 1.3

     */

    protected void setCanWrapLines(boolean newValue) {

        canWrapLines = newValue;

    }

    /**

     * Returns whether or not the lines can be wrapped. If this is false

     * no lineSeparator's will be output.

     *

     * @since 1.3

     */

    protected boolean getCanWrapLines() {

        return canWrapLines;

    }

    /**

     * Enables subclasses to specify how many spaces an indent

     * maps to. When indentation takes place, the indent level

     * is multiplied by this mapping.  The default is 2.

     *

     * @param space an int representing the space to indent mapping.

     */

    protected void setIndentSpace(int space) {

        indentSpace = space;

    }

    /**

     * Returns the amount of space to indent.

     *

     * @since 1.3

     */

    protected int getIndentSpace() {

        return indentSpace;

    }

    /**

     * Sets the String used to reprsent newlines. This is initialized

     * in the constructor from either the Document, or the System property

     * line.separator.

     *

     * @since 1.3

     */

    public void setLineSeparator(String value) {

        lineSeparator = value;

    }

    /**

     * Returns the string used to represent newlines.

     *

     * @since 1.3

     */

    public String getLineSeparator() {

        return lineSeparator;

    }

    /**

     * Increments the indent level. If indenting would cause

     * <code>getIndentSpace()</code> *<code>getIndentLevel()</code> to be &gt;

     * than <code>getLineLength()</code> this will not cause an indent.

     */

    protected void incrIndent() {

        // Only increment to a certain point.

        if (offsetIndent > 0) {

            offsetIndent++;

        }

        else {

            if (++indentLevel * getIndentSpace() >= getLineLength()) {

                offsetIndent++;

                --indentLevel;

            }

        }

    }

    /**

     * Decrements the indent level.

     */

    protected void decrIndent() {

        if (offsetIndent > 0) {

            --offsetIndent;

        }

        else {

            indentLevel--;

        }

    }

    /**

     * Returns the current indentation level. That is, the number of times

     * <code>incrIndent</code> has been invoked minus the number of times

     * <code>decrIndent</code> has been invoked.

     *

     * @since 1.3

     */

    protected int getIndentLevel() {

        return indentLevel;

    }

    /**

     * Does indentation. The number of spaces written

     * out is indent level times the space to map mapping. If the current

     * line is empty, this will not make it so that the current line is

     * still considered empty.

     *

     * @exception IOException on any I/O error

     */

    protected void indent() throws IOException {

        int max = getIndentLevel() * getIndentSpace();

        if (indentChars == null || max > indentChars.length) {

            indentChars = new char[max];

            for (int counter = 0; counter < max; counter++) {

                indentChars[counter] = ' ';

            }

        }

        int length = getCurrentLineLength();

        boolean wasEmpty = isLineEmpty();

        output(indentChars, 0, max);

        if (wasEmpty && length == 0) {

            isLineEmpty = true;

        }

    }

    /**

     * Writes out a character. This is implemented to invoke

     * the <code>write</code> method that takes a char[].

     *

     * @param     ch a char.

     * @exception IOException on any I/O error

     */

    protected void write(char ch) throws IOException {

        if (tempChars == null) {

            tempChars = new char[128];

        }

        tempChars[0] = ch;

        write(tempChars, 0, 1);

    }

    /**

     * Writes out a string. This is implemented to invoke the

     * <code>write</code> method that takes a char[].

     *

     * @param     content a String.

     * @exception IOException on any I/O error

     */

    protected void write(String content) throws IOException {

        if (content == null) {

            return;

        }

        int size = content.length();

        if (tempChars == null || tempChars.length < size) {

            tempChars = new char[size];

        }

        content.getChars(0, size, tempChars, 0);

        write(tempChars, 0, size);

    }

    /**

     * Writes the line separator. This invokes <code>output</code> directly

     * as well as setting the <code>lineLength</code> to 0.

     *

     * @since 1.3

     */

    protected void writeLineSeparator() throws IOException {

        String newline = getLineSeparator();

        int length = newline.length();

        if (newlineChars == null || newlineChars.length < length) {

            newlineChars = new char[length];