/*

 * 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.util.Vector;

import java.io.Serializable;

import javax.swing.undo.*;

import javax.swing.SwingUtilities;

/**

 * An implementation of the AbstractDocument.Content interface that is

 * a brute force implementation that is useful for relatively small

 * documents and/or debugging.  It manages the character content

 * as a simple character array.  It is also quite inefficient.

 * <p>

 * It is generally recommended that the gap buffer or piece table

 * implementations be used instead.  This buffer does not scale up

 * to large sizes.

 * <p>

 * <strong>Warning:</strong>

 * Serialized objects of this class will not be compatible with

 * future Swing releases. The current serialization support is

 * appropriate for short term storage or RMI between applications running

 * the same version of Swing.  As of 1.4, support for long term storage

 * of all JavaBeans™

 * has been added to the <code>java.beans</code> package.

 * Please see {@link java.beans.XMLEncoder}.

 *

 * @author  Timothy Prinzing

 */

public final class StringContent implements AbstractDocument.Content, Serializable {

    /**

     * Creates a new StringContent object.  Initial size defaults to 10.

     */

    public StringContent() {

        this(10);

    }

    /**

     * Creates a new StringContent object, with the initial

     * size specified.  If the length is < 1, a size of 1 is used.

     *

     * @param initialLength the initial size

     */

    public StringContent(int initialLength) {

        if (initialLength < 1) {

            initialLength = 1;

        }

        data = new char[initialLength];

        data[0] = '\n';

        count = 1;

    }

    /**

     * Returns the length of the content.

     *

     * @return the length >= 1

     * @see AbstractDocument.Content#length

     */

    public int length() {

        return count;

    }

    /**

     * Inserts a string into the content.

     *

     * @param where the starting position >= 0 && < length()

     * @param str the non-null string to insert

     * @return an UndoableEdit object for undoing

     * @exception BadLocationException if the specified position is invalid

     * @see AbstractDocument.Content#insertString

     */

    public UndoableEdit insertString(int where, String str) throws BadLocationException {

        if (where >= count || where < 0) {

            throw new BadLocationException("Invalid location", count);

        }

        char[] chars = str.toCharArray();

        replace(where, 0, chars, 0, chars.length);

        if (marks != null) {

            updateMarksForInsert(where, str.length());

        }

        return new InsertUndo(where, str.length());

    }

    /**

     * Removes part of the content.  where + nitems must be < length().

     *

     * @param where the starting position >= 0

     * @param nitems the number of characters to remove >= 0

     * @return an UndoableEdit object for undoing

     * @exception BadLocationException if the specified position is invalid

     * @see AbstractDocument.Content#remove

     */

    public UndoableEdit remove(int where, int nitems) throws BadLocationException {

        if (where + nitems >= count) {

            throw new BadLocationException("Invalid range", count);

        }

        String removedString = getString(where, nitems);

        UndoableEdit edit = new RemoveUndo(where, removedString);

        replace(where, nitems, empty, 0, 0);

        if (marks != null) {

            updateMarksForRemove(where, nitems);

        }

        return edit;

    }

    /**

     * Retrieves a portion of the content.  where + len must be <= length().

     *

     * @param where the starting position >= 0

     * @param len the length to retrieve >= 0

     * @return a string representing the content; may be empty

     * @exception BadLocationException if the specified position is invalid

     * @see AbstractDocument.Content#getString

     */

    public String getString(int where, int len) throws BadLocationException {

        if (where + len > count) {

            throw new BadLocationException("Invalid range", count);

        }

        return new String(data, where, len);

    }

    /**

     * Retrieves a portion of the content.  where + len must be <= length()

     *

     * @param where the starting position >= 0

     * @param len the number of characters to retrieve >= 0

     * @param chars the Segment object to return the characters in

     * @exception BadLocationException if the specified position is invalid

     * @see AbstractDocument.Content#getChars

     */

    public void getChars(int where, int len, Segment chars) throws BadLocationException {

        if (where + len > count) {

            throw new BadLocationException("Invalid location", count);

        }

        chars.array = data;

        chars.offset = where;

        chars.count = len;

    }

    /**

     * Creates a position within the content that will

     * track change as the content is mutated.

     *

     * @param offset the offset to create a position for >= 0

     * @return the position

     * @exception BadLocationException if the specified position is invalid

     */

    public Position createPosition(int offset) throws BadLocationException {

        // some small documents won't have any sticky positions

        // at all, so the buffer is created lazily.

        if (marks == null) {

            marks = new Vector<PosRec>();

        }

        return new StickyPosition(offset);

    }

    // --- local methods ---------------------------------------

    /**

     * Replaces some of the characters in the array

     * @param offset  offset into the array to start the replace

     * @param length  number of characters to remove

     * @param replArray replacement array

     * @param replOffset offset into the replacement array

     * @param replLength number of character to use from the

     *   replacement array.

     */

    void replace(int offset, int length,

                 char[] replArray, int replOffset, int replLength) {

        int delta = replLength - length;

        int src = offset + length;

        int nmove = count - src;

        int dest = src + delta;

        if ((count + delta) >= data.length) {

            // need to grow the array

            int newLength = Math.max(2*data.length, count + delta);

            char[] newData = new char[newLength];

            System.arraycopy(data, 0, newData, 0, offset);

            System.arraycopy(replArray, replOffset, newData, offset, replLength);

            System.arraycopy(data, src, newData, dest, nmove);

            data = newData;

        } else {

            // patch the existing array

            System.arraycopy(data, src, data, dest, nmove);

            System.arraycopy(replArray, replOffset, data, offset, replLength);

        }

        count = count + delta;

    }

    void resize(int ncount) {

        char[] ndata = new char[ncount];

        System.arraycopy(data, 0, ndata, 0, Math.min(ncount, count));

        data = ndata;

    }

    synchronized void updateMarksForInsert(int offset, int length) {

        if (offset == 0) {

            // zero is a special case where we update only

            // marks after it.

            offset = 1;

        }

        int n = marks.size();

        for (int i = 0; i < n; i++) {

            PosRec mark = marks.elementAt(i);

            if (mark.unused) {

                // this record is no longer used, get rid of it

                marks.removeElementAt(i);

                i -= 1;

                n -= 1;

            } else if (mark.offset >= offset) {

                mark.offset += length;

            }

        }

    }

    synchronized void updateMarksForRemove(int offset, int length) {

        int n = marks.size();

        for (int i = 0; i < n; i++) {

            PosRec mark = marks.elementAt(i);

            if (mark.unused) {

                // this record is no longer used, get rid of it

                marks.removeElementAt(i);

                i -= 1;

                n -= 1;

            } else if (mark.offset >= (offset + length)) {

                mark.offset -= length;

            } else if (mark.offset >= offset) {

                mark.offset = offset;

            }

        }

    }

    /**

     * Returns a Vector containing instances of UndoPosRef for the

     * Positions in the range

     * <code>offset</code> to <code>offset</code> + <code>length</code>.

     * If <code>v</code> is not null the matching Positions are placed in

     * there. The vector with the resulting Positions are returned.

     * <p>

     * This is meant for internal usage, and is generally not of interest

     * to subclasses.

     *

     * @param v the Vector to use, with a new one created on null

     * @param offset the starting offset >= 0

     * @param length the length >= 0

     * @return the set of instances

     */

    protected Vector getPositionsInRange(Vector v, int offset,

                                                      int length) {

        int n = marks.size();

        int end = offset + length;

        Vector placeIn = (v == null) ? new Vector() : v;

        for (int i = 0; i < n; i++) {

            PosRec mark = marks.elementAt(i);

            if (mark.unused) {

                // this record is no longer used, get rid of it

                marks.removeElementAt(i);

                i -= 1;

                n -= 1;

            } else if(mark.offset >= offset && mark.offset <= end)

                placeIn.addElement(new UndoPosRef(mark));

        }

        return placeIn;

    }

    /**

     * Resets the location for all the UndoPosRef instances

     * in <code>positions</code>.

     * <p>

     * This is meant for internal usage, and is generally not of interest

     * to subclasses.

     *

     * @param positions the positions of the instances

     */

    protected void updateUndoPositions(Vector positions) {

        for(int counter = positions.size() - 1; counter >= 0; counter--) {

            UndoPosRef ref = (UndoPosRef)positions.elementAt(counter);

            // Check if the Position is still valid.

            if(ref.rec.unused) {

                positions.removeElementAt(counter);

            }

            else

                ref.resetLocation();

        }

    }

    private static final char[] empty = new char[0];

    private char[] data;

    private int count;

    transient Vector<PosRec> marks;

    /**

     * holds the data for a mark... separately from

     * the real mark so that the real mark can be

     * collected if there are no more references to

     * it.... the update table holds only a reference

     * to this grungy thing.

     */

    final class PosRec {

        PosRec(int offset) {

            this.offset = offset;

        }

        int offset;

        boolean unused;

    }

    /**

     * This really wants to be a weak reference but

     * in 1.1 we don't have a 100% pure solution for

     * this... so this class trys to hack a solution

     * to causing the marks to be collected.

     */

    final class StickyPosition implements Position {

        StickyPosition(int offset) {

            rec = new PosRec(offset);

            marks.addElement(rec);

        }

        public int getOffset() {

            return rec.offset;

        }

        protected void finalize() throws Throwable {

            // schedule the record to be removed later

            // on another thread.

            rec.unused = true;

        }

        public String toString() {

            return Integer.toString(getOffset());

        }

        PosRec rec;

    }

    /**

     * Used to hold a reference to a Position that is being reset as the

     * result of removing from the content.

     */

    final class UndoPosRef {

        UndoPosRef(PosRec rec) {

            this.rec = rec;

            this.undoLocation = rec.offset;

        }

        /**

         * Resets the location of the Position to the offset when the

         * receiver was instantiated.

         */

        protected void resetLocation() {

            rec.offset = undoLocation;

        }

        /** Location to reset to when resetLocatino is invoked. */

        protected int undoLocation;

        /** Position to reset offset. */

        protected PosRec rec;

    }

    /**

     * UnoableEdit created for inserts.

     */

    class InsertUndo extends AbstractUndoableEdit {

        protected InsertUndo(int offset, int length) {

            super();

            this.offset = offset;

            this.length = length;

        }

        public void undo() throws CannotUndoException {

            super.undo();

            try {

                synchronized(StringContent.this) {

                    // Get the Positions in the range being removed.

                    if(marks != null)

                        posRefs = getPositionsInRange(null, offset, length);

                    string = getString(offset, length);

                    remove(offset, length);

                }

            } catch (BadLocationException bl) {

              throw new CannotUndoException();

            }

        }

        public void redo() throws CannotRedoException {

            super.redo();

            try {

                synchronized(StringContent.this) {

                    insertString(offset, string);

                    string = null;

                    // Update the Positions that were in the range removed.

                    if(posRefs != null) {

                        updateUndoPositions(posRefs);

                        posRefs = null;

                    }

              }

            } catch (BadLocationException bl) {

              throw new CannotRedoException();

            }

        }

        // Where the string goes.

        protected int offset;

        // Length of the string.

        protected int length;

        // The string that was inserted. To cut down on space needed this

        // will only be valid after an undo.

        protected String string;

        // An array of instances of UndoPosRef for the Positions in the

        // range that was removed, valid after undo.

        protected Vector posRefs;

    }

    /**

     * UndoableEdit created for removes.

     */

    class RemoveUndo extends AbstractUndoableEdit {

        protected RemoveUndo(int offset, String string) {

            super();

            this.offset = offset;

            this.string = string;

            this.length = string.length();

            if(marks != null)

                posRefs = getPositionsInRange(null, offset, length);

        }

        public void undo() throws CannotUndoException {

            super.undo();

            try {

                synchronized(StringContent.this) {

                    insertString(offset, string);

                    // Update the Positions that were in the range removed.

                    if(posRefs != null) {

                        updateUndoPositions(posRefs);

                        posRefs = null;

                    }

                    string = null;

                }

            } catch (BadLocationException bl) {

              throw new CannotUndoException();

            }

        }

        public void redo() throws CannotRedoException {

            super.redo();

            try {

                synchronized(StringContent.this) {

                    string = getString(offset, length);

                    // Get the Positions in the range being removed.

                    if(marks != null)

                        posRefs = getPositionsInRange(null, offset, length);

                    remove(offset, length);

                }

            } catch (BadLocationException bl) {

              throw new CannotRedoException();

            }

        }

        // Where the string goes.

        protected int offset;

        // Length of the string.

        protected int length;

        // The string that was inserted. This will be null after an undo.

        protected String string;

        // An array of instances of UndoPosRef for the Positions in the

        // range that was removed, valid before undo.

        protected Vector posRefs;

    }

}