/*

 * Copyright (c) 2014, 2018, 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.internal.jshell.tool;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.EOFException;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.PrintStream;

import java.io.Reader;

import java.io.StringReader;

import java.lang.module.ModuleDescriptor;

import java.lang.module.ModuleFinder;

import java.lang.module.ModuleReference;

import java.nio.charset.Charset;

import java.nio.file.FileSystems;

import java.nio.file.Files;

import java.nio.file.InvalidPathException;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Optional;

import java.util.Scanner;

import java.util.Set;

import java.util.function.Consumer;

import java.util.function.Predicate;

import java.util.prefs.Preferences;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import java.util.stream.StreamSupport;

import jdk.internal.jshell.debug.InternalDebugControl;

import jdk.internal.jshell.tool.IOContext.InputInterruptedException;

import jdk.jshell.DeclarationSnippet;

import jdk.jshell.Diag;

import jdk.jshell.EvalException;

import jdk.jshell.ExpressionSnippet;

import jdk.jshell.ImportSnippet;

import jdk.jshell.JShell;

import jdk.jshell.JShell.Subscription;

import jdk.jshell.MethodSnippet;

import jdk.jshell.Snippet;

import jdk.jshell.Snippet.Kind;

import jdk.jshell.Snippet.Status;

import jdk.jshell.SnippetEvent;

import jdk.jshell.SourceCodeAnalysis;

import jdk.jshell.SourceCodeAnalysis.CompletionInfo;

import jdk.jshell.SourceCodeAnalysis.Completeness;

import jdk.jshell.SourceCodeAnalysis.Suggestion;

import jdk.jshell.TypeDeclSnippet;

import jdk.jshell.UnresolvedReferenceException;

import jdk.jshell.VarSnippet;

import static java.nio.file.StandardOpenOption.CREATE;

import static java.nio.file.StandardOpenOption.TRUNCATE_EXISTING;

import static java.nio.file.StandardOpenOption.WRITE;

import java.util.AbstractMap.SimpleEntry;

import java.util.MissingResourceException;

import java.util.ResourceBundle;

import java.util.ServiceLoader;

import java.util.Spliterators;

import java.util.function.Function;

import java.util.function.Supplier;

import jdk.internal.joptsimple.*;

import jdk.internal.jshell.tool.Feedback.FormatAction;

import jdk.internal.jshell.tool.Feedback.FormatCase;

import jdk.internal.jshell.tool.Feedback.FormatErrors;

import jdk.internal.jshell.tool.Feedback.FormatResolve;

import jdk.internal.jshell.tool.Feedback.FormatUnresolved;

import jdk.internal.jshell.tool.Feedback.FormatWhen;

import jdk.internal.editor.spi.BuildInEditorProvider;

import jdk.internal.editor.external.ExternalEditor;

import static java.util.Arrays.asList;

import static java.util.Arrays.stream;

import static java.util.Collections.singletonList;

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

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

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

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

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

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

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

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

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

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

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

import static jdk.internal.jshell.tool.ContinuousCompletionProvider.STARTSWITH_MATCHER;

/**

 * Command line REPL tool for Java using the JShell API.

 * @author Robert Field

 */

public class JShellTool implements MessageHandler {

    private static final Pattern LINEBREAK = Pattern.compile("\\R");

    private static final Pattern ID = Pattern.compile("[se]?\\d+([-\\s].*)?");

    private static final Pattern RERUN_ID = Pattern.compile("/" + ID.pattern());

    private static final Pattern RERUN_PREVIOUS = Pattern.compile("/\\-\\d+( .*)?");

    private static final Pattern SET_SUB = Pattern.compile("/?set .*");

            static final String RECORD_SEPARATOR = "\u241E";

    private static final String RB_NAME_PREFIX  = "jdk.internal.jshell.tool.resources";

    private static final String VERSION_RB_NAME = RB_NAME_PREFIX + ".version";

    private static final String L10N_RB_NAME    = RB_NAME_PREFIX + ".l10n";

    final InputStream cmdin;

    final PrintStream cmdout;

    final PrintStream cmderr;

    final PrintStream console;

    final InputStream userin;

    final PrintStream userout;

    final PrintStream usererr;

    final PersistentStorage prefs;

    final Map<String, String> envvars;

    final Locale locale;

    final Feedback feedback = new Feedback();

    /**

     * The complete constructor for the tool (used by test harnesses).

     * @param cmdin command line input -- snippets and commands

     * @param cmdout command line output, feedback including errors

     * @param cmderr start-up errors and debugging info

     * @param console console control interaction

     * @param userin code execution input, or null to use IOContext

     * @param userout code execution output  -- System.out.printf("hi")

     * @param usererr code execution error stream  -- System.err.printf("Oops")

     * @param prefs persistence implementation to use

     * @param envvars environment variable mapping to use

     * @param locale locale to use

     */

    JShellTool(InputStream cmdin, PrintStream cmdout, PrintStream cmderr,

            PrintStream console,

            InputStream userin, PrintStream userout, PrintStream usererr,

            PersistentStorage prefs, Map<String, String> envvars, Locale locale) {

        this.cmdin = cmdin;

        this.cmdout = cmdout;

        this.cmderr = cmderr;

        this.console = console;

        this.userin = userin != null ? userin : new InputStream() {

            @Override

            public int read() throws IOException {

                return input.readUserInput();

            }

        };

        this.userout = userout;

        this.usererr = usererr;

        this.prefs = prefs;

        this.envvars = envvars;

        this.locale = locale;

    }

    private ResourceBundle versionRB = null;

    private ResourceBundle outputRB  = null;

    private IOContext input = null;

    private boolean regenerateOnDeath = true;

    private boolean live = false;

    private boolean interactiveModeBegun = false;

    private Options options;

    SourceCodeAnalysis analysis;

    private JShell state = null;

    Subscription shutdownSubscription = null;

    static final EditorSetting BUILT_IN_EDITOR = new EditorSetting(null, false);

    private boolean debug = false;

    public boolean testPrompt = false;

    private Startup startup = null;

    private boolean isCurrentlyRunningStartup = false;

    private String executionControlSpec = null;

    private EditorSetting editor = BUILT_IN_EDITOR;

    private int exitCode = 0;

    private static final String[] EDITOR_ENV_VARS = new String[] {

        "JSHELLEDITOR", "VISUAL", "EDITOR"};

    // Commands and snippets which can be replayed

    private ReplayableHistory replayableHistory;

    private ReplayableHistory replayableHistoryPrevious;

    static final String STARTUP_KEY  = "STARTUP";

    static final String EDITOR_KEY   = "EDITOR";

    static final String FEEDBACK_KEY = "FEEDBACK";

    static final String MODE_KEY     = "MODE";

    static final String REPLAY_RESTORE_KEY = "REPLAY_RESTORE";

    static final Pattern BUILTIN_FILE_PATTERN = Pattern.compile("\\w+");

    static final String BUILTIN_FILE_PATH_FORMAT = "/jdk/jshell/tool/resources/%s.jsh";

    static final String INT_PREFIX = "int $$exit$$ = ";

    static final int OUTPUT_WIDTH = 72;

    // match anything followed by whitespace

    private static final Pattern OPTION_PRE_PATTERN =

            Pattern.compile("\\s*(\\S+\\s+)*?");

    // match a (possibly incomplete) option flag with optional double-dash and/or internal dashes

    private static final Pattern OPTION_PATTERN =

            Pattern.compile(OPTION_PRE_PATTERN.pattern() + "(?<dd>-??)(?<flag>-([a-z][a-z\\-]*)?)");

    // match an option flag and a (possibly missing or incomplete) value

    private static final Pattern OPTION_VALUE_PATTERN =

            Pattern.compile(OPTION_PATTERN.pattern() + "\\s+(?<val>\\S*)");

    // Tool id (tid) mapping: the three name spaces

    NameSpace mainNamespace;

    NameSpace startNamespace;

    NameSpace errorNamespace;

    // Tool id (tid) mapping: the current name spaces

    NameSpace currentNameSpace;

    Map<Snippet, SnippetInfo> mapSnippet;

    // Kinds of compiler/runtime init options

    private enum OptionKind {

        CLASS_PATH("--class-path", true),

        MODULE_PATH("--module-path", true),

        ADD_MODULES("--add-modules", false),

        ADD_EXPORTS("--add-exports", false),

        TO_COMPILER("-C", false, false, true, false),

        TO_REMOTE_VM("-R", false, false, false, true),;

        final String optionFlag;

        final boolean onlyOne;

        final boolean passFlag;

        final boolean toCompiler;

        final boolean toRemoteVm;

        private OptionKind(String optionFlag, boolean onlyOne) {

            this(optionFlag, onlyOne, true, true, true);

        }

        private OptionKind(String optionFlag, boolean onlyOne, boolean passFlag,

                boolean toCompiler, boolean toRemoteVm) {

            this.optionFlag = optionFlag;

            this.onlyOne = onlyOne;

            this.passFlag = passFlag;

            this.toCompiler = toCompiler;

            this.toRemoteVm = toRemoteVm;

        }

    }

    // compiler/runtime init option values

    private static class Options {

        private final Map<OptionKind, List<String>> optMap;

        // New blank Options

        Options() {

            optMap = new HashMap<>();

        }

        // Options as a copy

        private Options(Options opts) {

            optMap = new HashMap<>(opts.optMap);

        }

        private String[] selectOptions(Predicate<Entry<OptionKind, List<String>>> pred) {

            return optMap.entrySet().stream()

                    .filter(pred)

                    .flatMap(e -> e.getValue().stream())

                    .toArray(String[]::new);

        }

        String[] remoteVmOptions() {

            return selectOptions(e -> e.getKey().toRemoteVm);

        }

        String[] compilerOptions() {

            return selectOptions(e -> e.getKey().toCompiler);

        }

        String[] commonOptions() {

            return selectOptions(e -> e.getKey().passFlag);

        }

        void addAll(OptionKind kind, Collection<String> vals) {

            optMap.computeIfAbsent(kind, k -> new ArrayList<>())

                    .addAll(vals);

        }

        // return a new Options, with parameter options overriding receiver options

        Options override(Options newer) {

            Options result = new Options(this);

            newer.optMap.entrySet().stream()

                    .forEach(e -> {

                        if (e.getKey().onlyOne) {

                            // Only one allowed, override last

                            result.optMap.put(e.getKey(), e.getValue());

                        } else {

                            // Additive

                            result.addAll(e.getKey(), e.getValue());

                        }

                    });

            return result;

        }

    }

    // base option parsing of /env, /reload, and /reset and command-line options

    private class OptionParserBase {

        final OptionParser parser = new OptionParser();

        private final OptionSpec<String> argClassPath = parser.accepts("class-path").withRequiredArg();

        private final OptionSpec<String> argModulePath = parser.accepts("module-path").withRequiredArg();

        private final OptionSpec<String> argAddModules = parser.accepts("add-modules").withRequiredArg();

        private final OptionSpec<String> argAddExports = parser.accepts("add-exports").withRequiredArg();

        private final NonOptionArgumentSpec<String> argNonOptions = parser.nonOptions();

        private Options opts = new Options();

        private List<String> nonOptions;

        private boolean failed = false;

        List<String> nonOptions() {

            return nonOptions;

        }

        void msg(String key, Object... args) {

            errormsg(key, args);

        }

        Options parse(String[] args) throws OptionException {

            try {

                OptionSet oset = parser.parse(args);

                nonOptions = oset.valuesOf(argNonOptions);

                return parse(oset);

            } catch (OptionException ex) {

                if (ex.options().isEmpty()) {

                    msg("jshell.err.opt.invalid", stream(args).collect(joining(", ")));

                } else {

                    boolean isKnown = parser.recognizedOptions().containsKey(ex.options().iterator().next());

                    msg(isKnown

                            ? "jshell.err.opt.arg"

                            : "jshell.err.opt.unknown",

                            ex.options()

                            .stream()

                            .collect(joining(", ")));

                }

                exitCode = 1;

                return null;

            }

        }

        // check that the supplied string represent valid class/module paths

        // converting any ~/ to user home

        private Collection<String> validPaths(Collection<String> vals, String context, boolean isModulePath) {

            Stream<String> result = vals.stream()

                    .map(s -> Arrays.stream(s.split(File.pathSeparator))

                        .flatMap(sp -> toPathImpl(sp, context))

                        .filter(p -> checkValidPathEntry(p, context, isModulePath))

                        .map(p -> p.toString())

                        .collect(Collectors.joining(File.pathSeparator)));

            if (failed) {

                return Collections.emptyList();

            } else {

                return result.collect(toList());

            }

        }

        // Adapted from compiler method Locations.checkValidModulePathEntry

        private boolean checkValidPathEntry(Path p, String context, boolean isModulePath) {

            if (!Files.exists(p)) {

                msg("jshell.err.file.not.found", context, p);

                failed = true;

                return false;

            }

            if (Files.isDirectory(p)) {

                // if module-path, either an exploded module or a directory of modules

                return true;

            }

            String name = p.getFileName().toString();

            int lastDot = name.lastIndexOf(".");

            if (lastDot > 0) {

                switch (name.substring(lastDot)) {

                    case ".jar":

                        return true;

                    case ".jmod":

                        if (isModulePath) {

                            return true;

                        }

                }

            }

            msg("jshell.err.arg", context, p);

            failed = true;

            return false;

        }

        private Stream<Path> toPathImpl(String path, String context) {

            try {

                return Stream.of(toPathResolvingUserHome(path));

            } catch (InvalidPathException ex) {

                msg("jshell.err.file.not.found", context, path);

                failed = true;

                return Stream.empty();

            }

        }

        Options parse(OptionSet options) {

            addOptions(OptionKind.CLASS_PATH,

                    validPaths(options.valuesOf(argClassPath), "--class-path", false));

            addOptions(OptionKind.MODULE_PATH,

                    validPaths(options.valuesOf(argModulePath), "--module-path", true));

            addOptions(OptionKind.ADD_MODULES, options.valuesOf(argAddModules));

            addOptions(OptionKind.ADD_EXPORTS, options.valuesOf(argAddExports).stream()

                    .map(mp -> mp.contains("=") ? mp : mp + "=ALL-UNNAMED")

                    .collect(toList())

            );

            if (failed) {

                exitCode = 1;

                return null;

            } else {

                return opts;

            }

        }

        void addOptions(OptionKind kind, Collection<String> vals) {

            if (!vals.isEmpty()) {

                if (kind.onlyOne && vals.size() > 1) {

                    msg("jshell.err.opt.one", kind.optionFlag);

                    failed = true;

                    return;

                }

                if (kind.passFlag) {

                    vals = vals.stream()

                            .flatMap(mp -> Stream.of(kind.optionFlag, mp))

                            .collect(toList());

                }

                opts.addAll(kind, vals);

            }

        }

    }

    // option parsing for /reload (adds -restore -quiet)

    private class OptionParserReload extends OptionParserBase {

        private final OptionSpecBuilder argRestore = parser.accepts("restore");

        private final OptionSpecBuilder argQuiet   = parser.accepts("quiet");

        private boolean restore = false;

        private boolean quiet = false;

        boolean restore() {

            return restore;

        }

        boolean quiet() {

            return quiet;

        }