/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _DECAF_LANG_ABSTRACTSTRINGBUILDER_H_
#define _DECAF_LANG_ABSTRACTSTRINGBUILDER_H_

#include <decaf/util/Config.h>
#include <decaf/lang/String.h>

#include <decaf/internal/util/concurrent/SynchronizableImpl.h>

namespace decaf {
namespace lang {

    class AbstractStringBuilderImpl;

    /**
     * A modifiable sequence of characters for use in creating and modifying Strings.
     * This class is intended as a base class for StringBuffer and StringBuilder.
     *
     * @see StringBuffer
     * @see StringBuilder
     *
     * @since 1.0
     */
    class DECAF_API AbstractStringBuilder : public decaf::internal::util::concurrent::SynchronizableImpl {
    protected:

        static const int INITIAL_CAPACITY;

    private:

        AbstractStringBuilderImpl* impl;

    public:

        AbstractStringBuilder();

        AbstractStringBuilder(int capacity);

        AbstractStringBuilder(const String& source);

        AbstractStringBuilder(const std::string& source);

        AbstractStringBuilder(const CharSequence* source);

        virtual ~AbstractStringBuilder();

    public:

        /**
         * Returns the current capacity. The capacity indicates the amount of space available in
         * the internal character buffer, when the number of characters inserted exceeds the current
         * capacity the internal buffer is reallocated and old contents copied to the new buffer.
         *
         * @return the current capacity value.
         */
        virtual int capacity() const;

        /**
         * Returns the character at the given index.
         *
         * @param index
         *      The index in this buffer where the character to return is located.
         *
         * @throws IndexOutOfBoundsException if index < 0 or index >= length().
         */
        virtual char charAt(int index) const;

        /**
         * Ensures that the capacity is at least equal to the specified min value. If
         * the current capacity is less than the given value, then this buffer backing this
         * instance will be reallocated and the old contents copied into the new buffer. The
         * new capacity is set to either the given value or twice the old capacity + 2
         * depending on which is larger.
         *
         * If the minimumCapacity argument is negative this method does nothing.
         *
         * @param minCapacity
         *      The minimum capacity to ensure exists in this buffer.
         */
        virtual void ensureCapacity(int minCapacity);

        /**
         * Copies characters from this character buffer into the given character array.
         *
         * @param start
         *      The index in this buffer to start the copy from
         * @param end
         *      The index in this buffer where the copy ends.
         * @param dest
         *      The destination character array where the values are copied.
         * @param destSize
         *      The size of the destination array.
         * @param destStart
         *      The index in the destination array to start the copy at.
         *
         * @throws NullPointerException if the dst pointer is NULL
         * @throws IndexOutOfBoundsException if:
         *      start or end is negative
         *      dstSize or dstStart is negative
         *      start is greater than end
         *      dstStart is greater than dstSize
         *      dstStart + (end - start) is greater than the dstSize
         */
        virtual void getChars(int start, int end, char* dst, int dstSize, int dstStart) const;

        /**
         * Search for the index within this string of the first occurrence of the specified substring.
         *
         * @param value
         *      The String to locate within this string buffer.
         *
         * @return the index of the specified substring within this string buffer or -1 if not found.
         */
        virtual int indexOf(const String& value) const;

        /**
         * Search for the index within this string of the first occurrence of the specified substring
         * starting at the given position and moving towards the end of this String.
         *
         * @param value
         *      The String to locate within this string buffer.
         * @param start
         *      The index to start the search from.
         *
         * @return the index of the specified substring within this string buffer or -1 if not found.
         */
        virtual int indexOf(const String& value, int start) const;

        /**
         * Search for the last index within this string where the given substring can be found.
         *
         * @param value
         *      The String to locate within this string buffer.
         *
         * @return the last index of the specified substring within this string buffer or -1
         *          if not found.
         */
        virtual int lastIndexOf(const String& value) const;

        /**
         * Search for the last index within this string where the given substring can be found
         * starting from the specified index and moving towards the beginning of the string.
         *
         * @param value
         *      The String to locate within this string buffer.
         * @param start
         *      The index to start the search from.
         *
         * @return the last index of the specified substring within this string buffer or -1
         *          if not found.
         */
        virtual int lastIndexOf(const String& value, int start) const;

        /**
         * Returns the current length of the String that has been built.
         *
         * @return the current number of characters that have been inserted.
         */
        virtual int length() const;

        /**
         * Sets the length of this character buffer. The backing buffer is changed to a new
         * character buffer whose length is specified by the argument.  Each character in the
         * old buffer is copied into the new buffer up to the given length value.  If the new
         * length is greater than the old buffer length then the additional character are all
         * set to '\0'.
         *
         * @param length
         *      The new length to give this character buffer
         *
         * @throws IndexOutOfBoundsException if length is less than zero.
         */
        virtual void setLength(int length);

        /**
         * Sets the character at the specified index to the new char value given.
         *
         * @param index
         *      The index of the character to modify.
         * @param value
         *      The new char value to assign at the given index.
         *
         * @throws IndexOutOfBoundsException if index is negative or greater than length().
         */
        virtual void setCharAt(int index, char value);

        /**
         * Returns a new String that contains a subset of the characters currently contained
         * in this character buffer. The substring starts at the specified index and extends
         * to the end of this character buffer.
         *
         * @param start
         *      The starting index of the substring to create.
         *
         * @return a new String that is a subset of this character buffer.
         *
         * @throws StringIndexOutOfBoundsException
         *      if start is less than zero, or greater than the length of this buffer.
         */
        virtual String substring(int start) const;

        /**
         * Returns a new String that contains a subset of the characters currently contained
         * in this character buffer. The substring starts at the specified index and extends
         * to the given end index.
         *
         * @param start
         *      The starting index of the substring to create. (inclusive)
         * @param end
         *      The ending index of the substring to create. (exclusive)
         *
         * @return a new String that is a subset of this character buffer.
         *
         * @throws StringIndexOutOfBoundsException
         *      if start or end is less than zero, or end is greater than the length of this buffer
         *      or start is greater than end.
         */
        virtual String substring(int start, int end) const;

        /**
         * Creates and returns a new CharSequence object that is a subset of the characters
         * contained in this character buffer.  This method behaves the same as the two parameter
         * substring method except that it returns a pointer value instead of a String, this
         * allows for subclasses to implement CharSequence.
         *
         * @param start
         *      The starting index of the substring to create. (inclusive)
         * @param end
         *      The ending index of the substring to create. (exclusive)
         *
         * @return a new CharSequence pointer that is a subset of this character buffer.
         *
         * @throws StringIndexOutOfBoundsException
         *      if start or end is less than zero, or end is greater than the length of this buffer
         *      or start is greater than end.
         */
        virtual CharSequence* subSequence(int start, int end) const;

        /**
         * Returns a String that represents the contents of this buffer.  Any changes
         * made to this buffer after calling this method will not be reflected in the
         * String value that is returned.
         */
        virtual String toString() const;

        /**
         * Attempts to reduce storage used for the character sequence. If the buffer
         * is larger than necessary to hold its current sequence of characters, then
         * it may be resized to become more space efficient. Calling this method may,
         * but is not required to, affect the value returned by a subsequent call to
         * the capacity() method.
         */
        virtual void trimToSize();

    protected:

        /**
         * Appends the string "null" to the current character buffer.
         */
        void doAppendNull();

        /**
         * Appends the given char to this buffer.
         *
         * @param value
         *      The char value to be appended into this buffer.
         */
        void doAppend(const char value);

        /**
         * Appends the given C string to this buffer.
         *
         * @param value
         *      The C string value to be appended into this buffer.
         *
         * @throws NullPointerException if the pointer is NULL.
         */
        void doAppend(const char* value);

        /**
         * Appends the given C string to this buffer starting at the given offset and
         * ending after the length number of characters has been appended.
         *
         * @param value
         *      The C string value to be appended into this buffer.
         * @param offset
         *      The starting position into the C string array.
         * @param length
         *      The number of characters to copy from the given array.
         *
         * @throws NullPointerException if the pointer is NULL.
         * @throws IndexOutOfBoundsException if offset or length is negative or the value of
         *         offset + length is greater than the strings length.
         */
        void doAppend(const char* value, int offset, int length);

        /**
         * Appends the given CharSequence to this buffer.
         *
         * @param value
         *      The CharSequence value to be appended into this buffer.
         *
         * @throws NullPointerException if the pointer is NULL.
         */
        void doAppend(const CharSequence* value);

        /**
         * Appends the given CharSequence to this buffer starting at the given offset and
         * ending after the length number of characters has been appended.
         *
         * @param value
         *      The CharSequence value to be appended into this buffer.
         * @param offset
         *      The starting position into the CharSequence.
         * @param length
         *      The number of characters to copy from the given CharSequence.
         *
         * @throws NullPointerException if the pointer is NULL.
         * @throws IndexOutOfBoundsException if offset or length is negative or the value of
         *         offset + length is greater than the strings length.
         */
        void doAppend(const CharSequence* value, int offset, int length);

        /**
         * Append the given std::string to this buffer.
         *
         * @param value
         *      The String instance to append into this buffer.
         */
        void doAppend(const std::string& value);

        /**
         * Append the given String to this buffer.
         *
         * @param value
         *      The String instance to append into this buffer.
         */
        void doAppend(const String& value);

        /**
         * Append the given AbstractStringBuilder to this buffer.
         *
         * @param value
         *      The String instance to append into this buffer.
         */
        void doAppend(const AbstractStringBuilder& value);

        /**
         * Delete the characters in the range start - end.
         *
         * @param start
         *      The starting index of the delete operation
         * @param end
         *      The ending index of the delete operation (exclusive).
         */
        void doDeleteRange(int start, int end);

        /**
         * Deletes the character at the given index from this buffer.
         *
         * @param index
         *      The index of the character to delete.
         */
        void doDeleteCharAt(int index);

        /**
         * Inserts a single char value at the given index
         *
         * @param index
         *      The index to insert the char at
         * @param value
         *      The char value to insert.
         */
        void doInsert(int index, char value);

        /**
         * Inserts a C string value at the given index.
         *
         * @param index
         *      The index to insert the C string at
         * @param value
         *      The char value to insert.
         */
        void doInsert(int index, const char* value);

        /**
         * Inserts a String value at the given index.
         *
         * @param index
         *      The index to insert the String at
         * @param value
         *      The char value to insert.
         */
        void doInsert(int index, const String& value);

        /**
         * Inserts a std::string value at the given index.
         *
         * @param index
         *      The index to insert the std::string at
         * @param value
         *      The char value to insert.
         */
        void doInsert(int index, const std::string& value);

        /**
         * Inserts the given C string at the given index in this buffer starting at the
         * given offset and ending after the length number of characters has been appended.
         *
         * @param index
         *      The index in this buffer to start inserting the C string.
         * @param value
         *      The C string value to be appended into this buffer.
         * @param offset
         *      The starting position into the C string array.
         * @param length
         *      The number of characters to copy from the given array.
         *
         * @throws NullPointerException if the pointer is NULL.
         * @throws IndexOutOfBoundsException if index, offset or length is negative or the value
         *         of offset + length is greater than the strings length.
         */
        void doInsert(int index, const char* value, int offset, int length);

        /**
         * Inserts the given CharSequence at the given index in this buffer.
         *
         * @param index
         *      The index in this buffer to start inserting the CharSequence.
         * @param value
         *      The CharSequence value to be appended into this buffer.
         *
         * @throws NullPointerException if the pointer is NULL.
         * @throws IndexOutOfBoundsException if index is negative or greater than length().
         */
        void doInsert(int index, const CharSequence* value);

        /**
         * Inserts the given CharSequence at the given index in this buffer starting at the
         * given index and ending at the specified end index.
         *
         * If the CharSequence pointer is NULL the string "null" is inserted.
         *
         * @param index
         *      The index in this buffer to start inserting the CharSequence.
         * @param value
         *      The CharSequence value to be appended into this buffer.
         * @param start
         *      The starting index into the CharSequence.
         * @param end
         *      The end index in the CharSequence to be inserted into this Buffer.
         *
         * @throws IndexOutOfBoundsException if index, start or end is negative or the value
         *         of start < end or the end index is greater than the sequence length.
         */
        void doInsert(int index, const CharSequence* value, int start, int end);

        /**
         * Replace some number of characters in this Buffer with the value given.
         *
         * The characters replaced start at the given index and end at the given end value
         * (exclusive).  If the replacement string value is longer the internal buffer is
         * lengthened to accommodate the new value.
         *
         * @param start
         *      The starting index to replace in the buffer (inclusive).
         * @param end
         *      The ending index of the replacement operation (exclusive).
         * @param value
         *      The new string value to replace the older value.
         *
         * @throws IndexOutOfBoundsException if start is negative, greater than end or greater than length().
         */
        void doReplace(int start, int end, const String& value);

        /**
         * Reverses the characters contained in this character buffer.
         */
        void doReverse();

    };

}}

#endif /* _DECAF_LANG_ABSTRACTSTRINGBUILDER_H_ */