/*

 * Copyright (c) 2015, 2017, 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.spi.ExecutionControl;

import java.io.ByteArrayInputStream;

import java.io.InputStream;

import java.io.InterruptedIOException;

import java.io.PrintStream;

import java.net.InetAddress;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.MissingResourceException;

import java.util.Objects;

import java.util.ResourceBundle;

import java.util.function.BiFunction;

import java.util.function.Consumer;

import java.util.function.Function;

import java.util.function.Supplier;

import java.util.stream.Stream;

import javax.tools.StandardJavaFileManager;

import jdk.internal.jshell.debug.InternalDebugControl;

import jdk.jshell.Snippet.Status;

import jdk.jshell.spi.ExecutionControl.EngineTerminationException;

import jdk.jshell.spi.ExecutionControl.ExecutionControlException;

import jdk.jshell.spi.ExecutionControlProvider;

import jdk.jshell.spi.ExecutionEnv;

import static jdk.jshell.Util.expunge;

/**

 * The JShell evaluation state engine.  This is the central class in the JShell

 * API.  A {@code JShell} instance holds the evolving compilation and

 * execution state.  The state is changed with the instance methods

 * {@link jdk.jshell.JShell#eval(java.lang.String) eval(String)},

 * {@link jdk.jshell.JShell#drop(jdk.jshell.Snippet) drop(Snippet)} and

 * {@link jdk.jshell.JShell#addToClasspath(java.lang.String) addToClasspath(String)}.

 * The majority of methods query the state.

 * A {@code JShell} instance also allows registering for events with

 * {@link jdk.jshell.JShell#onSnippetEvent(java.util.function.Consumer) onSnippetEvent(Consumer)}

 * and {@link jdk.jshell.JShell#onShutdown(java.util.function.Consumer) onShutdown(Consumer)}, which

 * are unregistered with

 * {@link jdk.jshell.JShell#unsubscribe(jdk.jshell.JShell.Subscription) unsubscribe(Subscription)}.

 * Access to the source analysis utilities is via

 * {@link jdk.jshell.JShell#sourceCodeAnalysis()}.

 * When complete the instance should be closed to free resources --

 * {@link jdk.jshell.JShell#close()}.

 * <p>

 * An instance of {@code JShell} is created with

 * {@code JShell.create()}.

 * <p>

 * This class is not thread safe, except as noted, all access should be through

 * a single thread.

 *

 * @author Robert Field

 * @since 9

 */

public class JShell implements AutoCloseable {

    final SnippetMaps maps;

    final KeyMap keyMap;

    final OuterWrapMap outerMap;

    final TaskFactory taskFactory;

    final InputStream in;

    final PrintStream out;

    final PrintStream err;

    final Supplier<String> tempVariableNameGenerator;

    final BiFunction<Snippet, Integer, String> idGenerator;

    final List<String> extraRemoteVMOptions;

    final List<String> extraCompilerOptions;

    final Function<StandardJavaFileManager, StandardJavaFileManager> fileManagerMapping;

    private int nextKeyIndex = 1;

    final Eval eval;

    final ClassTracker classTracker;

    private final Map<Subscription, Consumer<JShell>> shutdownListeners = new HashMap<>();

    private final Map<Subscription, Consumer<SnippetEvent>> keyStatusListeners = new HashMap<>();

    private boolean closed = false;

    private final ExecutionControl executionControl;

    private SourceCodeAnalysisImpl sourceCodeAnalysis = null;

    private static final String L10N_RB_NAME    = "jdk.jshell.resources.l10n";

    private static ResourceBundle outputRB  = null;

    JShell(Builder b) throws IllegalStateException {

        this.in = b.in;

        this.out = b.out;

        this.err = b.err;

        this.tempVariableNameGenerator = b.tempVariableNameGenerator;

        this.idGenerator = b.idGenerator;

        this.extraRemoteVMOptions = b.extraRemoteVMOptions;

        this.extraCompilerOptions = b.extraCompilerOptions;

        this.fileManagerMapping = b.fileManagerMapping;

        try {

            if (b.executionControlProvider != null) {

                executionControl = b.executionControlProvider.generate(new ExecutionEnvImpl(),

                        b.executionControlParameters == null

                                ? b.executionControlProvider.defaultParameters()

                                : b.executionControlParameters);

            } else {

                String loopback = InetAddress.getLoopbackAddress().getHostAddress();

                String spec = b.executionControlSpec == null

                        ? "failover:0(jdi:hostname(" + loopback + ")),"

                          + "1(jdi:launch(true)), 2(jdi)"

                        : b.executionControlSpec;

                executionControl = ExecutionControl.generate(new ExecutionEnvImpl(), spec);

            }

        } catch (Throwable ex) {

            throw new IllegalStateException("Launching JShell execution engine threw: " + ex.getMessage(), ex);

        }

        this.maps = new SnippetMaps(this);

        this.keyMap = new KeyMap(this);

        this.outerMap = new OuterWrapMap(this);

        this.taskFactory = new TaskFactory(this);

        this.eval = new Eval(this);

        this.classTracker = new ClassTracker();

    }

    /**

     * Builder for {@code JShell} instances.

     * Create custom instances of {@code JShell} by using the setter

     * methods on this class.  After zero or more of these, use the

     * {@link #build()} method to create a {@code JShell} instance.

     * These can all be chained. For example, setting the remote output and

     * error streams:

     * <pre>

     * {@code

     *     JShell myShell =

     *       JShell.builder()

     *         .out(myOutStream)

     *         .err(myErrStream)

     *         .build(); } </pre>

     * If no special set-up is needed, just use

     * {@code JShell.builder().build()} or the short-cut equivalent

     * {@code JShell.create()}.

     */

    public static class Builder {

        InputStream in = new ByteArrayInputStream(new byte[0]);

        PrintStream out = System.out;

        PrintStream err = System.err;

        Supplier<String> tempVariableNameGenerator = null;

        BiFunction<Snippet, Integer, String> idGenerator = null;

        List<String> extraRemoteVMOptions = new ArrayList<>();

        List<String> extraCompilerOptions = new ArrayList<>();

        ExecutionControlProvider executionControlProvider;

        Map<String,String> executionControlParameters;

        String executionControlSpec;

        Function<StandardJavaFileManager, StandardJavaFileManager> fileManagerMapping;

        Builder() { }

        /**

         * Sets the input for the running evaluation (it's {@code System.in}). Note:

         * applications that use {@code System.in} for snippet or other

         * user input cannot use {@code System.in} as the input stream for

         * the remote process.

         * <p>

         * The {@code read} method of the {@code InputStream} may throw the {@link InterruptedIOException}

         * to signal the user canceled the input. The currently running snippet will be automatically

         * {@link JShell#stop() stopped}.

         * <p>

         * The default, if this is not set, is to provide an empty input stream

         * -- {@code new ByteArrayInputStream(new byte[0])}.

         *

         * @param in the {@code InputStream} to be channelled to

         * {@code System.in} in the remote execution process

         * @return the {@code Builder} instance (for use in chained

         * initialization)

         */

        public Builder in(InputStream in) {

            this.in = in;

            return this;

        }

        /**

         * Sets the output for the running evaluation (it's {@code System.out}).

         * The controlling process and

         * the remote process can share {@code System.out}.

         * <p>

         * The default, if this is not set, is {@code System.out}.

         *

         * @param out the {@code PrintStream} to be channelled to

         * {@code System.out} in the remote execution process

         * @return the {@code Builder} instance (for use in chained

         * initialization)

         */

        public Builder out(PrintStream out) {

            this.out = out;

            return this;

        }

        /**

         * Sets the error output for the running evaluation (it's

         * {@code System.err}). The controlling process and the remote

         * process can share {@code System.err}.

         * <p>

         * The default, if this is not set, is {@code System.err}.

         *

         * @param err the {@code PrintStream} to be channelled to

         * {@code System.err} in the remote execution process

         * @return the {@code Builder} instance (for use in chained

         * initialization)

         */

        public Builder err(PrintStream err) {

            this.err = err;

            return this;

        }

        /**

         * Sets a generator of temp variable names for

         * {@link jdk.jshell.VarSnippet} of

         * {@link jdk.jshell.Snippet.SubKind#TEMP_VAR_EXPRESSION_SUBKIND}.

         * <p>

         * Do not use this method unless you have explicit need for it.

         * <p>

         * The generator will be used for newly created VarSnippet

         * instances. The name of a variable is queried with

         * {@link jdk.jshell.VarSnippet#name()}.

         * <p>

         * The callback is sent during the processing of the snippet, the

         * JShell state is not stable. No calls whatsoever on the

         * {@code JShell} instance may be made from the callback.

         * <p>

         * The generated name must be unique within active snippets.

         * <p>

         * The default behavior (if this is not set or {@code generator}

         * is null) is to generate the name as a sequential number with a

         * prefixing dollar sign ("$").

         *

         * @param generator the {@code Supplier} to generate the temporary

         * variable name string or {@code null}

         * @return the {@code Builder} instance (for use in chained

         * initialization)

         */

        public Builder tempVariableNameGenerator(Supplier<String> generator) {

            this.tempVariableNameGenerator = generator;

            return this;

        }

        /**

         * Sets the generator of identifying names for Snippets.

         * <p>

         * Do not use this method unless you have explicit need for it.

         * <p>

         * The generator will be used for newly created Snippet instances. The

         * identifying name (id) is accessed with

         * {@link jdk.jshell.Snippet#id()} and can be seen in the

         * {@code StackTraceElement.getFileName()} for a

         * {@link jdk.jshell.EvalException} and

         * {@link jdk.jshell.UnresolvedReferenceException}.

         * <p>

         * The inputs to the generator are the {@link jdk.jshell.Snippet} and an

         * integer. The integer will be the same for two Snippets which would

         * overwrite one-another, but otherwise is unique.

         * <p>

         * The callback is sent during the processing of the snippet and the

         * Snippet and the state as a whole are not stable. No calls to change

         * system state (including Snippet state) should be made. Queries of

         * Snippet may be made except to {@link jdk.jshell.Snippet#id()}. No

         * calls on the {@code JShell} instance may be made from the

         * callback, except to

         * {@link #status(jdk.jshell.Snippet) status(Snippet)}.

         * <p>

         * The default behavior (if this is not set or {@code generator}

         * is null) is to generate the id as the integer converted to a string.

         *

         * @param generator the {@code BiFunction} to generate the id

         * string or {@code null}

         * @return the {@code Builder} instance (for use in chained

         * initialization)

         */

        public Builder idGenerator(BiFunction<Snippet, Integer, String> generator) {

            this.idGenerator = generator;

            return this;

        }

        /**

         * Sets additional VM options for launching the VM.

         *

         * @param options The options for the remote VM

         * @return the {@code Builder} instance (for use in chained

         * initialization)

         */

        public Builder remoteVMOptions(String... options) {

            this.extraRemoteVMOptions.addAll(Arrays.asList(options));

            return this;

        }

        /**

         * Adds compiler options.  These additional options will be used on

         * parsing, analysis, and code generation calls to the compiler.

         * Options which interfere with results are not supported and have

         * undefined effects on JShell's operation.

         *

         * @param options the addition options for compiler invocations

         * @return the {@code Builder} instance (for use in chained

         * initialization)

         */

        public Builder compilerOptions(String... options) {

            this.extraCompilerOptions.addAll(Arrays.asList(options));

            return this;

        }

        /**

         * Sets the custom engine for execution. Snippet execution will be

         * provided by the {@link ExecutionControl} instance selected by the

         * specified execution control spec.

         * Use, at most, one of these overloaded {@code executionEngine} builder

         * methods.

         *

         * @param executionControlSpec the execution control spec,

         * which is documented in the {@link jdk.jshell.spi}

         * package documentation.

         * @return the {@code Builder} instance (for use in chained

         * initialization)

         */

        public Builder executionEngine(String executionControlSpec) {

            this.executionControlSpec = executionControlSpec;

            return this;

        }

        /**

         * Sets the custom engine for execution. Snippet execution will be

         * provided by the specified {@link ExecutionControl} instance.

         * Use, at most, one of these overloaded {@code executionEngine} builder

         * methods.

         *

         * @param executionControlProvider the provider to supply the execution

         * engine

         * @param executionControlParameters the parameters to the provider, or

         * {@code null} for default parameters

         * @return the {@code Builder} instance (for use in chained

         * initialization)

         */

        public Builder executionEngine(ExecutionControlProvider executionControlProvider,

                Map<String,String> executionControlParameters) {

            this.executionControlProvider = executionControlProvider;

            this.executionControlParameters = executionControlParameters;

            return this;

        }

        /**

         * Configure the {@code FileManager} to be used by compilation and

         * source analysis.

         * If not set or passed null, the compiler's standard file manager will

         * be used (identity mapping).

         * For use in special applications where the compiler's normal file

         * handling needs to be overridden.  See the file manager APIs for more

         * information.

         * The file manager input enables forwarding file managers, if this

         * is not needed, the incoming file manager can be ignored (constant

         * function).

         *

         * @param mapping a function that given the compiler's standard file

         * manager, returns a file manager to use

         * @return the {@code Builder} instance (for use in chained

         * initialization)

         */

        public Builder fileManager(Function<StandardJavaFileManager, StandardJavaFileManager> mapping) {

            this.fileManagerMapping = mapping;

            return this;

        }

        /**

         * Builds a JShell state engine. This is the entry-point to all JShell

         * functionality. This creates a remote process for execution. It is

         * thus important to close the returned instance.

         *

         * @throws IllegalStateException if the {@code JShell} instance could not be created.

         * @return the state engine

         */

        public JShell build() throws IllegalStateException {

            return new JShell(this);

        }

    }

    // --- public API ---

    /**

     * Create a new JShell state engine.

     * That is, create an instance of {@code JShell}.

     * <p>

     * Equivalent to {@link JShell#builder() JShell.builder()}{@link JShell.Builder#build() .build()}.

     * @throws IllegalStateException if the {@code JShell} instance could not be created.

     * @return an instance of {@code JShell}.

     */

    public static JShell create() throws IllegalStateException {

        return builder().build();

    }

    /**

     * Factory method for {@code JShell.Builder} which, in-turn, is used

     * for creating instances of {@code JShell}.

     * Create a default instance of {@code JShell} with

     * {@code JShell.builder().build()}. For more construction options

     * see {@link jdk.jshell.JShell.Builder}.

     * @return an instance of {@code Builder}.

     * @see jdk.jshell.JShell.Builder

     */

    public static Builder builder() {

        return new Builder();

    }

    /**

     * Access to source code analysis functionality.

     * An instance of {@code JShell} will always return the same

     * {@code SourceCodeAnalysis} instance from

     * {@code sourceCodeAnalysis()}.

     * @return an instance of {@link SourceCodeAnalysis SourceCodeAnalysis}

     * which can be used for source analysis such as completion detection and

     * completion suggestions.

     */

    public SourceCodeAnalysis sourceCodeAnalysis() {

        if (sourceCodeAnalysis == null) {

            sourceCodeAnalysis = new SourceCodeAnalysisImpl(this);

        }

        return sourceCodeAnalysis;

    }

    /**

     * Evaluate the input String, including definition and/or execution, if

     * applicable. The input is checked for errors, unless the errors can be

     * deferred (as is the case with some unresolvedDependencies references),

     * errors will abort evaluation.

     * <p>

     * The input should be

     * exactly one complete snippet of source code, that is, one expression,

     * statement, variable declaration, method declaration, class declaration,

     * or import.

     * To break arbitrary input into individual complete snippets, use

     * {@link SourceCodeAnalysis#analyzeCompletion(String)}.

     * <p>

     * For imports, the import is added.  Classes, interfaces. methods,

     * and variables are defined.  The initializer of variables, statements,

     * and expressions are executed.

     * The modifiers public, protected, private, static, and final are not

     * allowed on op-level declarations and are ignored with a warning.

     * Synchronized, native, abstract, and default top-level methods are not

     * allowed and are errors.

     * If a previous definition of a declaration is overwritten then there will

     * be an event showing its status changed to OVERWRITTEN, this will not

     * occur for dropped, rejected, or already overwritten declarations.

     * <p>

     * If execution environment is out of process, as is the default case, then

     * if the evaluated code

     * causes the execution environment to terminate, this {@code JShell}

     * instance will be closed but the calling process and VM remain valid.

     * @param input The input String to evaluate

     * @return the list of events directly or indirectly caused by this evaluation.

     * @throws IllegalStateException if this {@code JShell} instance is closed.

     * @see SourceCodeAnalysis#analyzeCompletion(String)

     * @see JShell#onShutdown(java.util.function.Consumer)

     */

    public List<SnippetEvent> eval(String input) throws IllegalStateException {

        SourceCodeAnalysisImpl a = sourceCodeAnalysis;

        if (a != null) {

            a.suspendIndexing();

        }

        try {

            checkIfAlive();

            List<SnippetEvent> events = eval.eval(input);

            events.forEach(this::notifyKeyStatusEvent);

            return Collections.unmodifiableList(events);

        } finally {

            if (a != null) {

                a.resumeIndexing();

            }

        }

    }