/*-----------------------------------------------------------------------+
 | org.conqat.engine.index.incubator
 |                                                                       |
   $Id$
 |                                                                       |
 | Copyright (c)  2009-2013 CQSE GmbH                                 |
 +-----------------------------------------------------------------------*/
package eu.cqse.check.framework.util.tokens;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

import org.conqat.lib.commons.assertion.CCSMAssert;
import org.conqat.lib.commons.collections.CollectionUtils;

import eu.cqse.check.framework.scanner.ETokenType;
import eu.cqse.check.framework.scanner.ETokenType.ETokenClass;
import eu.cqse.check.framework.scanner.IToken;

/**
 * A pattern that can be applied like a regular expression to a token stream.
 *
 * This class is not fully redundant to TokenTypePattern for two reasons:
 * <ul>
 * <li>It allows matching nested structures, e.g. parentheses, with
 * {@link #skipNested(Object, Object, boolean)}
 * <li>It allows named capture groups, something which is not currently possible
 * with Java 7: http://bugs.java.com/bugdatabase/view_bug.do?bug_id=8013252
 * </ul>
 */
public class TokenPattern {
        /**
         * The parts of the pattern that are matched in sequence.
         */
        private final List<TokenPatternBase> submatchers = new ArrayList<>();

        /** {@inheritDoc} */
        @Override
        public String toString() {
                return "submatchers " + submatchers.toString();
        }

        /**
         * Matches the pattern at all positions in the given token stream and returns
         * the found matches. This also finds overlapping matches. Given the token
         * sequence <code>const int a</code> and pattern
         * <code>(KEYWORD)* IDENTIFIFER</code>, this method will return 3 matches
         * <code>const int a</code>, <code>int a</code> & <code>a</code>.
         */
        public List<TokenPatternMatch> findAll(List<IToken> tokens) {
                List<TokenPatternMatch> matches = new ArrayList<>();
                TokenStream stream = new TokenStream(tokens, 0);
                for (int i = 0; i < tokens.size(); i++) {
                        stream.setPosition(i);
                        TokenPatternMatch match = matchesLocally(stream);
                        if (match != null) {
                                matches.add(match);
                        }
                }
                return matches;
        }

        /**
         * Matches the pattern at all positions in the given token stream and returns
         * the first found match or <code>null</code> if no match happened.
         */
        public TokenPatternMatch findFirstMatch(List<IToken> tokens) {
                for (int i = 0; i < tokens.size(); i++) {
                        TokenStream stream = new TokenStream(tokens, i);
                        TokenPatternMatch match = matchesLocally(stream);
                        if (match != null) {
                                return match;
                        }
                }
                return null;
        }

        /**
         * Finds and returns non-overlapping matches in the tokens. Given the token
         * sequence <code>const int a</code> and pattern
         * <code>(KEYWORD)* IDENTIFIFER</code>, this method will return only one match
         * contrary to {@link #findAll} that will return 3 matches. The search starts at
         * beginning of token stream say point x. If a match is found say at position x
         * + 5, the next search starts just after the position of the previous
         * successful search (x + 6). If no match is found, the search continues from
         * position x + 1. This ensures no overlapping matches.
         */
        public List<TokenPatternMatch> findNonOverlappingMatches(List<IToken> tokens) {
                List<TokenPatternMatch> matches = new ArrayList<>();
                TokenStream stream = new TokenStream(tokens, 0);
                int i = 0;
                while (i < tokens.size()) {
                        TokenPatternMatch match = matchesLocally(stream);
                        if (match == null) {
                                i += 1;
                                stream.setPosition(i);
                                continue;
                        }

                        // Stream position advances any time we have a match
                        matches.add(match);
                        i = stream.getPosition();
                        if (stream.isExhausted()) {
                                break;
                        }
                }

                return matches;
        }

        /**
         * Matches the pattern at the start position of the given tokens. Returns the
         * found match or <code>null</code> if no match happened.
         */
        public TokenPatternMatch matchAtStartOf(List<IToken> tokens) {
                TokenStream stream = new TokenStream(tokens, 0);
                TokenPatternMatch match = matchesLocally(stream);
                return match;
        }

        /**
         * Matches the pattern at the start position of the token stream. Returns the
         * found match or <code>null</code> if no match happened. The stream's position
         * is preserved.
         */
        public TokenPatternMatch matchAtCurrentPosition(TokenStream stream) {
                int position = stream.getPosition();
                TokenPatternMatch match = matchesLocally(stream);
                stream.setPosition(position);
                return match;
        }

        /**
         * Returns <code>true</code> if the pattern matches at least once in the given
         * token stream.
         */
        public boolean matchesAnywhere(List<IToken> tokens) {
                return findFirstMatch(tokens) != null;
        }

        /**
         * Matches the pattern once at the current position of the given token stream
         * and records the results in the given match.
         *
         * @return A {@link TokenPatternMatch} if the pattern matched or
         *         <code>null</code> if the pattern did not match.
         */
        private TokenPatternMatch matchesLocally(TokenStream stream) {
                return new SequencePattern(CollectionUtils.toArray(submatchers, TokenPatternBase.class)).matchesLocally(stream);
        }

        /**
         * Specifies that the last added subpattern should be appended to the group with
         * the given index. The group index may be any integer number. Group indices are
         * not required to be ordered or continuous.
         */
        public TokenPattern group(int groupIndex) {
                CCSMAssert.isFalse(submatchers.isEmpty(),
                                "You must specify a pattern part before you can assign a group to it.");
                submatchers.get(submatchers.size() - 1).setGroupIndex(groupIndex);
                return this;
        }

        /**
         * Adds a new pattern part that consumes anything until it encounters one of the
         * given match terms. The stop token matching one of the given terms is also
         * consumed.
         *
         * A group applied to this pattern will only contain the stop token.
         *
         * @param matchTerms
         *            a list of match terms which must match in order. These may be
         *            instances of {@link ETokenType}, {@link ETokenClass}, or sets of
         *            them, as well as {@link TokenPattern}s.
         */
        public TokenPattern skipTo(Object... matchTerms) {
                TokenPatternBase[] matchers = convertMatchTerms(matchTerms);
                submatchers.add(new SkipPattern(matchers));
                submatchers.add(new AlternativePattern(matchers));
                return this;
        }

        /**
         * Adds a new pattern part that consumes nested structures.
         *
         * @param openTerm
         *            a match term that identifies the opening braces. May be an
         *            instance of {@link ETokenType}, {@link ETokenClass}, or a set of
         *            them, as well as an {@link TokenPattern}.
         * @param closeTerm
         *            a match term that identifies the closing braces. May be an
         *            instance of {@link ETokenType}, {@link ETokenClass}, or a set of
         *            them, as well as an {@link TokenPattern}.
         * @param optional
         *            if this is <code>false</code>, the nested structure must be
         *            present or the pattern will not match. If this is
         *            <code>true</code>, this pattern may return an empty match.
         */
        public TokenPattern skipNested(Object openTerm, Object closeTerm, boolean optional) {
                TokenPatternBase openMatcher = convertMatchTerm(openTerm);
                TokenPatternBase closeMatcher = convertMatchTerm(closeTerm);
                submatchers.add(new SkipNestedPattern(openMatcher, closeMatcher, optional));
                return this;
        }

        /**
         * Adds a new "repeated" pattern part that matches the given terms zero or more
         * times in the given order.
         *
         * @param matchTerms
         *            a list of match terms which must match in order. These may be
         *            instances of {@link ETokenType}, {@link ETokenClass}, or sets of
         *            them, as well as {@link TokenPattern}s.
         */
        public TokenPattern repeated(Object... matchTerms) {
                TokenPatternBase[] matchers = convertMatchTerms(matchTerms);
                submatchers.add(new RepeatedPattern(matchers));
                return this;
        }

        /**
         * Adds a new pattern part that matches the given sequence of terms exactly once
         * in the given order.
         *
         * @param matchTerms
         *            a list of match terms which must match in order. These may be
         *            instances of {@link ETokenType}, {@link ETokenClass}, or sets of
         *            them, as well as {@link TokenPattern}s.
         */
        public TokenPattern sequence(Object... matchTerms) {
                TokenPatternBase[] matchers = convertMatchTerms(matchTerms);
                submatchers.add(new SequencePattern(matchers));
                return this;
        }

        /**
         * Adds a new pattern part that matches the end of the token stream (i.e. there
         * are no more tokens to match).
         */
        public TokenPattern endOfStream() {
                submatchers.add(new ZeroLengthTokenPatternBase() {

                        @Override
                        public boolean conditionApplies(TokenStream stream) {
                                return stream.isExhausted();
                        }

                        /** {@inheritDoc} */
                        @Override
                        public String toString() {
                                return "ZeroLength is exhausted";
                        }
                });
                return this;
        }

        /**
         * Adds a new pattern part that matches the beginning of the token stream (i.e.
         * no tokens have been consumed so far).
         */
        public TokenPattern beginningOfStream() {
                submatchers.add(new ZeroLengthTokenPatternBase() {

                        @Override
                        public boolean conditionApplies(TokenStream stream) {
                                return stream.isAtBeginning();
                        }

                        /** {@inheritDoc} */
                        @Override
                        public String toString() {
                                return "ZeroLength at beginning";
                        }
                });
                return this;
        }

        /**
         * Adds a new pattern part that matches anything but the beginning of the token
         * stream (i.e. at least one token has been consumed so far).
         */
        public TokenPattern notAtBeginningOfStream() {
                submatchers.add(new ZeroLengthTokenPatternBase() {

                        @Override
                        public boolean conditionApplies(TokenStream stream) {
                                return !stream.isAtBeginning();
                        }

                        /** {@inheritDoc} */
                        @Override
                        public String toString() {
                                return "ZeroLength not at beginning";
                        }
                });
                return this;
        }

        /**
         * Adds a new pattern part that matches if the last matched token is not
         * followed by a token that matches the given term. This pattern part does not
         * consume any tokens.
         *
         * @param matchTerm
         *            May be an instance of {@link ETokenType}, {@link ETokenClass}, or
         *            a set of them, as well as a {@link TokenPattern}.
         */
        public TokenPattern notFollowedBy(Object matchTerm) {
                TokenPatternBase matcher = convertMatchTerm(matchTerm);
                submatchers.add(new NotFollowedByPattern(matcher));
                return this;
        }

        /**
         * Adds a new pattern part that matches if the last matched token is not
         * preceded by a token that matches the given term. This pattern part does not
         * consume any tokens.
         *
         * NOTE: passing a {@link TokenPattern} to this function will not result in an
         * exception, but it will not yield the intuitive result. The given pattern will
         * be matched against the token stream, starting with the token preceding the
         * current token. It is therefore discouraged to pass a {@link TokenPattern} to
         * this function as it makes understanding the pattern difficult.
         *
         * @param matchTerm
         *            May be an instance of {@link ETokenType}, {@link ETokenClass}, or
         *            a set of them, but usually not a {@link TokenPattern}.
         */
        public TokenPattern notPrecededBy(Object matchTerm) {
                TokenPatternBase matcher = convertMatchTerm(matchTerm);
                submatchers.add(new NotPrecededByPattern(matcher));
                return this;
        }

        /**
         * Adds a new alternative pattern part that tries the given match terms one
         * after the other and stops as soon as one of them matches.
         *
         * @param matchTerms
         *            a list of match terms which must match in order. These may be
         *            instances of {@link ETokenType}, {@link ETokenClass}, or sets of
         *            them, as well as {@link TokenPattern}s.
         */
        public TokenPattern alternative(Object... matchTerms) {
                TokenPatternBase[] matchers = convertMatchTerms(matchTerms);
                submatchers.add(new AlternativePattern(matchers));
                return this;
        }

        /**
         * Adds a new optional pattern part that matches the given terms zero times or
         * once in the given order.
         *
         * @param matchTerms
         *            a list of match terms which must match in order. These may be
         *            instances of {@link ETokenType}, {@link ETokenClass}, or sets of
         *            them, as well as {@link TokenPattern}s.
         */
        public TokenPattern optional(Object... matchTerms) {
                TokenPatternBase[] matchers = convertMatchTerms(matchTerms);
                submatchers.add(new OptionalPattern(matchers));
                return this;
        }

        /**
         * Adds a new pattern part that matches token text with specified regex.
         *
         * @param regex
         *            string to contain in token text.
         */
        public TokenPattern regex(String regex) {
                submatchers.add(new RegexPattern(regex));
                return this;
        }

        /** Converts the given match terms to {@link TokenPatternBase}s. */
        private static TokenPatternBase[] convertMatchTerms(Object[] matchTerms) {
                CCSMAssert.isFalse(matchTerms.length == 0, "You must provide at least one match term.");
                TokenPatternBase[] matchers = new TokenPatternBase[matchTerms.length];
                for (int i = 0; i < matchTerms.length; ++i) {
                        matchers[i] = convertMatchTerm(matchTerms[i]);
                }
                return matchers;
        }

        /** Converts a {@link TokenPattern} match term to a matcher. */
        private static TokenPatternBase convertMatchTerm(final TokenPattern matchTerm) {
                return new TokenPatternBase() {
                        @Override
                        protected TokenPatternMatch matchesLocally(TokenStream stream) {
                                TokenPattern pattern = matchTerm;
                                int beforePosition = stream.getPosition();
                                TokenPatternMatch match = pattern.matchesLocally(stream);
                                if (match == null) {
                                        stream.setPosition(beforePosition);
                                        return null;
                                }
                                return match;
                        }

                        /** {@inheritDoc} */
                        @Override
                        public String toString() {
                                return matchTerm.toString();
                        }
                };
        }

        /** Converts a {@link ETokenType} match term to a matcher. */
        private static TokenPatternBase convertMatchTerm(final ETokenType matchTerm) {
                return new SingleTokenPatternBase() {
                        @Override
                        public boolean matchesToken(IToken token) {
                                return token.getType() == matchTerm;
                        }

                        /** {@inheritDoc} */
                        @Override
                        public String toString() {
                                return matchTerm.toString();
                        }
                };
        }

        /** Converts a ETokenClass match term to a matcher. */
        private static TokenPatternBase convertMatchTerm(final ETokenClass matchTerm) {
                return new SingleTokenPatternBase() {
                        @Override
                        public boolean matchesToken(IToken token) {
                                return token.getType().getTokenClass() == matchTerm;
                        }

                        /** {@inheritDoc} */
                        @Override
                        public String toString() {
                                return matchTerm.toString();
                        }
                };
        }

        /** Converts a Set of match terms to a matcher. */
        private static TokenPatternBase convertMatchTerm(final Set<?> matchTerm) {
                final Set<?> set = matchTerm;
                return new SingleTokenPatternBase() {
                        @Override
                        public boolean matchesToken(IToken token) {
                                ETokenType type = token.getType();
                                return set.contains(type) || set.contains(type.getTokenClass());
                        }

                        /** {@inheritDoc} */
                        @Override
                        public String toString() {
                                return matchTerm.toString();
                        }
                };
        }

        /** Converts a match term to a matcher. */
        private static TokenPatternBase convertMatchTerm(final Object matchTerm) {
                if (matchTerm instanceof TokenPatternBase) {
                        return (TokenPatternBase) matchTerm;
                }
                if (matchTerm instanceof TokenPattern) {
                        return convertMatchTerm((TokenPattern) matchTerm);
                }
                if (matchTerm instanceof ETokenType) {
                        return convertMatchTerm((ETokenType) matchTerm);
                }
                if (matchTerm instanceof ETokenClass) {
                        return convertMatchTerm((ETokenClass) matchTerm);
                }
                if (matchTerm instanceof Set<?>) {
                        return convertMatchTerm((Set<?>) matchTerm);
                }
                throw new AssertionError("Unsupported match term of type " + matchTerm.getClass());
        }

        /**
         * Matches the given terms one or more times. Shorthand for
         * <code>.sequence(matchTerms).repeated(matchTerms)</code>
         */
        public TokenPattern repeatedAtLeastOnce(Object... matchTerms) {
                return sequence(matchTerms).repeated(matchTerms);
        }

        /**
         * Returns a new Token pattern that matches on tokens that have exactly the
         * given text.
         */
        public static TokenPatternBase text(String tokenText) {
                return new SingleTokenPatternBase() {
                        @Override
                        public boolean matchesToken(IToken token) {
                                return tokenText.equals(token.getText());
                        }

                        /** {@inheritDoc} */
                        @Override
                        public String toString() {
                                return tokenText;
                        }
                };
        }
}