/*-----------------------------------------------------------------------+
 | 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.Collections;
import java.util.EnumSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.function.Function;

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

import eu.cqse.check.framework.preprocessor.c.IncludedTokens;
import eu.cqse.check.framework.scanner.ELanguage;
import eu.cqse.check.framework.scanner.ETokenType;
import eu.cqse.check.framework.scanner.IToken;
import eu.cqse.check.framework.shallowparser.TokenStreamUtils;

/**
 * Allows parsing a token stream from left to right. Parser can be reset to a
 * given position.
 */
public class TokenStreamParser {

        /** The complete original token stream. */
        private final List<IToken> tokens;

        /** The current position of the parser. */
        private int currentToken = 0;

        /**
         * Constructor.
         * 
         * @param tokens
         *            The tokens to parse.
         * @param filteredTokens
         *            A set of token types. All tokens of these types are filtered out
         *            before parsing, i.e. they are simply skipped.
         */
        public TokenStreamParser(List<IToken> tokens, Set<ETokenType> filteredTokens) {
                this(filter(tokens, filteredTokens));
        }

        /** Constructor. */
        public TokenStreamParser(List<IToken> tokens) {
                this.tokens = tokens;
        }

        /** Constructor. */
        public TokenStreamParser(List<IToken> tokens, int startPosition) {
                assertPositionAllowed(startPosition, tokens);
                this.tokens = tokens;
                this.currentToken = startPosition;

        }

        /**
         * Returns a filtered view of the given token list that does not contain any
         * tokens of the given types.
         */
        private static List<IToken> filter(List<IToken> tokens, Set<ETokenType> filteredTokens) {
                List<IToken> filtered = new ArrayList<>();
                for (IToken token : tokens) {
                        if (!filteredTokens.contains(token.getType())) {
                                filtered.add(token);
                        }
                }
                return filtered;
        }

        /**
         * Consumes all sequential tokens of the given types and returns the consumed
         * tokens.
         */
        public List<IToken> consumeAnyOf(Set<ETokenType> matchTypes) {
                int start = currentToken;
                while (isAnyOf(matchTypes)) {
                        currentToken++;
                }
                return tokens.subList(start, currentToken);
        }

        /**
         * Consumes one token of the given type and returns the token in an
         * {@link Optional} or <code>Optional.empty()</code> if the current token is not
         * of any of those types. This method only advances the parser if the current
         * token has one of the given types.
         */
        public Optional<IToken> consumeOneOrZeroOf(Set<ETokenType> types) {
                if (isAnyOf(types)) {
                        if (isDone()) {
                                return Optional.empty();
                        }
                        IToken token = tokens.get(currentToken);
                        currentToken++;
                        return Optional.of(token);
                }
                return Optional.empty();
        }

        /**
         * Consumes one token of the given type and returns the token in an
         * {@link Optional} or <code>Optional.empty()</code> if the current token is not
         * of any of those types. This method only advances the parser if the current
         * token has one of the given types.
         */
        public Optional<IToken> consumeOneOrZeroOf(ETokenType type) {
                return consumeOneOrZeroOf(EnumSet.of(type));
        }

        /**
         * Consumes all sequential tokens that are not of the given types and returns
         * their texts.
         */
        public List<String> consumeAnyExcept(Set<ETokenType> types) {
                List<String> texts = new ArrayList<>();
                while (!isAnyOf(types)) {
                        if (currentType() == null) {
                                break;
                        }
                        texts.add(currentText());
                        currentToken++;
                }
                return texts;
        }

        /**
         * Skips to the first occurrence of one of the given {@link ETokenType}s,
         * ignoring tokens nested in pairs of the given opening/closing
         * {@link ETokenType}s.
         * 
         * If no top-level occurrence of one of the search types is found, the parser
         * position is left unchanged and <code>false</code> is returned. If an
         * occurrence of one of the search types is found, the parser is left pointing
         * at it and <code>true</code> is returned.
         * 
         * @return <code>true</code> if the skipping succeeded and <code>false</code> if
         *         no top-level occurrence of the searchTypes could be found.
         */
        public boolean skipToFirstTopLevel(EnumSet<ETokenType> searchTypes, List<ETokenType> openingTypes,
                        List<ETokenType> closingTypes) {
                int firstTopLevelOccurrence = TokenStreamUtils.findFirstTopLevel(tokens, currentToken, searchTypes,
                                openingTypes, closingTypes);
                if (firstTopLevelOccurrence == TokenStreamUtils.NOT_FOUND) {
                        return false;
                }
                currentToken = firstTopLevelOccurrence;
                return true;
        }

        /**
         * Skips balanced braces as long as they only contain the allowed inner types.
         * Checks that the current token is of the opening type.
         * 
         * Skipping may be interrupted prematurely if unexpected tokens are encountered.
         * In this case, the parser is left pointing to the bad token.
         * 
         * @return Returns a Pair. The first element states whether this method
         *         succeeded (<code>true</code> if did not encounter a disallowed inner
         *         type). The second element is the list of consumed {@link IToken}s.
         */
        public Pair<Boolean, List<IToken>> skipBalanced(ETokenType openingType, ETokenType closingType,
                        Set<ETokenType> allowedInnerTypes) {
                CCSMAssert.isFalse(allowedInnerTypes.contains(openingType),
                                "The given inner token types contain the opening token type");
                CCSMAssert.isFalse(allowedInnerTypes.contains(closingType),
                                "The given inner token types contain the closing token type");
                if (currentType() != openingType) {
                        return Pair.createPair(false, Collections.emptyList());
                }
                ArrayList<IToken> consumedTokens = new ArrayList<>();
                consumeOneOrZeroOf(EnumSet.of(openingType)).ifPresent(consumedTokens::add);

                int openCount = 1;
                while (openCount > 0) {
                        consumedTokens.addAll(consumeAnyOf(allowedInnerTypes));
                        Optional<IToken> consumed;
                        if ((consumed = consumeOneOrZeroOf(EnumSet.of(openingType))).isPresent()) {
                                openCount++;
                                consumedTokens.add(consumed.get());
                        } else if ((consumed = consumeOneOrZeroOf(EnumSet.of(closingType))).isPresent()) {
                                openCount--;
                                consumedTokens.add(consumed.get());
                        } else {
                                return Pair.createPair(false, consumedTokens);
                        }
                }
                return Pair.createPair(true, consumedTokens);
        }

        /**
         * Syntactic sugar for skipping balanced LPAREN and RPAREN. Wraps
         * {@link #skipBalanced(ETokenType, ETokenType, Set)} with
         * {@link ETokenType#LPAREN} and {@link ETokenType#RPAREN}.
         */
        public Pair<Boolean, List<IToken>> skipBalancedParentheses() {
                return skipBalanced(ETokenType.LPAREN, ETokenType.RPAREN,
                                EnumSet.complementOf(EnumSet.of(ETokenType.LPAREN, ETokenType.RPAREN)));
        }

        /** Consumes tokens as long as they alternate between the two type sets. */
        public List<IToken> consumeAlternating(Set<ETokenType> typeSet1, Set<ETokenType> typeSet2) {
                List<IToken> list = new ArrayList<>();
                while (true) {
                        Optional<IToken> token1 = consumeOneOrZeroOf(typeSet1);
                        if (!token1.isPresent()) {
                                break;
                        }
                        list.add(token1.get());
                        Optional<IToken> token2 = consumeOneOrZeroOf(typeSet2);
                        if (!token2.isPresent()) {
                                break;
                        }
                        list.add(token2.get());
                }
                return list;
        }

        /**
         * Returns <code>true</code> if the current token has any of the given types.
         */
        public boolean isAnyOf(Set<ETokenType> types) {
                return types.contains(currentType());
        }

        /**
         * Returns <code>true</code> if all tokens have been consumed and parsing is
         * done.
         */
        public boolean isDone() {
                return currentToken >= tokens.size();
        }

        /**
         * Returns the text of the current token or <code>null</code> if all tokens have
         * been consumed.
         */
        public String currentText() {
                if (isDone()) {
                        return null;
                }
                return tokens.get(currentToken).getText();
        }

        /**
         * Returns the type of the current token or <code>null</code> if all tokens have
         * been consumed.
         */
        public ETokenType currentType() {
                if (isDone()) {
                        return null;
                }
                return tokens.get(currentToken).getType();
        }

        /** Returns whether the next tokens correspond to the given sequence */
        public boolean continuesWithSequence(ETokenType... tokenTypes) {
                return !isDone() && TokenStreamUtils.containsSequence(tokens, currentToken, tokens.size() - 1, tokenTypes);
        }

        /**
         * Skips to the beginning of the specified sequence or to the end if the
         * sequence was not found
         */
        public void skipToSequence(ETokenType... tokenTypes) {
                int index = TokenStreamUtils.firstTokenOfTypeSequence(tokens, currentToken, tokenTypes);
                if (index != TokenStreamUtils.NOT_FOUND) {
                        currentToken = index;
                } else {
                        skipToEnd();
                }
        }

        /**
         * Returns the number of tokens consumed so far.
         */
        public int getConsumedTokenCount() {
                return currentToken;
        }

        /**
         * Reset parser position to the given token index. Current position is
         * {@link #getConsumedTokenCount()}.
         */
        public void resetToPosition(int newPosition) {
                assertPositionAllowed(newPosition, tokens);
                currentToken = newPosition;
        }

        /**
         * Asserts that the given index is contained in the list.
         */
        private static void assertPositionAllowed(int index, List<IToken> tokens) throws AssertionError {
                CCSMAssert.isTrue(index >= 0 && index <= tokens.size(),
                                "The new position is out of range (position: " + index + " range: 0--" + (tokens.size() - 1));
        }

        /** {@inheritDoc} */
        @Override
        public String toString() {
                return "TokenStreamParser " + tokens.subList(currentToken, tokens.size());
        }

        /** @see #tokens */
        public List<IToken> getTokens() {
                return tokens;
        }

        /**
         * Tries to apply the given token consumer to this {@link TokenStreamParser}. If
         * the consumer returns {@link Optional#empty()}, resets the parser to the
         * current position and returns {@link Optional#empty()}. Otherwise, returns the
         * return value of the consumer.
         */
        public <T> Optional<T> tryConsume(Function<TokenStreamParser, Optional<T>> consumer) {
                int parserPositionBefore = getConsumedTokenCount();
                Optional<T> result = consumer.apply(this);
                if (!result.isPresent()) {
                        resetToPosition(parserPositionBefore);
                }
                return result;
        }

        /**
         * Returns the language of the given {@link IncludedTokens} (assuming all have
         * the same language).
         */
        public ELanguage getTokenLanguage() {
                return TokenStreamUtils.getLanguage(tokens);
        }

        /**
         * Skips any remaining tokens. The next call of {@link #isDone()} will return
         * <code>true</code>.
         */
        public void skipToEnd() {
                currentToken = tokens.size();
        }

        /** Returns the current token or null iff {@link #isDone()}. */
        public IToken currentToken() {
                if (isDone()) {
                        return null;
                }
                return tokens.get(currentToken);
        }

        /**
         * Returns whether the token before the current parsing position has the given
         * type.
         */
        public boolean previousTokenTypeIs(ETokenType type) {
                if (currentToken == 0) {
                        return false;
                }
                return tokens.get(currentToken - 1).getType() == type;
        }
}