package eu.cqse.check.framework.util.abap;

import java.util.Arrays;
import java.util.EnumSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;

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

import eu.cqse.check.framework.core.CheckException;
import eu.cqse.check.framework.core.ICheckContext;
import eu.cqse.check.framework.core.phase.ECodeViewOption;
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.framework.EShallowEntityType;
import eu.cqse.check.framework.shallowparser.framework.ShallowEntity;
import eu.cqse.check.framework.shallowparser.framework.ShallowEntityTraversalUtils;
import eu.cqse.check.framework.typetracker.ITypeResolution;
import eu.cqse.check.framework.typetracker.ScopedTypeLookup;
import eu.cqse.check.framework.util.LanguageFeatureParser;

/**
 * Utility methods for checks analyzing ABAP code.
 */
public abstract class AbapCheckUtils {

        /** Value of return code SY-SUBRC which indicates no error */
        public static final int SY_SUBRC_NO_ERROR = 0;

        /** A list of token types which can include a variable name. **/
        public static final Set<ETokenType> TOKEN_TYPES_POTENTIALLY_CONTAINING_VARIABLE_NAMES = CollectionUtils
                        .unionSet(ETokenType.IDENTIFIERS, ETokenType.KEYWORDS);

        /** A list of entity types representing events. */
        public static final Set<String> EVENT_TYPES = CollectionUtils.asHashSet(SubTypeNames.AT_LINE_SELECTION,
                        SubTypeNames.PF_EVENT, SubTypeNames.AT_SELECTION_SCREEN, SubTypeNames.AT_USER_COMMAND,
                        SubTypeNames.END_OF_PAGE, SubTypeNames.END_OF_SELECTION, SubTypeNames.INITIALIZATION,
                        SubTypeNames.LOAD_OF_PROGRAM, SubTypeNames.START_OF_SELECTION, SubTypeNames.TOP_OF_PAGE,
                        SubTypeNames.GET_LATE, SubTypeNames.GET, SubTypeNames.TOP_OF_PAGE_DURING_LINE_SELECTION);

        /**
         * Tokens that identify when to filter out an INCLUDE statements. We only want
         * to find statements of type <code>INCLUDE foobar</code> where foobar is
         * another ABAP source object, but not <code>INCLUDE TYPE foobar</code> or
         * <code>INCLUDE STRUCTURE foobar</code>. Since one may name his included source
         * object like an ABAP keyword, we need to have a blacklist approach here.
         */
        private static final Set<ETokenType> INCLUDE_FILTER_TYPES = EnumSet.of(ETokenType.STRUCTURE, ETokenType.TYPE);

        /**
         * All entity types whose children are in class scope.
         */
        public static final Set<String> PARENT_TYPES_OF_CLASS_SCOPE = CollectionUtils.asHashSet(
                        SubTypeNames.CLASS_DEFINITION, SubTypeNames.CLASS_IMPLEMENTATION, SubTypeNames.INTERFACE_DEFINITION);

        /**
         * All entity types whose children are in global scope.
         */
        public static final Set<String> PARENT_TYPES_OF_GLOBAL_SCOPE = CollectionUtils.unionSet(
                        CollectionUtils.asHashSet(SubTypeNames.REPORT, SubTypeNames.PROGRAM, SubTypeNames.DOCUMENT_ROOT),
                        EVENT_TYPES);

        /**
         * All entity types whose children are in local scope.
         *
         * @see #isEntityWithinLocalValidScope(ShallowEntity)
         */
        public static final Set<String> PARENT_TYPES_OF_LOCAL_VALID_SCOPE = CollectionUtils.asHashSet(
                        SubTypeNames.METHOD_DECLARATION, SubTypeNames.METHOD_IMPLEMENTATION, SubTypeNames.FORM,
                        SubTypeNames.MODULE_INPUT, SubTypeNames.MODULE_OUTPUT, SubTypeNames.FUNCTION);

        /**
         * Meta comment which is added by Teamsale Git importer as last source line to
         * indicate that an function module is RFC enabled.
         */
        public static final String META_COMMENT_IS_RFC_ENABLED = "*#$#* teamscale-meta[rfc-enabled] *#$#*";

        /**
         * Checks whether an entity is within the scope of a class.
         *
         * @param entity
         *            The entity to be checked.
         * @return Yes if passed entity is within class scope, false otherwise.
         */
        public static boolean isEntityWithinClassScope(ShallowEntity entity) {
                CCSMAssert.isNotNull(entity.getParent(), "Entity " + entity + " must have a parent.");
                String currSubtype = entity.getParent().getSubtype();
                return PARENT_TYPES_OF_CLASS_SCOPE.contains(currSubtype);
        }

        /**
         * Checks whether an entity is in global scope, i.e. is a child of a top entity.
         *
         * @param entity
         *            The entity to be checked.
         * @return Yes if passed entity is global, false otherwise.
         */

        public static boolean isEntityWithinGlobalScope(ShallowEntity entity) {
                CCSMAssert.isNotNull(entity.getParent(), "Entity " + entity + " must have a parent.");
                String currSubtype = entity.getParent().getSubtype();
                return PARENT_TYPES_OF_GLOBAL_SCOPE.contains(currSubtype);
        }

        /**
         * Checks whether an entity is within a valid, local scope. Valid local scopes
         * are if the parent of the entity is e.g. a method, a form or a function.
         * Invalid local scopes are if the parent is e.g. an IF statement.
         *
         * @param entity
         *            The entity to be checked.
         * @return true if passed entity is within local, valid scope, false otherwise.
         */
        public static boolean isEntityWithinLocalValidScope(ShallowEntity entity) {
                CCSMAssert.isNotNull(entity.getParent(), "Entity " + entity + " must have a parent.");
                String currSubtype = entity.getParent().getSubtype();
                return PARENT_TYPES_OF_LOCAL_VALID_SCOPE.contains(currSubtype);
        }

        /**
         * Disable check for inherited methods, since we cannot see their interface and
         * hence cannot judge whether tables are passed as parameters or refer to the
         * database.
         *
         * Also disable check for cases in which we cannot be sure we see all variables.
         * This is true if
         * <ul>
         * <li>we have INCLUDEs in the code</li>
         * <li>we are inside a program include</li>
         * <li>we are inside a function group include</li>
         * </ul>
         *
         * @param entity
         *            The entity to check. May be a database statement or a macro.
         * @param rootEntities
         *            The corresponding file's root entities.
         * @param uniformPath
         *            The uniformPath to that file.
         */
        public static boolean isIgnoredForDatabaseChecks(ShallowEntity entity, List<ShallowEntity> rootEntities,
                        String uniformPath) {
                if (uniformPath.contains("/FUGR/") || containsInclude(rootEntities)) {
                        return true;
                }
                if (uniformPath.contains("/PROG/") && !isReportOrProgram(rootEntities)) {
                        return true;
                }

                ShallowEntity method = getMethodAncestor(entity);
                if (method == null) {
                        return false;
                }

                switch (method.getSubtype()) {
                case SubTypeNames.METHOD_IMPLEMENTATION:
                        return LanguageFeatureParser.ABAP.getDeclarationTokensForMethod(rootEntities, method) == null;
                default:
                        return false;
                }
        }

        /**
         * Whether the given identifier is considered a variable (rather than e.g. a
         * database table) with regards to the current variable scope.
         *
         * @param identifier
         *            The identifier inside a statement to check for being a variable.
         * @param entity
         *            The entity containing the statement. This may e.g. be an SQL
         *            statement directly or a macro containing the statement.
         * @param typeResolution
         *            The type resolution. This typically comes directly from the check
         *            context.
         */
        public static boolean isVariable(String identifier, ShallowEntity entity, ITypeResolution typeResolution) {
                identifier = AbapLanguageFeatureParser.normalizeVariable(identifier);

                // Ignore parameters and local variables.
                ScopedTypeLookup currentTypeLookup = typeResolution.getTypeLookup(entity);
                if (currentTypeLookup.containsVariable(identifier)) {
                        return true;
                }

                // in case we are in a program or report, also check the type lookup of
                // the corresponding PROGRAM or REPORT entity, since that is actually
                // not a method, but the global scope.
                ScopedTypeLookup globalLookup = getGlobalLookup(entity, typeResolution);
                if (globalLookup != null && globalLookup.containsVariable(identifier)) {
                        return true;
                }

                // in case the identifier points to a field of a structure, only the structure
                // is the local variable. Therefore we also check the structure name. This also
                // works with meshes, since these are basically structures with table-type
                // fields.
                if (identifier.contains("-")) {
                        return isVariable(StringUtils.getFirstParts(identifier, 1, '-'), entity, typeResolution);
                }
                return false;
        }

        /**
         * Whether the given list of root entities belong to a REPORT or PROGRAM.
         */
        private static boolean isReportOrProgram(List<ShallowEntity> rootEntities) {
                return ShallowEntityTraversalUtils.listMethodsNonRecursive(rootEntities).stream()
                                .anyMatch(method -> (method.getSubtype().equals(SubTypeNames.REPORT)
                                                || method.getSubtype().equals(SubTypeNames.PROGRAM)));
        }

        /**
         * If the entity belongs to a report or program, returns the type lookup for the
         * REPORT or PROGRAM method scope, since this is actually the global scope.
         * Returns null otherwise.
         */
        private static ScopedTypeLookup getGlobalLookup(ShallowEntity entity, ITypeResolution typeResolution) {
                ShallowEntity method = getMethodAncestor(entity);
                if (method == null) {
                        return null;
                }
                return getReportOrProgram(method)
                                // get the fist child, so the type lookup's scope is the report.
                                .flatMap(r -> r.getChildren().stream().findFirst()).map(r -> typeResolution.getTypeLookup(r))
                                .orElse(null);
        }

        /**
         * Get the REPORT or PROGRAM sibling corresponding to the given method entity.
         */
        private static Optional<ShallowEntity> getReportOrProgram(ShallowEntity method) {
                if (method.getParent() == null) {
                        return Optional.empty();
                }
                return method.getParent().getChildrenOfType(EShallowEntityType.METHOD).stream()
                                .filter(child -> (child.getSubtype().equals(SubTypeNames.REPORT)
                                                || child.getSubtype().equals(SubTypeNames.PROGRAM)))
                                .findFirst();
        }

        /**
         * Checks whether the root entities contain an include.
         */
        private static boolean containsInclude(List<ShallowEntity> rootEntities) {
                List<ShallowEntity> includes = ShallowEntityTraversalUtils.selectEntities(rootEntities,
                                AbapCheckUtils::isInclude);
                return !includes.isEmpty();
        }

        /**
         * Searches for INCLUDE statements that are not INCLUDE TYPE or INCLUDE
         * STRUCTURE.
         */
        private static boolean isInclude(ShallowEntity entity) {
                if (entity.getType() != EShallowEntityType.STATEMENT || !entity.getSubtype().equals(SubTypeNames.INCLUDE)) {
                        return false;
                }
                List<IToken> tokens = entity.ownStartTokens();
                if (tokens.size() < 2 || INCLUDE_FILTER_TYPES.contains(tokens.get(1).getType())) {
                        return false;
                }
                return true;
        }

        /**
         * Returns the closest ancestor that is of type
         * {@link EShallowEntityType#METHOD}.
         */
        private static ShallowEntity getMethodAncestor(ShallowEntity entity) {
                while (entity != null) {
                        if (entity.getType() == EShallowEntityType.METHOD) {
                                return entity;
                        }
                        entity = entity.getParent();
                }
                return null;
        }

        /**
         * Checks if the given entity is a function call of a function with any of the
         * given names.
         */
        public static boolean isFunctionCallOfAny(ShallowEntity entity, String... functionNames) throws CheckException {
                Optional<FunctionCallInfo> functionCallInfo = LanguageFeatureParser.ABAP.getFunctionCallInfo(entity);
                if (!functionCallInfo.isPresent()) {
                        return false;
                }
                if (!Arrays.asList(functionNames).contains(functionCallInfo.get().getFunctionName())) {
                        return false;
                }
                return true;
        }

        /**
         * Gets the normalized text of the start tokens of a {@link ShallowEntity}
         * (typically for statement). Normalization is performed as follows:
         * <p>
         * 1) full comment lines (introduced with *) are removed
         * <p>
         * 2) mid-line comments (introduced with ") will be removed (unless a ' follows
         * the " since it is assumed that the " is within a String literal in that
         * case).
         * <p>
         * 3) white spaces before the closing . are removed
         * <p>
         * 4) all (sequences of) white spaces are replaced by a single space
         */
        public static String getNormalizedStartTokensText(ShallowEntity entity, ICheckContext context)
                        throws CheckException {
                List<IToken> tokens = entity.ownStartTokens();
                if (tokens.isEmpty()) {
                        return StringUtils.EMPTY_STRING;
                }
                String statementText = context.getTextContent(ECodeViewOption.ETextViewOption.FILTERED_CONTENT)
                                .substring(tokens.get(0).getOffset(), tokens.get(tokens.size() - 1).getEndOffset() + 1);
                return statementText.replaceAll("(?m)^\\*.*", StringUtils.EMPTY_STRING)
                                .replaceAll("\"[^']*?\\n", StringUtils.SPACE).trim().replaceAll("\\s+\\.$", ".")
                                .replaceAll("\\s+", StringUtils.SPACE);
        }

        /**
         * Checks if the given content, what is expected to be the unfiltered content,
         * contains the meta data comment for RFC enablement in the last line
         */
        public static boolean hasMetaCommentForRfcEnablement(String unfilteredContent) {
                List<String> lines = StringUtils.splitLinesAsList(unfilteredContent);
                return hasMetaCommentForRfcEnablement(lines);
        }

        /**
         * Checks if the given content lines contains the meta data comment for RFC
         * enablement in the last line
         */
        public static boolean hasMetaCommentForRfcEnablement(List<String> contentLines) {
                if (contentLines.size() < 1) {
                        return false;
                }
                return contentLines.get(contentLines.size() - 1).equals(META_COMMENT_IS_RFC_ENABLED);
        }
}