/*-------------------------------------------------------------------------+
|                                                                          |
| 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.shallowparser.util;

import static eu.cqse.check.framework.scanner.ETokenType.INTERFACE;
import static eu.cqse.check.framework.scanner.ETokenType.PRIVATE;
import static eu.cqse.check.framework.scanner.ETokenType.PUBLIC;
import static eu.cqse.check.framework.shallowparser.framework.EShallowEntityType.TYPE;

import java.util.EnumSet;
import java.util.List;
import java.util.function.Predicate;
import java.util.regex.Pattern;

import org.conqat.lib.commons.collections.CollectionUtils;
import org.conqat.lib.commons.collections.UnmodifiableList;
import org.conqat.lib.commons.enums.EnumUtils;
import org.conqat.lib.commons.string.StringUtils;

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.SubTypeNames;
import eu.cqse.check.framework.shallowparser.TokenStreamUtils;
import eu.cqse.check.framework.shallowparser.framework.EShallowEntityType;
import eu.cqse.check.framework.shallowparser.framework.ShallowEntity;
import eu.cqse.check.framework.shallowparser.framework.ShallowEntityTraversalUtils;

/**
 * Defines valid primitive expressions that can be used in the
 * {@link EntitySelectionExpressionParser}. Each expression is defined by a
 * public static method of same name. Methods found here must be parameterless
 * or accept a single string parameter and must return an {@link Predicate} over
 * {@link ShallowEntity}. To avoid clashes with Java keywords, an optional
 * prefix "select" may be used.
 * 
 * Note that the comments for the public methods describe not exactly the
 * function, but rather the returned predicate.
 */
public class EntitySelectionPredicates {

        /** The visibility modifiers in C++. */
        private static final EnumSet<ETokenType> CPP_VISIBILITY_MODIFIERS = EnumSet.of(ETokenType.PUBLIC, PRIVATE,
                        ETokenType.PROTECTED);

        /**
         * Selects entities in files with the given language. If the given language name
         * is invalid, no entities are matched.
         */
        public static Predicate<ShallowEntity> language(String languageName) {
                ELanguage language = EnumUtils.valueOfIgnoreCase(ELanguage.class, languageName);
                if (language == null) {
                        return entity -> false;
                }
                return entity -> getLanguage(entity) == language;
        }

        /** Selects all modules/namespaces. */
        public static Predicate<ShallowEntity> module() {
                return typePredicate(EShallowEntityType.MODULE);
        }

        /** Selects all types/classes. */
        public static Predicate<ShallowEntity> type() {
                return typePredicate(EShallowEntityType.TYPE).and(entity -> !entity.getSubtype().equals("typedef"));
        }

        /** Selects all methods/functions. */
        public static Predicate<ShallowEntity> method() {
                return entity -> entity.getType() == EShallowEntityType.METHOD
                                && (entity.getParent() == null || entity.getParent().getType() != EShallowEntityType.ATTRIBUTE);
        }

        /** Selects all shallow entities whose subtype is a declaration. */
        public static Predicate<ShallowEntity> declaration() {
                return entity -> {
                        if (entity.getSubtype().contains(SubTypeNames.DECLARATION)) {
                                return true;
                        }

                        // also consider inline methods in classes
                        if (ELanguage.CPP.equals(getLanguage(entity))) {
                                ShallowEntity parent = entity.getParent();
                                return parent != null && parent.getType() == EShallowEntityType.TYPE;
                        }
                        return false;
                };
        }

        /** Selects all shallow entities that are internal (C# keyword). */
        public static Predicate<ShallowEntity> internal() {
                return entity -> {
                        if (TokenStreamUtils.containsAny(entity.ownStartTokens(), ETokenType.INTERNAL)) {
                                return true;
                        }
                        ShallowEntity parent = entity.getParent();
                        return parent != null && TokenStreamUtils.containsAny(parent.ownStartTokens(), ETokenType.INTERNAL);
                };
        }

        /** Selects all attributes. */
        public static Predicate<ShallowEntity> attribute() {
                return typePredicate(EShallowEntityType.ATTRIBUTE);
        }

        /**
         * Selects all properties, defined attributes that have only method children.
         * More specific: ATTRIBUTE entities that have children and each child is a
         * METHOD entity. E.g., C# properties.
         */
        public static Predicate<ShallowEntity> property() {
                return entity -> {
                        if (entity.getType() != EShallowEntityType.ATTRIBUTE) {
                                return false;
                        }

                        for (ShallowEntity child : entity.getChildren()) {
                                if (child.getType() != EShallowEntityType.METHOD) {
                                        return false;
                                }
                        }
                        return !entity.getChildren().isEmpty();
                };
        }

        /** Selects all statements. */
        public static Predicate<ShallowEntity> statement() {
                return typePredicate(EShallowEntityType.STATEMENT);
        }

        /** Selects all meta information (defines, annotations, etc.). */
        public static Predicate<ShallowEntity> meta() {
                return typePredicate(EShallowEntityType.META);
        }

        /** Creates a predicate for checking the type of an entity. */
        private static Predicate<ShallowEntity> typePredicate(EShallowEntityType type) {
                return entity -> entity.getType() == type;
        }

        /**
         * Matches all public entities as well as methods inside interfaces, which are
         * considered public in most languages.
         */
        public static Predicate<ShallowEntity> selectPublic() {
                return (modifierPredicate(PUBLIC).or(EntitySelectionPredicates::isInterfaceMethod)
                                .or(EntitySelectionPredicates::isJavaScriptInterface))
                                                .and(EntitySelectionPredicates::isNotTypeScriptConstructor);
        }

        /**
         * Returns <code>true</code> if the given entity is is a JavaScript interface.
         * JavaScript has no modifiers, so all interfaces are public.
         */
        private static boolean isJavaScriptInterface(ShallowEntity entity) {
                return getLanguage(entity) == ELanguage.JAVASCRIPT && entity.getType() == EShallowEntityType.TYPE
                                && modifierPredicate(INTERFACE).test(entity);
        }

        /**
         * Returns <code>true</code> if the given entity is a method in an interface.
         */
        private static boolean isInterfaceMethod(ShallowEntity entity) {
                ShallowEntity parent = entity.getParent();
                return entity.getType() == EShallowEntityType.METHOD && parent != null && parent.getType() == TYPE
                                && modifierPredicate(INTERFACE).test(parent);
        }

        public static Predicate<ShallowEntity> isAbstract() {
                return modifierPredicate(ETokenType.ABSTRACT).or(EntitySelectionPredicates::isInterfaceMethod);
        }

        /** Matches all protected entities. */
        public static Predicate<ShallowEntity> selectProtected() {
                return modifierPredicate(ETokenType.PROTECTED).and(EntitySelectionPredicates::isNotTypeScriptConstructor);
        }

        /** Matches all entities marked with override. */
        public static Predicate<ShallowEntity> selectOverride() {
                return modifierPredicate(ETokenType.OVERRIDE);
        }

        /**
         * Matches all private entities (except the TypeScript constructor parameters).
         */
        public static Predicate<ShallowEntity> selectPrivate() {
                return modifierPredicate(PRIVATE).and(EntitySelectionPredicates::isNotTypeScriptConstructor);
        }

        /**
         * Checks that the entity is not a TypeScript constructor.
         */
        private static boolean isNotTypeScriptConstructor(ShallowEntity entity) {
                if (getLanguage(entity) == ELanguage.JAVASCRIPT) {
                        return !SubTypeNames.CONSTRUCTOR.equals(entity.getSubtype());
                }
                return true;
        }

        /** Matches all entities with default visibility. */
        public static Predicate<ShallowEntity> selectDefault() {
                return element -> {
                        if (getLanguage(element) == ELanguage.JAVASCRIPT) {
                                return isTypeScriptDefault(element);
                        }
                        return hasNoModifiers(element);
                };
        }

        /**
         * Checks that the given entity has no modifiers. The method checks for the
         * following modifiers: PUBLIC, PRIVATE and PROTECTED.
         */
        private static boolean hasNoModifiers(ShallowEntity element) {
                List<IToken> tokens = element.ownStartTokens();
                return !TokenStreamUtils.containsAny(tokens, 0, tokens.size(), ETokenType.PUBLIC, ETokenType.PROTECTED,
                                PRIVATE);
        }

        /**
         * Returns <code>true</code> if the given entity is a TypeScript attribute or
         * method that could be selected as 'DEFAULT' and has no explicit modifier (i.e
         * default visibility). These include:
         * <ol>
         * <li>Types</li>
         * <li>Constructors</li>
         * <li>All methods except lambda methods (since they will already be covered by
         * the check on their parent attributes)</li>
         * <li>Attributes</li>
         * </ol>
         */
        private static boolean isTypeScriptDefault(ShallowEntity entity) {
                if (getLanguage(entity) != ELanguage.JAVASCRIPT) {
                        return false;
                }

                // Special handling of constructors needed to support public attributes
                // / members, e.g.
                // constructor(public pos: Vector, lookAt: Vector) { ... }
                boolean isConstructor = entity.getType() == EShallowEntityType.METHOD
                                && SubTypeNames.CONSTRUCTOR.equals(entity.getSubtype());
                if (isConstructor) {
                        UnmodifiableList<IToken> tokens = entity.ownStartTokens();
                        if (!tokens.isEmpty() && tokens.get(0).getText().equals(SubTypeNames.CONSTRUCTOR)) {
                                return true;
                        }
                }

                if (!hasNoModifiers(entity)) {
                        return false;
                }

                // ignore lambdas
                if (entity.getType() == EShallowEntityType.METHOD && SubTypeNames.LAMBDA.equals(entity.getSubtype())) {
                        return false;
                }

                return entity.getType() == EShallowEntityType.TYPE || entity.getType() == EShallowEntityType.METHOD
                                || entity.getType() == EShallowEntityType.ATTRIBUTE;
        }

        /** Matches all final entities. */
        public static Predicate<ShallowEntity> selectFinal() {
                return modifierPredicate(ETokenType.FINAL);
        }

        /** Matches all static entities. */
        public static Predicate<ShallowEntity> selectStatic() {
                return modifierPredicate(ETokenType.STATIC);
        }

        /** Matches all export entities. */
        public static Predicate<ShallowEntity> export() {
                return modifierPredicate(ETokenType.EXPORT);
        }

        /** Returns a predicate that checks for existence of the given modifier. */
        private static Predicate<ShallowEntity> modifierPredicate(final ETokenType modifier) {
                return element -> {
                        if (TokenStreamUtils.firstTokenOfType(element.ownStartTokens(), modifier) != TokenStreamUtils.NOT_FOUND) {
                                return true;
                        }

                        if (ELanguage.CPP == getLanguage(element) && CPP_VISIBILITY_MODIFIERS.contains(modifier)) {
                                return hasCppVisibilityModifer(element, modifier);
                        }
                        return false;
                };
        }

        /**
         * Determines the language of the given entity or <code>null</code> if it cannot
         * be determined
         */
        private static ELanguage getLanguage(ShallowEntity entity) {
                return ShallowParsingUtils.getLanguage(entity);
        }

        /**
         * Determines the origin, i.e. the uniformPath, of the given entity or
         * <code>null</code> if it cannot be determined.
         */
        private static String getUniformPath(ShallowEntity entity) {
                UnmodifiableList<IToken> tokens = entity.includedTokens();
                if (tokens.isEmpty()) {
                        return null;
                }
                return CollectionUtils.getAny(tokens).getOriginId();
        }

        /**
         * Checks whether the given shallow entity is affected by the specified C++
         * visibility modifier by backwards searching the sibling shallow entities. The
         * given modifier must be one of public, protected, or private.
         */
        private static boolean hasCppVisibilityModifer(ShallowEntity entity, ETokenType modifier) {
                ShallowEntity parent = entity.getParent();
                if (parent == null) {
                        return false;
                }

                UnmodifiableList<ShallowEntity> siblings = parent.getChildren();
                for (int i = siblings.indexOf(entity) - 1; i >= 0; i--) {
                        ShallowEntity sibling = siblings.get(i);

                        if (isCppVisibilityModifier(sibling)) {
                                return TokenStreamUtils.containsAny(sibling.ownStartTokens(), modifier);
                        }
                }

                // no explicit modifier found -> assume default
                if (parent.getType() == EShallowEntityType.TYPE) {
                        if (SubTypeNames.STRUCT.equals(parent.getSubtype())) {
                                return ETokenType.PUBLIC.equals(modifier);
                        }
                        return PRIVATE.equals(modifier);
                }

                return false;
        }

        /** Returns whether the given entity is a C++ visibility modifier. */
        private static boolean isCppVisibilityModifier(ShallowEntity entity) {
                return entity.getType() == EShallowEntityType.META
                                && TokenStreamUtils.containsAny(entity.ownStartTokens(), CPP_VISIBILITY_MODIFIERS);
        }

        /** Matches all primitive entities (i.e. those without children). */
        public static Predicate<ShallowEntity> primitive() {
                return entity -> entity.getChildren().isEmpty();
        }

        /** Matches entities by their subtype. */
        public static Predicate<ShallowEntity> subtype(final String subtype) {
                return entity -> subtype.equals(entity.getSubtype());
        }

        /**
         * Matches entities by their parent type's subtype (e.g. to select all members
         * of interfaces).
         */
        public static Predicate<ShallowEntity> typeSubtype(String subtype) {
                return entity -> {
                        ShallowEntity parent = entity.getParent();
                        return parent != null && type().test(parent) && parent.getSubtype().equals(subtype);
                };
        }

        /**
         * Matches entities whose parent is an exported type.
         */
        public static Predicate<ShallowEntity> typeExported() {
                return entity -> {
                        ShallowEntity parent = entity.getParent();
                        return parent != null && type().test(parent) && export().test(parent);
                };
        }

        /** Matches entities by their name. */
        public static Predicate<ShallowEntity> name(String name) {
                return entity -> name.equals(entity.getName());
        }

        /** Matches entities by their name using regular expression. */
        public static Predicate<ShallowEntity> nameRegex(String regex) {
                Pattern pattern = Pattern.compile(regex);
                // name is null for e.g. lambdas and anonymous types
                return entity -> entity.getName() != null && pattern.matcher(entity.getName()).matches();
        }

        /** Matches entities by their file name */
        public static Predicate<ShallowEntity> fileRegex(String regex) {
                Pattern pattern = Pattern.compile(regex);
                return entity -> {
                        String uniformPath = getUniformPath(entity);
                        if (uniformPath == null) {
                                return false;
                        }
                        return pattern.matcher(uniformPath).matches();
                };
        }

        /**
         * Matches all entities that are annotated with an annotation of given name
         * (excluding the '@' sign).
         */
        public static Predicate<ShallowEntity> annotated(String annotationName) {
                final String normalizedAnnotationName = StringUtils.stripPrefix(annotationName, "@");
                return entity -> {
                        ShallowEntity parent = entity.getParent();
                        if (parent == null) {
                                return false;
                        }

                        // Special handling needed for JavaScript, since annotations are
                        // detected as decorators.
                        if (getLanguage(entity) == ELanguage.JAVASCRIPT) {
                                return hasAnnotation(annotationName, entity, parent.getChildren(), SubTypeNames.DECORATOR);
                        }

                        return hasAnnotation(normalizedAnnotationName, entity, parent.getChildren(), SubTypeNames.ANNOTATION);
                };
        }

        /**
         * Checks if the entity is annotated with the specified annotation. Traverses
         * the siblings before the entity in the children list, as more than one
         * annotation might exist.
         */
        private static boolean hasAnnotation(final String annotationName, ShallowEntity entity,
                        List<ShallowEntity> children, String subTypeNameToCheck) {

                int index = children.indexOf(entity);
                index -= 1;
                while (index >= 0 && children.get(index).getType() == EShallowEntityType.META) {
                        ShallowEntity metaEntity = children.get(index);
                        if (subTypeNameToCheck.equals(metaEntity.getSubtype())
                                        && annotationName.equalsIgnoreCase(metaEntity.getName())) {
                                return true;
                        }
                        index -= 1;
                }
                return false;
        }

        /**
         * Matches simple getters, i.e. methods starting with "get" or "is" and with at
         * most one contained statement.
         */
        public static Predicate<ShallowEntity> simpleGetter() {
                return (simpleMethod("get").or(simpleMethod("is"))).and(isAbstract().negate());
        }

        /**
         * Matches simple setters, i.e. methods starting with "set" and with at most one
         * contained statement.
         */
        public static Predicate<ShallowEntity> simpleSetter() {
                return simpleMethod("set").and(isAbstract().negate());
        }

        /**
         * Matches simple setters, i.e. methods starting with "set" (case insensitive)
         * and with at most one contained statement.
         */
        public static Predicate<ShallowEntity> simpleSetterCaseInsensitive() {
                return simpleMethodCaseInsensitive("set").and(isAbstract().negate());
        }

        /**
         * Matches simple getters, i.e. methods starting with "get" or "is" (case
         * insensitive) and with at most one contained statement.
         */
        public static Predicate<ShallowEntity> simpleGetterCaseInsensitive() {
                return (simpleMethodCaseInsensitive("get").or(simpleMethodCaseInsensitive("is"))).and(isAbstract().negate());
        }

        /**
         * Matches getter in CSharp generated by the automatic property generation
         * feature. These are recognized by the entity subtype '(empty) get'
         */
        public static Predicate<ShallowEntity> simpleCSharpGetter() {
                return entity -> {
                        boolean isSimpleMethod = entity.getType() == EShallowEntityType.METHOD && getStatementCount(entity) <= 1;
                        return isSimpleMethod && StringUtils.equalsOneOf(entity.getSubtype().toLowerCase(), SubTypeNames.GET,
                                        SubTypeNames.EMPTY_GET);
                };
        }

        /**
         * Matches setter in CSharp generated by the automatic property generation
         * feature. These are recognized by the entity subtype '(empty) set'
         */
        public static Predicate<ShallowEntity> simpleCSharpSetter() {
                return entity -> {
                        boolean isSimpleMethod = entity.getType() == EShallowEntityType.METHOD && getStatementCount(entity) <= 1;
                        return isSimpleMethod && StringUtils.equalsOneOf(entity.getSubtype().toLowerCase(), SubTypeNames.SET,
                                        SubTypeNames.EMPTY_SET);
                };
        }

        /**
         * Matches simple methods with the given prefix. A method is simple, if it
         * contains as most one statement.
         */
        public static Predicate<ShallowEntity> simpleMethod(String namePrefix) {
                return entity -> {
                        boolean isSimpleMethod = entity.getType() == EShallowEntityType.METHOD && getStatementCount(entity) <= 1;
                        return isSimpleMethod && (entity.getName() != null) && entity.getName().startsWith(namePrefix);
                };
        }

        /**
         * Matches simple methods with the given prefix (case insensitive). A method is
         * simple, if it contains as most one statement.
         */
        public static Predicate<ShallowEntity> simpleMethodCaseInsensitive(String namePrefix) {
                return entity -> {
                        boolean isSimpleMethod = entity.getType() == EShallowEntityType.METHOD && getStatementCount(entity) <= 1;
                        return isSimpleMethod && (entity.getName() != null)
                                        && entity.getName().toLowerCase().startsWith(namePrefix.toLowerCase());
                };
        }

        /**
         * Returns the number of statements contained as children of the entity.
         */
        private static int getStatementCount(ShallowEntity entity) {
                return ShallowEntityTraversalUtils.listEntitiesOfType(entity.getChildren(), EShallowEntityType.STATEMENT)
                                .size();
        }
}