/*

 * Copyright (c) 2014, 2019, 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 java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.List;

import java.util.Locale;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import java.util.stream.Collectors;

import javax.lang.model.element.Modifier;

import com.sun.source.tree.ArrayTypeTree;

import com.sun.source.tree.AssignmentTree;

import com.sun.source.tree.ClassTree;

import com.sun.source.tree.ExpressionStatementTree;

import com.sun.source.tree.ExpressionTree;

import com.sun.source.tree.IdentifierTree;

import com.sun.source.tree.MethodTree;

import com.sun.source.tree.ModifiersTree;

import com.sun.source.tree.NewClassTree;

import com.sun.source.tree.Tree;

import com.sun.source.tree.VariableTree;

import com.sun.tools.javac.tree.JCTree;

import com.sun.tools.javac.tree.Pretty;

import java.io.IOException;

import java.io.StringWriter;

import java.io.Writer;

import java.util.Arrays;

import java.util.LinkedHashSet;

import java.util.Set;

import jdk.jshell.ExpressionToTypeInfo.ExpressionInfo;

import jdk.jshell.ExpressionToTypeInfo.ExpressionInfo.AnonymousDescription;

import jdk.jshell.ExpressionToTypeInfo.ExpressionInfo.AnonymousDescription.VariableDesc;

import jdk.jshell.Key.ErroneousKey;

import jdk.jshell.Key.MethodKey;

import jdk.jshell.Key.TypeDeclKey;

import jdk.jshell.Snippet.Kind;

import jdk.jshell.Snippet.SubKind;

import jdk.jshell.TaskFactory.AnalyzeTask;

import jdk.jshell.TaskFactory.BaseTask;

import jdk.jshell.TaskFactory.ParseTask;

import jdk.jshell.Util.Pair;

import jdk.jshell.Wrap.CompoundWrap;

import jdk.jshell.Wrap.Range;

import jdk.jshell.Snippet.Status;

import jdk.jshell.spi.ExecutionControl.ClassBytecodes;

import jdk.jshell.spi.ExecutionControl.ClassInstallException;

import jdk.jshell.spi.ExecutionControl.EngineTerminationException;

import jdk.jshell.spi.ExecutionControl.InternalException;

import jdk.jshell.spi.ExecutionControl.NotImplementedException;

import jdk.jshell.spi.ExecutionControl.ResolutionException;

import jdk.jshell.spi.ExecutionControl.RunException;

import jdk.jshell.spi.ExecutionControl.UserException;

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

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

import static java.util.Collections.singletonList;

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

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

import static jdk.jshell.Util.DOIT_METHOD_NAME;

import static jdk.jshell.Util.PREFIX_PATTERN;

import static jdk.jshell.Util.expunge;

import static jdk.jshell.Snippet.SubKind.SINGLE_TYPE_IMPORT_SUBKIND;

import static jdk.jshell.Snippet.SubKind.SINGLE_STATIC_IMPORT_SUBKIND;

import static jdk.jshell.Snippet.SubKind.TYPE_IMPORT_ON_DEMAND_SUBKIND;

import static jdk.jshell.Snippet.SubKind.STATIC_IMPORT_ON_DEMAND_SUBKIND;

/**

 * The Evaluation Engine. Source internal analysis, wrapping control,

 * compilation, declaration. redefinition, replacement, and execution.

 *

 * @author Robert Field

 */

class Eval {

    private static final Pattern IMPORT_PATTERN = Pattern.compile("import\\p{javaWhitespace}+(?<static>static\\p{javaWhitespace}+)?(?<fullname>[\\p{L}\\p{N}_\\$\\.]+\\.(?<name>[\\p{L}\\p{N}_\\$]+|\\*))");

    private static final Pattern DEFAULT_PREFIX = Pattern.compile("\\p{javaWhitespace}*(default)\\p{javaWhitespace}+");

    // for uses that should not change state -- non-evaluations

    private boolean preserveState = false;

    private int varNumber = 0;

    /* The number of anonymous innerclasses seen so far. Used to generate unique

     * names of these classes.

     */

    private int anonCount = 0;

    private final JShell state;

    // The set of names of methods on Object

    private final Set<String> objectMethods = Arrays

            .stream(Object.class.getMethods())

            .map(m -> m.getName())

            .collect(toSet());

    Eval(JShell state) {

        this.state = state;

    }

    /**

     * Evaluates a snippet of source.

     *

     * @param userSource the source of the snippet

     * @return the list of primary and update events

     * @throws IllegalStateException

     */

    List<SnippetEvent> eval(String userSource) throws IllegalStateException {

        List<SnippetEvent> allEvents = new ArrayList<>();

        for (Snippet snip : sourceToSnippets(userSource)) {

            if (snip.kind() == Kind.ERRONEOUS) {

                state.maps.installSnippet(snip);

                allEvents.add(new SnippetEvent(

                        snip, Status.NONEXISTENT, Status.REJECTED,

                        false, null, null, null));

            } else {

                allEvents.addAll(declare(snip, snip.syntheticDiags()));

            }

        }

        return allEvents;

    }

    /**

     * Converts the user source of a snippet into a Snippet list -- Snippet will

     * have wrappers.

     *

     * @param userSource the source of the snippet

     * @return usually a singleton list of Snippet, but may be empty or multiple

     */

    List<Snippet> sourceToSnippetsWithWrappers(String userSource) {

        List<Snippet> snippets = sourceToSnippets(userSource);

        for (Snippet snip : snippets) {

            if (snip.outerWrap() == null) {

                snip.setOuterWrap(

                        (snip.kind() == Kind.IMPORT)

                                ? state.outerMap.wrapImport(snip.guts(), snip)

                                : state.outerMap.wrapInTrialClass(snip.guts())

                );

            }

        }

        return snippets;

    }

    /**

     * Converts the user source of a snippet into a Snippet object (or list of

     * objects in the case of: int x, y, z;).  Does not install the Snippets

     * or execute them.  Does not change any state.

     *

     * @param userSource the source of the snippet

     * @return usually a singleton list of Snippet, but may be empty or multiple

     */

    List<Snippet> toScratchSnippets(String userSource) {

        try {

            preserveState = true;

            return sourceToSnippets(userSource);

        } finally {

            preserveState = false;

        }

    }

    /**

     * Converts the user source of a snippet into a Snippet object (or list of

     * objects in the case of: int x, y, z;).  Does not install the Snippets

     * or execute them.

     *

     * @param userSource the source of the snippet

     * @return usually a singleton list of Snippet, but may be empty or multiple

     */

    private List<Snippet> sourceToSnippets(String userSource) {

        String compileSource = Util.trimEnd(new MaskCommentsAndModifiers(userSource, false).cleared());

        if (compileSource.length() == 0) {

            return Collections.emptyList();

        }

        return state.taskFactory.parse(compileSource, pt -> {

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

            if (units.isEmpty()) {

                return compileFailResult(pt, userSource, Kind.ERRONEOUS);

            }

            Tree unitTree = units.get(0);

            if (pt.getDiagnostics().hasOtherThanNotStatementErrors()) {

                Matcher matcher = DEFAULT_PREFIX.matcher(compileSource);

                DiagList dlist = matcher.lookingAt()

                        ? new DiagList(new ModifierDiagnostic(true,

                            state.messageFormat("jshell.diag.modifier.single.fatal", "'default'"),

                            matcher.start(1), matcher.end(1)))

                        : pt.getDiagnostics();

                return compileFailResult(dlist, userSource, kindOfTree(unitTree));

            }

            // Erase illegal/ignored modifiers

            String compileSourceInt = new MaskCommentsAndModifiers(compileSource, true).cleared();

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

            switch (unitTree.getKind()) {

                case IMPORT:

                    return processImport(userSource, compileSourceInt);

                case VARIABLE:

                    return processVariables(userSource, units, compileSourceInt, pt);

                case EXPRESSION_STATEMENT:

                    return processExpression(userSource, unitTree, compileSourceInt, pt);

                case CLASS:

                    return processClass(userSource, unitTree, compileSourceInt, SubKind.CLASS_SUBKIND, pt);

                case ENUM:

                    return processClass(userSource, unitTree, compileSourceInt, SubKind.ENUM_SUBKIND, pt);

                case ANNOTATION_TYPE:

                    return processClass(userSource, unitTree, compileSourceInt, SubKind.ANNOTATION_TYPE_SUBKIND, pt);

                case INTERFACE:

                    return processClass(userSource, unitTree, compileSourceInt, SubKind.INTERFACE_SUBKIND, pt);

                case METHOD:

                    return processMethod(userSource, unitTree, compileSourceInt, pt);

                default:

                    return processStatement(userSource, compileSourceInt);

            }

        });

    }

    private List<Snippet> processImport(String userSource, String compileSource) {

        Wrap guts = Wrap.simpleWrap(compileSource);

        Matcher mat = IMPORT_PATTERN.matcher(compileSource);

        String fullname;

        String name;

        boolean isStatic;

        if (mat.find()) {

            isStatic = mat.group("static") != null;

            name = mat.group("name");

            fullname = mat.group("fullname");

        } else {

            // bad import -- fake it

            isStatic = compileSource.contains("static");

            name = fullname = compileSource;

        }

        String fullkey = (isStatic ? "static-" : "") + fullname;

        boolean isStar = name.equals("*");

        String keyName = isStar

                ? fullname

                : name;

        SubKind snippetKind = isStar

                ? (isStatic ? STATIC_IMPORT_ON_DEMAND_SUBKIND : TYPE_IMPORT_ON_DEMAND_SUBKIND)

                : (isStatic ? SINGLE_STATIC_IMPORT_SUBKIND : SINGLE_TYPE_IMPORT_SUBKIND);

        Snippet snip = new ImportSnippet(state.keyMap.keyForImport(keyName, snippetKind),

                userSource, guts, fullname, name, snippetKind, fullkey, isStatic, isStar);

        return singletonList(snip);

    }

    private static class EvalPretty extends Pretty {

        private final Writer out;

        public EvalPretty(Writer writer, boolean bln) {

            super(writer, bln);

            this.out = writer;

        }

        /**

         * Print string, DO NOT replacing all non-ascii character with unicode

         * escapes.

         */

        @Override

        public void print(Object o) throws IOException {

            out.write(o.toString());

        }

        static String prettyExpr(JCTree tree, boolean bln) {

            StringWriter out = new StringWriter();

            try {

                new EvalPretty(out, bln).printExpr(tree);

            } catch (IOException e) {

                throw new AssertionError(e);

            }

            return out.toString();

        }

    }

    private List<Snippet> processVariables(String userSource, List<? extends Tree> units, String compileSource, ParseTask pt) {

        List<Snippet> snippets = new ArrayList<>();

        TreeDissector dis = TreeDissector.createByFirstClass(pt);

        for (Tree unitTree : units) {

            VariableTree vt = (VariableTree) unitTree;

            String name = vt.getName().toString();

            String typeName;

            String fullTypeName;

            String displayType;

            boolean hasEnhancedType = false;

            TreeDependencyScanner tds = new TreeDependencyScanner();

            Wrap typeWrap;

            Wrap anonDeclareWrap = null;

            Wrap winit = null;

            boolean enhancedDesugaring = false;

            Set<String> anonymousClasses = Collections.emptySet();

            StringBuilder sbBrackets = new StringBuilder();

            Tree baseType = vt.getType();

            if (baseType != null) {

                tds.scan(baseType); // Not dependent on initializer

                fullTypeName = displayType = typeName = EvalPretty.prettyExpr((JCTree) vt.getType(), false);

                while (baseType instanceof ArrayTypeTree) {

                    //TODO handle annotations too

                    baseType = ((ArrayTypeTree) baseType).getType();

                    sbBrackets.append("[]");

                }

                Range rtype = dis.treeToRange(baseType);

                typeWrap = Wrap.rangeWrap(compileSource, rtype);

            } else {

                DiagList dl = trialCompile(Wrap.methodWrap(compileSource));

                if (dl.hasErrors()) {

                    return compileFailResult(dl, userSource, kindOfTree(unitTree));

                }

                Tree init = vt.getInitializer();

                if (init != null) {

                    Range rinit = dis.treeToRange(init);

                    String initCode = rinit.part(compileSource);

                    ExpressionInfo ei =

                            ExpressionToTypeInfo.localVariableTypeForInitializer(initCode, state, false);

                    if (ei != null && ei.declareTypeName != null) {

                        typeName = ei.declareTypeName;

                        fullTypeName = ei.fullTypeName;

                        displayType = ei.displayTypeName;

                        hasEnhancedType = !typeName.equals(fullTypeName);

                        enhancedDesugaring = !ei.isPrimitiveType;

                        Pair<Wrap, Wrap> anonymous2Member =

                                anonymous2Member(ei, compileSource, rinit, dis, init);

                        anonDeclareWrap = anonymous2Member.first;

                        winit = anonymous2Member.second;

                        anonymousClasses = ei.anonymousClasses.stream().map(ad -> ad.declareTypeName).collect(Collectors.toSet());

                    } else {

                        displayType = fullTypeName = typeName = "java.lang.Object";

                    }

                    tds.scan(init);

                } else {

                    displayType = fullTypeName = typeName = "java.lang.Object";

                }

                typeWrap = Wrap.identityWrap(typeName);

            }

            Range runit = dis.treeToRange(vt);

            runit = new Range(runit.begin, runit.end - 1);

            ExpressionTree it = vt.getInitializer();

            int nameMax = runit.end - 1;

            SubKind subkind;

            if (it != null) {

                subkind = SubKind.VAR_DECLARATION_WITH_INITIALIZER_SUBKIND;

                Range rinit = dis.treeToRange(it);

                winit = winit == null ? Wrap.rangeWrap(compileSource, rinit) : winit;

                nameMax = rinit.begin - 1;

            } else {

                String sinit;

                switch (typeName) {

                    case "byte":

                    case "short":

                    case "int":

                        sinit = "0";

                        break;

                    case "long":

                        sinit = "0L";

                        break;

                    case "float":

                        sinit = "0.0f";

                        break;

                    case "double":

                        sinit = "0.0d";

                        break;

                    case "boolean":

                        sinit = "false";

                        break;

                    case "char":

                        sinit = "'\\u0000'";

                        break;

                    default:

                        sinit = "null";

                        break;

                }

                winit = Wrap.simpleWrap(sinit);

                subkind = SubKind.VAR_DECLARATION_SUBKIND;

            }

            int nameStart = compileSource.lastIndexOf(name, nameMax);

            if (nameStart < 0) {

                throw new AssertionError("Name '" + name + "' not found");

            }

            int nameEnd = nameStart + name.length();

            Range rname = new Range(nameStart, nameEnd);

            Wrap guts = Wrap.varWrap(compileSource, typeWrap, sbBrackets.toString(), rname,

                                     winit, enhancedDesugaring, anonDeclareWrap);

            DiagList modDiag = modifierDiagnostics(vt.getModifiers(), dis, true);

            Snippet snip = new VarSnippet(state.keyMap.keyForVariable(name), userSource, guts,

                    name, subkind, displayType, hasEnhancedType ? fullTypeName : null, anonymousClasses,

                    tds.declareReferences(), modDiag);

            snippets.add(snip);

        }

        return snippets;

    }

    /**Convert anonymous classes in "init" to member classes, based

     * on the additional information from ExpressionInfo.anonymousClasses.

     *

     * This means:

     * -if the code in the anonymous class captures any variables from the

     *  enclosing context, create fields for them

     * -creating an explicit constructor that:

     * --if the new class expression has a base/enclosing expression, make it an

     *   explicit constructor parameter "encl" and use "encl.super" when invoking

     *   the supertype constructor

     * --if the (used) supertype constructor has any parameters, declare them

     *   as explicit parameters of the constructor, and pass them to the super

     *   constructor

     * --if the code in the anonymous class captures any variables from the

     *   enclosing context, make them an explicit paramters of the constructor

     *   and assign to respective fields.

     * --if there are any explicit fields with initializers in the anonymous class,

     *   move the initializers at the end of the constructor (after the captured fields

     *   are assigned, so that the initializers of these fields can use them).

     * -from the captured variables fields, constructor, and existing members

     *  (with cleared field initializers), create an explicit class that extends or

     *  implements the supertype of the anonymous class.

     *

     * This method returns two wraps: the first contains the class declarations for the

     * converted classes, the first one should be used instead of "init" in the variable

     * declaration.

     */

    private Pair<Wrap, Wrap> anonymous2Member(ExpressionInfo ei,

                                              String compileSource,

                                              Range rinit,

                                              TreeDissector dis,

                                              Tree init) {

        List<Wrap> anonymousDeclarations = new ArrayList<>();

        List<Wrap> partitionedInit = new ArrayList<>();

        int lastPos = rinit.begin;

        com.sun.tools.javac.util.List<NewClassTree> toConvert =

                ExpressionToTypeInfo.listAnonymousClassesToConvert(init);

        com.sun.tools.javac.util.List<AnonymousDescription> descriptions =

                ei.anonymousClasses;

        while (toConvert.nonEmpty() && descriptions.nonEmpty()) {

            NewClassTree node = toConvert.head;

            AnonymousDescription ad = descriptions.head;

            toConvert = toConvert.tail;

            descriptions = descriptions.tail;

            List<Object> classBodyParts = new ArrayList<>();

            //declarations of the captured variables:

            for (VariableDesc vd : ad.capturedVariables) {

                classBodyParts.add(vd.type + " " + vd.name + ";\n");

            }

            List<Object> constructorParts = new ArrayList<>();

            constructorParts.add(ad.declareTypeName + "(");

            String sep = "";

            //add the parameter for the base/enclosing expression, if any:

            if (ad.enclosingInstanceType != null) {

                constructorParts.add(ad.enclosingInstanceType + " encl");

                sep = ", ";

            }

            int idx = 0;

            //add parameters of the super constructor, if any:

            for (String type : ad.parameterTypes) {

                constructorParts.add(sep);

                constructorParts.add(type + " " + "arg" + idx++);

                sep = ", ";

            }

            //add parameters for the captured variables:

            for (VariableDesc vd : ad.capturedVariables) {

                constructorParts.add(sep);

                constructorParts.add(vd.type + " " + "cap$" + vd.name);

                sep = ", ";

            }

            //construct super constructor call:

            if (ad.enclosingInstanceType != null) {

                //if there's an enclosing instance, call super on it:

                constructorParts.add(") { encl.super (");

            } else {

                constructorParts.add(") { super (");

            }

            sep = "";

            for (int i = 0; i < idx; i++) {

                constructorParts.add(sep);

                constructorParts.add("arg" + i);

                sep = ", ";