/*

 * Copyright (c) 2014, 2016, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package jdk.jshell;

import jdk.jshell.SourceCodeAnalysis.Completeness;

import com.sun.source.tree.AssignmentTree;

import com.sun.source.tree.CompilationUnitTree;

import com.sun.source.tree.ErroneousTree;

import com.sun.source.tree.ExpressionTree;

import com.sun.source.tree.IdentifierTree;

import com.sun.source.tree.ImportTree;

import com.sun.source.tree.MemberSelectTree;

import com.sun.source.tree.MethodInvocationTree;

import com.sun.source.tree.MethodTree;

import com.sun.source.tree.NewClassTree;

import com.sun.source.tree.Scope;

import com.sun.source.tree.Tree;

import com.sun.source.tree.Tree.Kind;

import com.sun.source.tree.VariableTree;

import com.sun.source.util.JavacTask;

import com.sun.source.util.SourcePositions;

import com.sun.source.util.TreePath;

import com.sun.source.util.TreePathScanner;

import com.sun.source.util.Trees;

import com.sun.tools.javac.api.JavacScope;

import com.sun.tools.javac.api.JavacTaskImpl;

import com.sun.tools.javac.code.Flags;

import com.sun.tools.javac.code.Symbol.CompletionFailure;

import com.sun.tools.javac.code.Symbol.VarSymbol;

import com.sun.tools.javac.code.Symtab;

import com.sun.tools.javac.code.Type;

import com.sun.tools.javac.code.Type.ClassType;

import com.sun.tools.javac.util.DefinedBy;

import com.sun.tools.javac.util.DefinedBy.Api;

import com.sun.tools.javac.util.Name;

import com.sun.tools.javac.util.Names;

import com.sun.tools.javac.util.Pair;

import jdk.jshell.CompletenessAnalyzer.CaInfo;

import jdk.jshell.TaskFactory.AnalyzeTask;

import jdk.jshell.TaskFactory.ParseTask;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import java.util.function.Predicate;

import javax.lang.model.element.Element;

import javax.lang.model.element.ElementKind;

import javax.lang.model.element.Modifier;

import javax.lang.model.element.TypeElement;

import javax.lang.model.type.DeclaredType;

import javax.lang.model.type.TypeMirror;

import static jdk.internal.jshell.debug.InternalDebugControl.DBG_COMPA;

import java.io.IOException;

import java.net.URI;

import java.nio.file.DirectoryStream;

import java.nio.file.FileSystem;

import java.nio.file.FileSystems;

import java.nio.file.FileVisitResult;

import java.nio.file.FileVisitor;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.nio.file.attribute.BasicFileAttributes;

import java.util.Arrays;

import java.util.Collection;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashSet;

import java.util.Map;

import java.util.NoSuchElementException;

import java.util.Set;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.function.Function;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import java.util.stream.Collectors;

import static java.util.stream.Collectors.collectingAndThen;

import static java.util.stream.Collectors.toCollection;

import static java.util.stream.Collectors.toList;

import static java.util.stream.Collectors.toSet;

import java.util.stream.Stream;

import java.util.stream.StreamSupport;

import javax.lang.model.SourceVersion;

import javax.lang.model.element.ExecutableElement;

import javax.lang.model.element.PackageElement;

import javax.lang.model.element.QualifiedNameable;

import javax.lang.model.element.VariableElement;

import javax.lang.model.type.ArrayType;

import javax.lang.model.type.ExecutableType;

import javax.lang.model.type.TypeKind;

import javax.lang.model.util.ElementFilter;

import javax.lang.model.util.Types;

import javax.tools.JavaCompiler;

import javax.tools.JavaFileManager.Location;

import javax.tools.JavaFileObject;

import javax.tools.StandardJavaFileManager;

import javax.tools.StandardLocation;

import javax.tools.ToolProvider;

import static jdk.jshell.Util.REPL_DOESNOTMATTER_CLASS_NAME;

/**

 * The concrete implementation of SourceCodeAnalysis.

 * @author Robert Field

 */

class SourceCodeAnalysisImpl extends SourceCodeAnalysis {

    private static final Map<Path, ClassIndex> PATH_TO_INDEX = new HashMap<>();

    private static final ExecutorService INDEXER = Executors.newFixedThreadPool(1, r -> {

        Thread t = new Thread(r);

        t.setDaemon(true);

        t.setUncaughtExceptionHandler((thread, ex) -> ex.printStackTrace());

        return t;

    });

    private final JShell proc;

    private final CompletenessAnalyzer ca;

    private final Map<Path, ClassIndex> currentIndexes = new HashMap<>();

    private int indexVersion;

    private int classpathVersion;

    private final Object suspendLock = new Object();

    private int suspend;

    SourceCodeAnalysisImpl(JShell proc) {

        this.proc = proc;

        this.ca = new CompletenessAnalyzer(proc);

        int cpVersion = classpathVersion = 1;

        INDEXER.submit(() -> refreshIndexes(cpVersion));

    }

    @Override

    public CompletionInfo analyzeCompletion(String srcInput) {

        MaskCommentsAndModifiers mcm = new MaskCommentsAndModifiers(srcInput, false);

        String cleared = mcm.cleared();

        String trimmedInput = Util.trimEnd(cleared);

        if (trimmedInput.isEmpty()) {

            // Just comment or empty

            return new CompletionInfo(Completeness.EMPTY, srcInput.length(), srcInput, "");

        }

        CaInfo info = ca.scan(trimmedInput);

        Completeness status = info.status;

        int unitEndPos = info.unitEndPos;

        if (unitEndPos > srcInput.length()) {

            unitEndPos = srcInput.length();

        }

        int nonCommentNonWhiteLength = trimmedInput.length();

        String src = srcInput.substring(0, unitEndPos);

        switch (status) {

            case COMPLETE:

                if (unitEndPos == nonCommentNonWhiteLength) {

                    // The unit is the whole non-coment/white input plus semicolon

                    String compileSource = src

                            + mcm.mask().substring(nonCommentNonWhiteLength);

                    proc.debug(DBG_COMPA, "Complete: %s\n", compileSource);

                    proc.debug(DBG_COMPA, "   nothing remains.\n");

                    return new CompletionInfo(status, unitEndPos, compileSource, "");

                } else {

                    String remain = srcInput.substring(unitEndPos);

                    proc.debug(DBG_COMPA, "Complete: %s\n", src);

                    proc.debug(DBG_COMPA, "          remaining: %s\n", remain);

                    return new CompletionInfo(status, unitEndPos, src, remain);

                }

            case COMPLETE_WITH_SEMI:

                // The unit is the whole non-coment/white input plus semicolon

                String compileSource = src

                        + ";"

                        + mcm.mask().substring(nonCommentNonWhiteLength);

                proc.debug(DBG_COMPA, "Complete with semi: %s\n", compileSource);

                proc.debug(DBG_COMPA, "   nothing remains.\n");

                return new CompletionInfo(status, unitEndPos, compileSource, "");

            case DEFINITELY_INCOMPLETE:

                proc.debug(DBG_COMPA, "Incomplete: %s\n", srcInput);

                return new CompletionInfo(status, unitEndPos, null, srcInput + '\n');

            case CONSIDERED_INCOMPLETE:

                proc.debug(DBG_COMPA, "Considered incomplete: %s\n", srcInput);

                return new CompletionInfo(status, unitEndPos, null, srcInput + '\n');

            case EMPTY:

                proc.debug(DBG_COMPA, "Detected empty: %s\n", srcInput);

                return new CompletionInfo(status, unitEndPos, srcInput, "");

            case UNKNOWN:

                proc.debug(DBG_COMPA, "Detected error: %s\n", srcInput);

                return new CompletionInfo(status, unitEndPos, srcInput, "");

        }

        throw new InternalError();

    }

    private Tree.Kind guessKind(String code) {

        ParseTask pt = proc.taskFactory.new ParseTask(code);

        List<? extends Tree> units = pt.units();

        if (units.isEmpty()) {

            return Tree.Kind.BLOCK;

        }

        Tree unitTree = units.get(0);

        proc.debug(DBG_COMPA, "Kind: %s -- %s\n", unitTree.getKind(), unitTree);

        return unitTree.getKind();

    }

    //TODO: would be better handled through a lexer:

    private final Pattern JAVA_IDENTIFIER = Pattern.compile("\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*");

    @Override

    public List<Suggestion> completionSuggestions(String code, int cursor, int[] anchor) {

        suspendIndexing();

        try {

            return completionSuggestionsImpl(code, cursor, anchor);

        } finally {

            resumeIndexing();

        }

    }

    private List<Suggestion> completionSuggestionsImpl(String code, int cursor, int[] anchor) {

        code = code.substring(0, cursor);

        Matcher m = JAVA_IDENTIFIER.matcher(code);

        String identifier = "";

        while (m.find()) {

            if (m.end() == code.length()) {

                cursor = m.start();

                code = code.substring(0, cursor);

                identifier = m.group();

            }

        }

        code = code.substring(0, cursor);

        if (code.trim().isEmpty()) { //TODO: comment handling

            code += ";";

        }

        OuterWrap codeWrap;

        switch (guessKind(code)) {

            case IMPORT:

                codeWrap = proc.outerMap.wrapImport(Wrap.simpleWrap(code + "any.any"), null);

                break;

            case METHOD:

                codeWrap = proc.outerMap.wrapInTrialClass(Wrap.classMemberWrap(code));

                break;

            default:

                codeWrap = proc.outerMap.wrapInTrialClass(Wrap.methodWrap(code));

                break;

        }

        String requiredPrefix = identifier;

        return computeSuggestions(codeWrap, cursor, anchor).stream()

                .filter(s -> s.continuation.startsWith(requiredPrefix) && !s.continuation.equals(REPL_DOESNOTMATTER_CLASS_NAME))

                .sorted(Comparator.comparing(s -> s.continuation))

                .collect(collectingAndThen(toList(), Collections::unmodifiableList));

    }

    private List<Suggestion> computeSuggestions(OuterWrap code, int cursor, int[] anchor) {

        AnalyzeTask at = proc.taskFactory.new AnalyzeTask(code);

        SourcePositions sp = at.trees().getSourcePositions();

        CompilationUnitTree topLevel = at.firstCuTree();

        List<Suggestion> result = new ArrayList<>();

        TreePath tp = pathFor(topLevel, sp, code.snippetIndexToWrapIndex(cursor));

        if (tp != null) {

            Scope scope = at.trees().getScope(tp);

            Predicate<Element> accessibility = createAccessibilityFilter(at, tp);

            Predicate<Element> smartTypeFilter;

            Predicate<Element> smartFilter;

            Iterable<TypeMirror> targetTypes = findTargetType(at, tp);

            if (targetTypes != null) {

                smartTypeFilter = el -> {

                    TypeMirror resultOf = resultTypeOf(el);

                    return Util.stream(targetTypes)

                            .anyMatch(targetType -> at.getTypes().isAssignable(resultOf, targetType));

                };

                smartFilter = IS_CLASS.negate()

                                      .and(IS_INTERFACE.negate())

                                      .and(IS_PACKAGE.negate())

                                      .and(smartTypeFilter);

            } else {

                smartFilter = TRUE;

                smartTypeFilter = TRUE;

            }

            switch (tp.getLeaf().getKind()) {

                case MEMBER_SELECT: {

                    MemberSelectTree mst = (MemberSelectTree)tp.getLeaf();

                    if (mst.getIdentifier().contentEquals("*"))

                        break;

                    TreePath exprPath = new TreePath(tp, mst.getExpression());

                    TypeMirror site = at.trees().getTypeMirror(exprPath);

                    boolean staticOnly = isStaticContext(at, exprPath);

                    ImportTree it = findImport(tp);

                    boolean isImport = it != null;

                    List<? extends Element> members = membersOf(at, site, staticOnly && !isImport);

                    Predicate<Element> filter = accessibility;

                    Function<Boolean, String> paren = DEFAULT_PAREN;

                    if (isNewClass(tp)) { // new xxx.|

                        Predicate<Element> constructorFilter = accessibility.and(IS_CONSTRUCTOR)

                            .and(el -> {

                                if (el.getEnclosingElement().getEnclosingElement().getKind() == ElementKind.CLASS) {

                                    return el.getEnclosingElement().getModifiers().contains(Modifier.STATIC);

                                }

                                return true;

                            });

                        addElements(membersOf(at, members), constructorFilter, smartFilter, result);

                        filter = filter.and(IS_PACKAGE);

                    } else if (isThrowsClause(tp)) {

                        staticOnly = true;

                        filter = filter.and(IS_PACKAGE.or(IS_CLASS).or(IS_INTERFACE));

                        smartFilter = IS_PACKAGE.negate().and(smartTypeFilter);

                    } else if (isImport) {

                        paren = NO_PAREN;

                        if (!it.isStatic()) {

                            filter = filter.and(IS_PACKAGE.or(IS_CLASS).or(IS_INTERFACE));

                        }

                    } else {

                        filter = filter.and(IS_CONSTRUCTOR.negate());

                    }

                    filter = filter.and(staticOnly ? STATIC_ONLY : INSTANCE_ONLY);

                    addElements(members, filter, smartFilter, paren, result);

                    break;

                }

                case IDENTIFIER:

                    if (isNewClass(tp)) {

                        Function<Element, Iterable<? extends Element>> listEnclosed =

                                el -> el.getKind() == ElementKind.PACKAGE ? Collections.singletonList(el)

                                                                          : el.getEnclosedElements();

                        Predicate<Element> filter = accessibility.and(IS_CONSTRUCTOR.or(IS_PACKAGE));

                        NewClassTree newClassTree = (NewClassTree)tp.getParentPath().getLeaf();

                        ExpressionTree enclosingExpression = newClassTree.getEnclosingExpression();

                        if (enclosingExpression != null) { // expr.new IDENT|

                            TypeMirror site = at.trees().getTypeMirror(new TreePath(tp, enclosingExpression));

                            filter = filter.and(el -> el.getEnclosingElement().getKind() == ElementKind.CLASS && !el.getEnclosingElement().getModifiers().contains(Modifier.STATIC));

                            addElements(membersOf(at, membersOf(at, site, false)), filter, smartFilter, result);

                        } else {

                            addScopeElements(at, scope, listEnclosed, filter, smartFilter, result);

                        }

                        break;

                    }

                    if (isThrowsClause(tp)) {

                        Predicate<Element> accept = accessibility.and(STATIC_ONLY)

                                .and(IS_PACKAGE.or(IS_CLASS).or(IS_INTERFACE));

                        addScopeElements(at, scope, IDENTITY, accept, IS_PACKAGE.negate().and(smartTypeFilter), result);

                        break;

                    }

                    ImportTree it = findImport(tp);

                    if (it != null) {

                        addElements(membersOf(at, at.getElements().getPackageElement("").asType(), false), it.isStatic() ? STATIC_ONLY.and(accessibility) : accessibility, smartFilter, result);

                    }

                    break;

                case ERRONEOUS:

                case EMPTY_STATEMENT: {

                    boolean staticOnly = ReplResolve.isStatic(((JavacScope)scope).getEnv());

                    Predicate<Element> accept = accessibility.and(staticOnly ? STATIC_ONLY : TRUE);

                    addScopeElements(at, scope, IDENTITY, accept, smartFilter, result);

                    Tree parent = tp.getParentPath().getLeaf();

                    switch (parent.getKind()) {

                        case VARIABLE:

                            accept = ((VariableTree)parent).getType() == tp.getLeaf() ?

                                    IS_VOID.negate() :

                                    TRUE;

                            break;

                        case PARAMETERIZED_TYPE: // TODO: JEP 218: Generics over Primitive Types

                        case TYPE_PARAMETER:

                        case CLASS:

                        case INTERFACE:

                        case ENUM:

                            accept = FALSE;

                            break;

                        default:

                            accept = TRUE;

                            break;

                    }

                    addElements(primitivesOrVoid(at), accept, smartFilter, result);

                    break;

                }

            }

        }

        anchor[0] = cursor;

        return result;

    }

    private boolean isStaticContext(AnalyzeTask at, TreePath path) {

        switch (path.getLeaf().getKind()) {

            case ARRAY_TYPE:

            case PRIMITIVE_TYPE:

                return true;

            default:

                Element selectEl = at.trees().getElement(path);

                return selectEl != null && (selectEl.getKind().isClass() || selectEl.getKind().isInterface() || selectEl.getKind() == ElementKind.TYPE_PARAMETER) && selectEl.asType().getKind() != TypeKind.ERROR;

        }

    }

    private TreePath pathFor(CompilationUnitTree topLevel, SourcePositions sp, int pos) {

        TreePath[] deepest = new TreePath[1];

        new TreePathScanner<Void, Void>() {

            @Override @DefinedBy(Api.COMPILER_TREE)

            public Void scan(Tree tree, Void p) {

                if (tree == null)

                    return null;

                long start = sp.getStartPosition(topLevel, tree);

                long end = sp.getEndPosition(topLevel, tree);

                long prevEnd = deepest[0] != null ? sp.getEndPosition(topLevel, deepest[0].getLeaf()) : -1;

                if (start <= pos && pos <= end &&

                    (start != end || prevEnd != end || deepest[0] == null ||

                     deepest[0].getParentPath().getLeaf() != getCurrentPath().getLeaf())) {

                    deepest[0] = new TreePath(getCurrentPath(), tree);

                    return super.scan(tree, p);

                }

                return null;

            }

            @Override @DefinedBy(Api.COMPILER_TREE)

            public Void visitErroneous(ErroneousTree node, Void p) {

                return scan(node.getErrorTrees(), null);

            }

        }.scan(topLevel, null);

        return deepest[0];

    }

    private boolean isNewClass(TreePath tp) {

        return tp.getParentPath() != null &&

               tp.getParentPath().getLeaf().getKind() == Kind.NEW_CLASS &&

               ((NewClassTree) tp.getParentPath().getLeaf()).getIdentifier() == tp.getLeaf();

    }

    private boolean isThrowsClause(TreePath tp) {

        Tree parent = tp.getParentPath().getLeaf();

        return parent.getKind() == Kind.METHOD &&

                ((MethodTree)parent).getThrows().contains(tp.getLeaf());

    }

    private ImportTree findImport(TreePath tp) {

        while (tp != null && tp.getLeaf().getKind() != Kind.IMPORT) {

            tp = tp.getParentPath();

        }

        return tp != null ? (ImportTree)tp.getLeaf() : null;

    }

    private Predicate<Element> createAccessibilityFilter(AnalyzeTask at, TreePath tp) {

        Scope scope = at.trees().getScope(tp);

        return el -> {

            switch (el.getKind()) {

                case ANNOTATION_TYPE: case CLASS: case ENUM: case INTERFACE:

                    return at.trees().isAccessible(scope, (TypeElement) el);

                case PACKAGE:

                case EXCEPTION_PARAMETER: case PARAMETER: case LOCAL_VARIABLE: case RESOURCE_VARIABLE:

                    return true;

                default:

                    TypeMirror type = el.getEnclosingElement().asType();

                    if (type.getKind() == TypeKind.DECLARED)

                        return at.trees().isAccessible(scope, el, (DeclaredType) type);

                    else

                        return true;

            }

        };

    }

    private final Predicate<Element> TRUE = el -> true;

    private final Predicate<Element> FALSE = TRUE.negate();

    private final Predicate<Element> IS_STATIC = el -> el.getModifiers().contains(Modifier.STATIC);

    private final Predicate<Element> IS_CONSTRUCTOR = el -> el.getKind() == ElementKind.CONSTRUCTOR;

    private final Predicate<Element> IS_METHOD = el -> el.getKind() == ElementKind.METHOD;

    private final Predicate<Element> IS_PACKAGE = el -> el.getKind() == ElementKind.PACKAGE;

    private final Predicate<Element> IS_CLASS = el -> el.getKind().isClass();

    private final Predicate<Element> IS_INTERFACE = el -> el.getKind().isInterface();

    private final Predicate<Element> IS_VOID = el -> el.asType().getKind() == TypeKind.VOID;

    private final Predicate<Element> STATIC_ONLY = el -> {

        ElementKind kind = el.getKind();

        Element encl = el.getEnclosingElement();

        ElementKind enclKind = encl != null ? encl.getKind() : ElementKind.OTHER;

        return IS_STATIC.or(IS_PACKAGE).or(IS_CLASS).or(IS_INTERFACE).test(el) || IS_PACKAGE.test(encl) ||

                (kind == ElementKind.TYPE_PARAMETER && !enclKind.isClass() && !enclKind.isInterface());

    };

    private final Predicate<Element> INSTANCE_ONLY = el -> {

        Element encl = el.getEnclosingElement();

        return IS_STATIC.or(IS_CLASS).or(IS_INTERFACE).negate().test(el) ||

                IS_PACKAGE.test(encl);

    };

    private final Function<Element, Iterable<? extends Element>> IDENTITY = el -> Collections.singletonList(el);

    private final Function<Boolean, String> DEFAULT_PAREN = hasParams -> hasParams ? "(" : "()";

    private final Function<Boolean, String> NO_PAREN = hasParams -> "";

    private void addElements(Iterable<? extends Element> elements, Predicate<Element> accept, Predicate<Element> smart, List<Suggestion> result) {

        addElements(elements, accept, smart, DEFAULT_PAREN, result);

    }

    private void addElements(Iterable<? extends Element> elements, Predicate<Element> accept, Predicate<Element> smart, Function<Boolean, String> paren, List<Suggestion> result) {