/*-------------------------------------------------------------------------+
|                                                                          |
| Copyright 2005-2011 the ConQAT Project                                   |
|                                                                          |
| Licensed 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.                                           |
+-------------------------------------------------------------------------*/
package eu.cqse.check.framework.util.tokens;

import java.util.Collection;
import java.util.EnumSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;

import org.conqat.lib.commons.collections.Pair;
import org.conqat.lib.commons.string.StringUtils;

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

/**
 * Utility methods for {@link IToken}s.
 */
public class TokenUtils {

        /**
         * Set of token types that always have to be treated case-sensitive, e.g. String
         * literals.
         */
        public static final EnumSet<ETokenType> ALWAYS_CASE_SENSITIVE_TOKEN_TYPES = EnumSet.of(ETokenType.STRING_LITERAL,
                        ETokenType.CHARACTER_LITERAL, ETokenType.UNTERMINATED_STRING_LITERAL,
                        ETokenType.UNTERMINATED_CHARACTER_LITERAL);

        /**
         * Estimates the zero-based end line of the specified token by looking where the
         * provided next token begins. Note that this cannot check, if the provided next
         * token is really the next token, nor if there are blank lines between the two
         * tokens.
         * <p>
         * This method is more efficient than
         * {@link #calculateEndLineByCountingLines(IToken)}, but not as precise.
         * 
         * @param token
         *            the token whose end line should be calculated.
         * @param nextToken
         *            the lookahead token.
         * @return the end line of the specified first token.
         */
        public static int estimateEndLineByLookahead(IToken token, IToken nextToken) {
                int tokenEndLine = nextToken.getLineNumber() - 1;
                return Math.max(tokenEndLine, token.getLineNumber());
        }

        /**
         * Calculates the zero-based end line of the specified token by counting the
         * lines of the text contained within.
         * <p>
         * This method is less efficient than
         * {@link #estimateEndLineByLookahead(IToken, IToken)}, but always yields the
         * correct result.
         * 
         * @param token
         *            the token whose end line should be calculated.
         * @return the end line of the specified token.
         */
        public static int calculateEndLineByCountingLines(IToken token) {
                int tokenEndLine = token.getLineNumber() + StringUtils.countLines(token.getText()) - 1;
                return Math.max(tokenEndLine, token.getLineNumber());
        }

        /**
         * Checks if the given tokens are of equal type and have the equal text. The
         * method is <code>null</code>-safe.
         * 
         * @return <code>true</code> if both tokens are <code>null</code> or if both
         *         tokens are of the same {@link ETokenType} and have the same text,
         *         <code>false</code> otherwise.
         */
        public static boolean isEqualTypeAndText(IToken t1, IToken t2) {
                if (t1 == t2) {
                        return true;
                }
                if (t1 == null || t2 == null) {
                        return false;
                }
                return t1.getType() == t2.getType() && Objects.equals(t1.getText(), t2.getText());
        }

        /**
         * Returns the first matching pattern and the match or null if no pattern
         * matches.
         */
        public static Pair<TokenPattern, TokenPatternMatch> getMatchingPattern(Collection<TokenPattern> patterns,
                        List<IToken> tokens) {
                for (TokenPattern pattern : patterns) {
                        TokenPatternMatch match = pattern.findFirstMatch(tokens);
                        if (match != null) {
                                return new Pair<>(pattern, match);
                        }
                }
                return null;
        }

        /**
         * Returns true if a given token is a comment token.
         */
        public static boolean isCommentToken(IToken token) {
                return token.getType().getTokenClass() == ETokenClass.COMMENT;
        }

        /**
         * Creates a representation of the tokens that contains only the tokens
         * specified in the parameter. This method keeps the original line breaks.
         * 
         * @param coveredLines
         *            the method will only count lines that are not already in the given
         *            set. The set will afterwards contain all lines covered by the
         *            remaining tokens.
         */
        public static int getTokenLineCount(EnumSet<ETokenClass> tokenClassesToPreserve, List<IToken> tokens,
                        Set<Integer> coveredLines) {

                int count = 0;
                for (IToken token : tokens) {
                        if (!tokenClassesToPreserve.contains(token.getType().getTokenClass())) {
                                continue;
                        }

                        int startLine = token.getLineNumber();
                        int endLine = token.getLineNumber() + StringUtils.countLines(token.getText());
                        for (int line = startLine; line < endLine; line++) {
                                if (coveredLines.add(line)) {
                                        count += 1;
                                }
                        }
                }

                return count;
        }

}