/*

 * 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.internal.jshell.tool;

import java.io.BufferedWriter;

import java.io.ByteArrayInputStream;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.PrintStream;

import java.io.Reader;

import java.io.StringReader;

import java.nio.charset.Charset;

import java.nio.file.AccessDeniedException;

import java.nio.file.FileSystems;

import java.nio.file.Files;

import java.nio.file.NoSuchFileException;

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

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

import jdk.jshell.Snippet;

import jdk.jshell.Snippet.Status;

import jdk.jshell.SnippetEvent;

import jdk.jshell.SourceCodeAnalysis;

import jdk.jshell.SourceCodeAnalysis.CompletionInfo;

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

import java.util.Optional;

import java.util.ResourceBundle;

import java.util.Spliterators;

import java.util.function.Function;

import java.util.function.Supplier;

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 static java.util.stream.Collectors.toList;

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

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

/**

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

 * @author Robert Field

 */

public class JShellTool {

    private static final String LINE_SEP = System.getProperty("line.separator");

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

    private static final Pattern HISTORY_ALL_START_FILENAME = Pattern.compile(

            "((?<cmd>(all|history|start))(\\z|\\p{javaWhitespace}+))?(?<filename>.*)");

    private 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 Preferences prefs;

    final Locale locale;

    final Feedback feedback = new Feedback();

    /**

     * The constructor for the tool (used by tool launch via main and by test

     * harnesses to capture ins and outs.

     * @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 (not yet functional)

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

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

     * @param prefs preferences to use

     * @param locale locale to use

     */

    public JShellTool(InputStream cmdin, PrintStream cmdout, PrintStream cmderr,

            PrintStream console,

            InputStream userin, PrintStream userout, PrintStream usererr,

            Preferences prefs, Locale locale) {

        this.cmdin = cmdin;

        this.cmdout = cmdout;

        this.cmderr = cmderr;

        this.console = console;

        this.userin = userin;

        this.userout = userout;

        this.usererr = usererr;

        this.prefs = prefs;

        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 feedbackInitialized = false;

    SourceCodeAnalysis analysis;

    JShell state = null;

    Subscription shutdownSubscription = null;

    private boolean debug = false;

    public boolean testPrompt = false;

    private String cmdlineClasspath = null;

    private String cmdlineStartup = null;

    private String[] editor = null;

    // Commands and snippets which should be replayed

    private List<String> replayableHistory;

    private List<String> replayableHistoryPrevious;

    static final String STARTUP_KEY = "STARTUP";

    static final String REPLAY_RESTORE_KEY = "REPLAY_RESTORE";

    static final String DEFAULT_STARTUP =

            "\n" +

            "import java.util.*;\n" +

            "import java.io.*;\n" +

            "import java.math.*;\n" +

            "import java.net.*;\n" +

            "import java.util.concurrent.*;\n" +

            "import java.util.prefs.*;\n" +

            "import java.util.regex.*;\n" +

            "void printf(String format, Object... args) { System.out.printf(format, args); }\n";

    // 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;

    /**

     * Is the input/output currently interactive

     *

     * @return true if console

     */

    boolean interactive() {

        return input != null && input.interactiveOutput();

    }

    void debug(String format, Object... args) {

        if (debug) {

            cmderr.printf(format + "\n", args);

        }

    }

    /**

     * Base output for command output -- no pre- or post-fix

     *

     * @param printf format

     * @param printf args

     */

    void rawout(String format, Object... args) {

        cmdout.printf(format, args);

    }

    /**

     * Must show command output

     *

     * @param format printf format

     * @param args printf args

     */

    void hard(String format, Object... args) {

        rawout(feedback.getPre() + format + feedback.getPost(), args);

    }

    /**

     * Error command output

     *

     * @param format printf format

     * @param args printf args

     */

    void error(String format, Object... args) {

        rawout(feedback.getErrorPre() + format + feedback.getErrorPost(), args);

    }

    /**

     * Optional output

     *

     * @param format printf format

     * @param args printf args

     */

    void fluff(String format, Object... args) {

        if (feedback.shouldDisplayCommandFluff() && interactive()) {

            hard(format, args);

        }

    }

    /**

     * Optional output -- with embedded per- and post-fix

     *

     * @param format printf format

     * @param args printf args

     */

    void fluffRaw(String format, Object... args) {

        if (feedback.shouldDisplayCommandFluff() && interactive()) {

            rawout(format, args);

        }

    }

    /**

     * Print using resource bundle look-up and adding prefix and postfix

     *

     * @param key the resource key

     */

    String getResourceString(String key) {

        if (outputRB == null) {

            try {

                outputRB = ResourceBundle.getBundle(L10N_RB_NAME, locale);

            } catch (MissingResourceException mre) {

                error("Cannot find ResourceBundle: %s for locale: %s", L10N_RB_NAME, locale);

                return "";

            }

        }

        String s;

        try {

            s = outputRB.getString(key);

        } catch (MissingResourceException mre) {

            error("Missing resource: %s in %s", key, L10N_RB_NAME);

            return "";

        }

        return s;

    }

    /**

     * Add prefixing to embedded newlines in a string, leading with the normal

     * prefix

     *

     * @param s the string to prefix

     */

    String prefix(String s) {

        return prefix(s, feedback.getPre());

    }

    /**

     * Add prefixing to embedded newlines in a string

     *

     * @param s the string to prefix

     * @param leading the string to prepend

     */

    String prefix(String s, String leading) {

        if (s == null || s.isEmpty()) {

            return "";

        }

        return leading

                + s.substring(0, s.length() - 1).replaceAll("\\R", System.getProperty("line.separator") + feedback.getPre())

                + s.substring(s.length() - 1, s.length());

    }

    /**

     * Print using resource bundle look-up and adding prefix and postfix

     *

     * @param key the resource key

     */

    void hardrb(String key) {

        String s = prefix(getResourceString(key));

        cmdout.println(s);

    }

    /**

     * Format using resource bundle look-up using MessageFormat

     *

     * @param key the resource key

     * @param args

     */

    String messageFormat(String key, Object... args) {

        String rs = getResourceString(key);

        return MessageFormat.format(rs, args);

    }

    /**

     * Print using resource bundle look-up, MessageFormat, and add prefix and

     * postfix

     *

     * @param key the resource key

     * @param args

     */

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

        cmdout.println(prefix(messageFormat(key, args)));

    }

    /**

     * Print error using resource bundle look-up, MessageFormat, and add prefix

     * and postfix

     *

     * @param key the resource key

     * @param args

     */

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

        cmdout.println(prefix(messageFormat(key, args), feedback.getErrorPre()));

    }

    /**

     * Print command-line error using resource bundle look-up, MessageFormat

     *

     * @param key the resource key

     * @param args

     */

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

        cmderr.println(prefix(messageFormat(key, args), ""));

    }

    /**

     * Print (fluff) using resource bundle look-up, MessageFormat, and add

     * prefix and postfix

     *

     * @param key the resource key

     * @param args

     */

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

        if (feedback.shouldDisplayCommandFluff() && interactive()) {

            hardmsg(key, args);

        }

    }

    <T> void hardPairs(Stream<T> stream, Function<T, String> a, Function<T, String> b) {

        Map<String, String> a2b = stream.collect(toMap(a, b,

                (m1, m2) -> m1,

                () -> new LinkedHashMap<>()));

        int aLen = 0;

        for (String av : a2b.keySet()) {

            aLen = Math.max(aLen, av.length());

        }

        String format = "   %-" + aLen + "s -- %s";

        String indentedNewLine = LINE_SEP + feedback.getPre()

                + String.format("   %-" + (aLen + 4) + "s", "");

        for (Entry<String, String> e : a2b.entrySet()) {

            hard(format, e.getKey(), e.getValue().replaceAll("\n", indentedNewLine));

        }

    }

    /**

     * Trim whitespace off end of string

     *

     * @param s

     * @return

     */

    static String trimEnd(String s) {

        int last = s.length() - 1;

        int i = last;

        while (i >= 0 && Character.isWhitespace(s.charAt(i))) {

            --i;

        }

        if (i != last) {

            return s.substring(0, i + 1);

        } else {

            return s;

        }

    }

    /**

     * Normal start entry point

     * @param args

     * @throws Exception

     */

    public static void main(String[] args) throws Exception {

        new JShellTool(System.in, System.out, System.err, System.out,

                 new ByteArrayInputStream(new byte[0]), System.out, System.err,

                 Preferences.userRoot().node("tool/JShell"),

                 Locale.getDefault())

                .start(args);

    }

    public void start(String[] args) throws Exception {

        List<String> loadList = processCommandArgs(args);

        if (loadList == null) {

            // Abort

            return;

        }

        try (IOContext in = new ConsoleIOContext(this, cmdin, console)) {

            start(in, loadList);

        }

    }

    private void start(IOContext in, List<String> loadList) {

        resetState(); // Initialize

        // Read replay history from last jshell session into previous history

        String prevReplay = prefs.get(REPLAY_RESTORE_KEY, null);

        if (prevReplay != null) {

            replayableHistoryPrevious = Arrays.asList(prevReplay.split(RECORD_SEPARATOR));

        }

        for (String loadFile : loadList) {

            runFile(loadFile, "jshell");

        }

        if (regenerateOnDeath) {

            hardmsg("jshell.msg.welcome", version());

        }

        try {

            while (regenerateOnDeath) {

                if (!live) {

                    resetState();

                }

                run(in);

            }

        } finally {

            closeState();

        }

    }

    /**

     * Process the command line arguments.

     * Set options.

     * @param args the command line arguments

     * @return the list of files to be loaded

     */

    private List<String> processCommandArgs(String[] args) {

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

        Iterator<String> ai = Arrays.asList(args).iterator();

        while (ai.hasNext()) {

            String arg = ai.next();

            if (arg.startsWith("-")) {

                switch (arg) {

                    case "-classpath":

                    case "-cp":

                        if (cmdlineClasspath != null) {

                            startmsg("jshell.err.opt.classpath.conflict");

                            return null;

                        }

                        if (ai.hasNext()) {

                            cmdlineClasspath = ai.next();

                        } else {

                            startmsg("jshell.err.opt.classpath.arg");

                            return null;

                        }

                        break;