/*

 * Copyright (c) 1999, 2015, 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 java.util.regex;

import java.util.ConcurrentModificationException;

import java.util.Iterator;

import java.util.NoSuchElementException;

import java.util.Objects;

import java.util.Spliterator;

import java.util.Spliterators;

import java.util.function.Consumer;

import java.util.function.Function;

import java.util.stream.Stream;

import java.util.stream.StreamSupport;

/**

 * An engine that performs match operations on a {@linkplain java.lang.CharSequence

 * character sequence} by interpreting a {@link Pattern}.

 *

 * <p> A matcher is created from a pattern by invoking the pattern's {@link

 * Pattern#matcher matcher} method.  Once created, a matcher can be used to

 * perform three different kinds of match operations:

 *

 * <ul>

 *

 *   <li><p> The {@link #matches matches} method attempts to match the entire

 *   input sequence against the pattern.  </p></li>

 *

 *   <li><p> The {@link #lookingAt lookingAt} method attempts to match the

 *   input sequence, starting at the beginning, against the pattern.  </p></li>

 *

 *   <li><p> The {@link #find find} method scans the input sequence looking for

 *   the next subsequence that matches the pattern.  </p></li>

 *

 * </ul>

 *

 * <p> Each of these methods returns a boolean indicating success or failure.

 * More information about a successful match can be obtained by querying the

 * state of the matcher.

 *

 * <p> A matcher finds matches in a subset of its input called the

 * <i>region</i>. By default, the region contains all of the matcher's input.

 * The region can be modified via the{@link #region region} method and queried

 * via the {@link #regionStart regionStart} and {@link #regionEnd regionEnd}

 * methods. The way that the region boundaries interact with some pattern

 * constructs can be changed. See {@link #useAnchoringBounds

 * useAnchoringBounds} and {@link #useTransparentBounds useTransparentBounds}

 * for more details.

 *

 * <p> This class also defines methods for replacing matched subsequences with

 * new strings whose contents can, if desired, be computed from the match

 * result.  The {@link #appendReplacement appendReplacement} and {@link

 * #appendTail appendTail} methods can be used in tandem in order to collect

 * the result into an existing string buffer or string builder. Alternatively,

 * the more convenient {@link #replaceAll replaceAll} method can be used to

 * create a string in which every matching subsequence in the input sequence

 * is replaced.

 *

 * <p> The explicit state of a matcher includes the start and end indices of

 * the most recent successful match.  It also includes the start and end

 * indices of the input subsequence captured by each <a

 * href="Pattern.html#cg">capturing group</a> in the pattern as well as a total

 * count of such subsequences.  As a convenience, methods are also provided for

 * returning these captured subsequences in string form.

 *

 * <p> The explicit state of a matcher is initially undefined; attempting to

 * query any part of it before a successful match will cause an {@link

 * IllegalStateException} to be thrown.  The explicit state of a matcher is

 * recomputed by every match operation.

 *

 * <p> The implicit state of a matcher includes the input character sequence as

 * well as the <i>append position</i>, which is initially zero and is updated

 * by the {@link #appendReplacement appendReplacement} method.

 *

 * <p> A matcher may be reset explicitly by invoking its {@link #reset()}

 * method or, if a new input sequence is desired, its {@link

 * #reset(java.lang.CharSequence) reset(CharSequence)} method.  Resetting a

 * matcher discards its explicit state information and sets the append position

 * to zero.

 *

 * <p> Instances of this class are not safe for use by multiple concurrent

 * threads. </p>

 *

 *

 * @author      Mike McCloskey

 * @author      Mark Reinhold

 * @author      JSR-51 Expert Group

 * @since       1.4

 * @spec        JSR-51

 */

public final class Matcher implements MatchResult {

    /**

     * The Pattern object that created this Matcher.

     */

    Pattern parentPattern;

    /**

     * The storage used by groups. They may contain invalid values if

     * a group was skipped during the matching.

     */

    int[] groups;

    /**

     * The range within the sequence that is to be matched. Anchors

     * will match at these "hard" boundaries. Changing the region

     * changes these values.

     */

    int from, to;

    /**

     * Lookbehind uses this value to ensure that the subexpression

     * match ends at the point where the lookbehind was encountered.

     */

    int lookbehindTo;

    /**

     * The original string being matched.

     */

    CharSequence text;

    /**

     * Matcher state used by the last node. NOANCHOR is used when a

     * match does not have to consume all of the input. ENDANCHOR is

     * the mode used for matching all the input.

     */

    static final int ENDANCHOR = 1;

    static final int NOANCHOR = 0;

    int acceptMode = NOANCHOR;

    /**

     * The range of string that last matched the pattern. If the last

     * match failed then first is -1; last initially holds 0 then it

     * holds the index of the end of the last match (which is where the

     * next search starts).

     */

    int first = -1, last = 0;

    /**

     * The end index of what matched in the last match operation.

     */

    int oldLast = -1;

    /**

     * The index of the last position appended in a substitution.

     */

    int lastAppendPosition = 0;

    /**

     * Storage used by nodes to tell what repetition they are on in

     * a pattern, and where groups begin. The nodes themselves are stateless,

     * so they rely on this field to hold state during a match.

     */

    int[] locals;

    /**

     * Boolean indicating whether or not more input could change

     * the results of the last match.

     *

     * If hitEnd is true, and a match was found, then more input

     * might cause a different match to be found.

     * If hitEnd is true and a match was not found, then more

     * input could cause a match to be found.

     * If hitEnd is false and a match was found, then more input

     * will not change the match.

     * If hitEnd is false and a match was not found, then more

     * input will not cause a match to be found.

     */

    boolean hitEnd;

    /**

     * Boolean indicating whether or not more input could change

     * a positive match into a negative one.

     *

     * If requireEnd is true, and a match was found, then more

     * input could cause the match to be lost.

     * If requireEnd is false and a match was found, then more

     * input might change the match but the match won't be lost.

     * If a match was not found, then requireEnd has no meaning.

     */

    boolean requireEnd;

    /**

     * If transparentBounds is true then the boundaries of this

     * matcher's region are transparent to lookahead, lookbehind,

     * and boundary matching constructs that try to see beyond them.

     */

    boolean transparentBounds = false;

    /**

     * If anchoringBounds is true then the boundaries of this

     * matcher's region match anchors such as ^ and $.

     */

    boolean anchoringBounds = true;

    /**

     * Number of times this matcher's state has been modified

     */

    int modCount;

    /**

     * No default constructor.

     */

    Matcher() {

    }

    /**

     * All matchers have the state used by Pattern during a match.

     */

    Matcher(Pattern parent, CharSequence text) {

        this.parentPattern = parent;

        this.text = text;

        // Allocate state storage

        int parentGroupCount = Math.max(parent.capturingGroupCount, 10);

        groups = new int[parentGroupCount * 2];

        locals = new int[parent.localCount];

        // Put fields into initial states

        reset();

    }

    /**

     * Returns the pattern that is interpreted by this matcher.

     *

     * @return  The pattern for which this matcher was created

     */

    public Pattern pattern() {

        return parentPattern;

    }

    /**

     * Returns the match state of this matcher as a {@link MatchResult}.

     * The result is unaffected by subsequent operations performed upon this

     * matcher.

     *

     * @return  a <code>MatchResult</code> with the state of this matcher

     * @since 1.5

     */

    public MatchResult toMatchResult() {

        return toMatchResult(text.toString());

    }

    private MatchResult toMatchResult(String text) {

        return new ImmutableMatchResult(this.first,

                                        this.last,

                                        groupCount(),

                                        this.groups.clone(),

                                        text);

    }

    private static class ImmutableMatchResult implements MatchResult {

        private final int first;

        private final int last;

        private final int[] groups;

        private final int groupCount;

        private final String text;

        ImmutableMatchResult(int first, int last, int groupCount,

                             int groups[], String text)

        {

            this.first = first;

            this.last = last;

            this.groupCount = groupCount;

            this.groups = groups;

            this.text = text;

        }

        @Override

        public int start() {

            return first;

        }

        @Override

        public int start(int group) {

            if (group < 0 || group > groupCount)

                throw new IndexOutOfBoundsException("No group " + group);

            return groups[group * 2];

        }

        @Override

        public int end() {

            return last;

        }

        @Override

        public int end(int group) {

            if (group < 0 || group > groupCount)

                throw new IndexOutOfBoundsException("No group " + group);

            return groups[group * 2 + 1];

        }

        @Override

        public int groupCount() {

            return groupCount;

        }

        @Override

        public String group() {

            return group(0);

        }

        @Override

        public String group(int group) {

            if (group < 0 || group > groupCount)

                throw new IndexOutOfBoundsException("No group " + group);

            if ((groups[group*2] == -1) || (groups[group*2+1] == -1))

                return null;

            return text.subSequence(groups[group * 2], groups[group * 2 + 1]).toString();

        }

    }

    /**

      * Changes the <tt>Pattern</tt> that this <tt>Matcher</tt> uses to

      * find matches with.

      *

      * <p> This method causes this matcher to lose information

      * about the groups of the last match that occurred. The

      * matcher's position in the input is maintained and its

      * last append position is unaffected.</p>

      *

      * @param  newPattern

      *         The new pattern used by this matcher

      * @return  This matcher

      * @throws  IllegalArgumentException

      *          If newPattern is <tt>null</tt>

      * @since 1.5

      */

    public Matcher usePattern(Pattern newPattern) {

        if (newPattern == null)

            throw new IllegalArgumentException("Pattern cannot be null");

        parentPattern = newPattern;

        // Reallocate state storage

        int parentGroupCount = Math.max(newPattern.capturingGroupCount, 10);

        groups = new int[parentGroupCount * 2];

        locals = new int[newPattern.localCount];

        for (int i = 0; i < groups.length; i++)

            groups[i] = -1;

        for (int i = 0; i < locals.length; i++)

            locals[i] = -1;

        modCount++;

        return this;

    }

    /**

     * Resets this matcher.

     *

     * <p> Resetting a matcher discards all of its explicit state information

     * and sets its append position to zero. The matcher's region is set to the

     * default region, which is its entire character sequence. The anchoring

     * and transparency of this matcher's region boundaries are unaffected.

     *

     * @return  This matcher

     */

    public Matcher reset() {

        first = -1;

        last = 0;

        oldLast = -1;

        for(int i=0; i<groups.length; i++)

            groups[i] = -1;

        for(int i=0; i<locals.length; i++)

            locals[i] = -1;

        lastAppendPosition = 0;

        from = 0;

        to = getTextLength();

        modCount++;

        return this;

    }

    /**

     * Resets this matcher with a new input sequence.

     *

     * <p> Resetting a matcher discards all of its explicit state information

     * and sets its append position to zero.  The matcher's region is set to

     * the default region, which is its entire character sequence.  The

     * anchoring and transparency of this matcher's region boundaries are

     * unaffected.

     *

     * @param  input

     *         The new input character sequence

     *

     * @return  This matcher

     */

    public Matcher reset(CharSequence input) {

        text = input;

        return reset();

    }

    /**

     * Returns the start index of the previous match.

     *

     * @return  The index of the first character matched

     *

     * @throws  IllegalStateException

     *          If no match has yet been attempted,

     *          or if the previous match operation failed

     */

    public int start() {

        if (first < 0)

            throw new IllegalStateException("No match available");

        return first;

    }

    /**

     * Returns the start index of the subsequence captured by the given group

     * during the previous match operation.

     *

     * <p> <a href="Pattern.html#cg">Capturing groups</a> are indexed from left

     * to right, starting at one.  Group zero denotes the entire pattern, so

     * the expression <i>m.</i><tt>start(0)</tt> is equivalent to

     * <i>m.</i><tt>start()</tt>.  </p>

     *

     * @param  group

     *         The index of a capturing group in this matcher's pattern

     *

     * @return  The index of the first character captured by the group,

     *          or <tt>-1</tt> if the match was successful but the group

     *          itself did not match anything

     *

     * @throws  IllegalStateException

     *          If no match has yet been attempted,

     *          or if the previous match operation failed

     *

     * @throws  IndexOutOfBoundsException

     *          If there is no capturing group in the pattern

     *          with the given index

     */

    public int start(int group) {

        if (first < 0)

            throw new IllegalStateException("No match available");

        if (group < 0 || group > groupCount())

            throw new IndexOutOfBoundsException("No group " + group);

        return groups[group * 2];

    }

    /**

     * Returns the start index of the subsequence captured by the given

     * <a href="Pattern.html#groupname">named-capturing group</a> during the

     * previous match operation.

     *

     * @param  name

     *         The name of a named-capturing group in this matcher's pattern

     *

     * @return  The index of the first character captured by the group,

     *          or {@code -1} if the match was successful but the group

     *          itself did not match anything

     *

     * @throws  IllegalStateException

     *          If no match has yet been attempted,

     *          or if the previous match operation failed

     *

     * @throws  IllegalArgumentException

     *          If there is no capturing group in the pattern

     *          with the given name

     * @since 1.8

     */

    public int start(String name) {

        return groups[getMatchedGroupIndex(name) * 2];

    }

    /**

     * Returns the offset after the last character matched.

     *

     * @return  The offset after the last character matched

     *

     * @throws  IllegalStateException

     *          If no match has yet been attempted,

     *          or if the previous match operation failed

     */

    public int end() {

        if (first < 0)

            throw new IllegalStateException("No match available");

        return last;

    }

    /**

     * Returns the offset after the last character of the subsequence

     * captured by the given group during the previous match operation.

     *

     * <p> <a href="Pattern.html#cg">Capturing groups</a> are indexed from left

     * to right, starting at one.  Group zero denotes the entire pattern, so

     * the expression <i>m.</i><tt>end(0)</tt> is equivalent to

     * <i>m.</i><tt>end()</tt>.  </p>

     *

     * @param  group

     *         The index of a capturing group in this matcher's pattern

     *

     * @return  The offset after the last character captured by the group,

     *          or <tt>-1</tt> if the match was successful

     *          but the group itself did not match anything

     *

     * @throws  IllegalStateException

     *          If no match has yet been attempted,