/*

 * 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.ClassTree;

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.TypeParameterTree;

import com.sun.source.tree.VariableTree;

import com.sun.source.util.SourcePositions;

import com.sun.source.util.TreePath;

import com.sun.source.util.TreePathScanner;

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

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.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.EnumSet;

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.TypeParameterElement;

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.JavaFileManager.Location;

import javax.tools.StandardLocation;

import static jdk.jshell.Util.REPL_DOESNOTMATTER_CLASS_NAME;

import static jdk.jshell.SourceCodeAnalysis.Completeness.DEFINITELY_INCOMPLETE;

import static jdk.jshell.TreeDissector.printType;

/**

 * 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);

        if (mcm.endsWithOpenComment()) {

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

            return new CompletionInfoImpl(DEFINITELY_INCOMPLETE, null, srcInput + '\n');

        }

        String cleared = mcm.cleared();

        String trimmedInput = Util.trimEnd(cleared);

        if (trimmedInput.isEmpty()) {

            // Just comment or empty

            return new CompletionInfoImpl(Completeness.EMPTY, 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 CompletionInfoImpl(status, 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 CompletionInfoImpl(status, 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 CompletionInfoImpl(status, compileSource, "");

            case DEFINITELY_INCOMPLETE:

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

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

            case CONSIDERED_INCOMPLETE:

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

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

            case EMPTY:

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

                return new CompletionInfoImpl(status, srcInput, "");

            case UNKNOWN:

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

                return new CompletionInfoImpl(status, 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 CLASS:

            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 CLASS: {

                    Predicate<Element> accept = accessibility.and(IS_TYPE);

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

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

                    break;

                }

                case BLOCK:

                case EMPTY_STATEMENT:

                case ERRONEOUS: {

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

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

                    if (isClass(tp)) {

                        ClassTree clazz = (ClassTree) tp.getParentPath().getLeaf();

                        if (clazz.getExtendsClause() == tp.getLeaf()) {

                            accept = accept.and(IS_TYPE);

                            smartFilter = smartFilter.and(el -> el.getKind() == ElementKind.CLASS);

                        } else {

                            Predicate<Element> f = smartFilterFromList(at, tp, clazz.getImplementsClause(), tp.getLeaf());

                            if (f != null) {

                                accept = accept.and(IS_TYPE);

                                smartFilter = f.and(el -> el.getKind() == ElementKind.INTERFACE);

                            }

                        }

                    } else if (isTypeParameter(tp)) {

                        TypeParameterTree tpt = (TypeParameterTree) tp.getParentPath().getLeaf();

                        Predicate<Element> f = smartFilterFromList(at, tp, tpt.getBounds(), tp.getLeaf());

                        if (f != null) {

                            accept = accept.and(IS_TYPE);

                            smartFilter = f;

                            if (!tpt.getBounds().isEmpty() && tpt.getBounds().get(0) != tp.getLeaf()) {

                                smartFilter = smartFilter.and(el -> el.getKind() == ElementKind.INTERFACE);

                            }

                        }

                    } else if (isVariable(tp)) {

                        VariableTree var = (VariableTree) tp.getParentPath().getLeaf();

                        if (var.getType() == tp.getLeaf()) {

                            accept = accept.and(IS_TYPE);

                        }

                    }

                    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 static final Set<Kind> CLASS_KINDS = EnumSet.of(

            Kind.ANNOTATION_TYPE, Kind.CLASS, Kind.ENUM, Kind.INTERFACE

    );

    private Predicate<Element> smartFilterFromList(AnalyzeTask at, TreePath base, Collection<? extends Tree> types, Tree current) {

        Set<Element> existingEls = new HashSet<>();

        for (Tree type : types) {

            if (type == current) {

                return el -> !existingEls.contains(el);

            }

            existingEls.add(at.trees().getElement(new TreePath(base, type)));

        }

        return null;

    }

    @Override

    public SnippetWrapper wrapper(Snippet snippet) {

        return new SnippetWrapper() {

            @Override

            public String source() {

                return snippet.source();

            }

            @Override

            public String wrapped() {

                return snippet.outerWrap().wrapped();

            }

            @Override

            public String fullClassName() {

                return snippet.classFullName();

            }

            @Override

            public Snippet.Kind kind() {

                return snippet.kind() == Snippet.Kind.ERRONEOUS

                        ? ((ErroneousSnippet) snippet).probableKind()

                        : snippet.kind();

            }

            @Override

            public int sourceToWrappedPosition(int pos) {

                return snippet.outerWrap().snippetIndexToWrapIndex(pos);

            }

            @Override

            public int wrappedToSourcePosition(int pos) {

                return snippet.outerWrap().wrapIndexToSnippetIndex(pos);

            }

        };

    }

    @Override

    public List<SnippetWrapper> wrappers(String input) {

        return proc.eval.sourceToSnippetsWithWrappers(input).stream()

                .map(sn -> wrapper(sn))

                .collect(toList());

    }

    @Override