/*

 * Copyright (c) 2014, 2015, 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.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.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.Diag;

import jdk.jshell.EvalException;

import jdk.jshell.JShell;

import jdk.jshell.Snippet;

import jdk.jshell.DeclarationSnippet;

import jdk.jshell.TypeDeclSnippet;

import jdk.jshell.MethodSnippet;

import jdk.jshell.PersistentSnippet;

import jdk.jshell.VarSnippet;

import jdk.jshell.ExpressionSnippet;

import jdk.jshell.Snippet.Status;

import jdk.jshell.SourceCodeAnalysis;

import jdk.jshell.SourceCodeAnalysis.CompletionInfo;

import jdk.jshell.SourceCodeAnalysis.Suggestion;

import jdk.jshell.SnippetEvent;

import jdk.jshell.UnresolvedReferenceException;

import jdk.jshell.Snippet.SubKind;

import jdk.jshell.JShell.Subscription;

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

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

/**

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

 * @author Robert Field

 */

public class JShellTool {

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

    final InputStream cmdin;

    final PrintStream cmdout;

    final PrintStream cmderr;

    final PrintStream console;

    final InputStream userin;

    final PrintStream userout;

    final PrintStream usererr;

    /**

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

     */

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

            PrintStream console,

            InputStream userin, PrintStream userout, PrintStream usererr) {

        this.cmdin = cmdin;

        this.cmdout = cmdout;

        this.cmderr = cmderr;

        this.console = console;

        this.userin = userin;

        this.userout = userout;

        this.usererr = usererr;

    }

    private IOContext input = null;

    private boolean regenerateOnDeath = true;

    private boolean live = false;

    SourceCodeAnalysis analysis;

    JShell state = null;

    Subscription shutdownSubscription = null;

    private boolean debug = false;

    private boolean displayPrompt = true;

    public boolean testPrompt = false;

    private Feedback feedback = Feedback.Default;

    private String cmdlineClasspath = null;

    private String cmdlineStartup = null;

    private String editor = null;

    static final Preferences PREFS = Preferences.userRoot().node("tool/REPL");

    static final String STARTUP_KEY = "STARTUP";

    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

    NameSpace mainNamespace;

    NameSpace startNamespace;

    NameSpace errorNamespace;

    NameSpace currentNameSpace;

    Map<Snippet,SnippetInfo> mapSnippet;

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

        if (debug) {

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

        }

    }

    /**

     * For more verbose feedback modes

     * @param format printf format

     * @param args printf args

     */

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

        if (feedback() != Feedback.Off && feedback() != Feedback.Concise) {

            hard(format, args);

        }

    }

    /**

     * For concise feedback mode only

     * @param format printf format

     * @param args printf args

     */

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

        if (feedback() == Feedback.Concise) {

            hard(format, args);

        }

    }

    /**

     * For all feedback modes -- must show

     * @param format printf format

     * @param args printf args

     */

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

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

    }

    /**

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

                .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

        for (String loadFile : loadList) {

            cmdOpen(loadFile);

        }

        if (regenerateOnDeath) {

            fluff("Welcome to JShell -- Version %s", version());

            fluff("Type /help for help");

        }

        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) {

                            cmderr.printf("Conflicting -classpath option.\n");

                            return null;

                        }

                        if (ai.hasNext()) {

                            cmdlineClasspath = ai.next();

                        } else {

                            cmderr.printf("Argument to -classpath missing.\n");

                            return null;

                        }

                        break;

                    case "-help":

                        printUsage();

                        return null;

                    case "-version":

                        cmdout.printf("jshell %s\n", version());

                        return null;

                    case "-fullversion":

                        cmdout.printf("jshell %s\n", fullVersion());

                        return null;

                    case "-startup":

                        if (cmdlineStartup != null) {

                            cmderr.printf("Conflicting -startup or -nostartup option.\n");

                            return null;

                        }

                        if (ai.hasNext()) {

                            String filename = ai.next();

                            try {

                                byte[] encoded = Files.readAllBytes(Paths.get(filename));

                                cmdlineStartup = new String(encoded);

                            } catch (AccessDeniedException e) {

                                hard("File '%s' for start-up is not accessible.", filename);

                            } catch (NoSuchFileException e) {

                                hard("File '%s' for start-up is not found.", filename);

                            } catch (Exception e) {

                                hard("Exception while reading start-up file: %s", e);

                            }

                        } else {

                            cmderr.printf("Argument to -startup missing.\n");

                            return null;

                        }

                        break;

                    case "-nostartup":

                        if (cmdlineStartup != null && !cmdlineStartup.isEmpty()) {

                            cmderr.printf("Conflicting -startup option.\n");

                            return null;

                        }

                        cmdlineStartup = "";

                        break;

                    default:

                        cmderr.printf("Unknown option: %s\n", arg);

                        printUsage();

                        return null;

                }

            } else {

                loadList.add(arg);

            }

        }

        return loadList;

    }

    private void printUsage() {

        cmdout.printf("Usage:   jshell <options> <load files>\n");

        cmdout.printf("where possible options include:\n");

        cmdout.printf("  -classpath <path>          Specify where to find user class files\n");

        cmdout.printf("  -cp <path>                 Specify where to find user class files\n");

        cmdout.printf("  -startup <file>            One run replacement for the start-up definitions\n");

        cmdout.printf("  -nostartup                 Do not run the start-up definitions\n");

        cmdout.printf("  -help                      Print a synopsis of standard options\n");

        cmdout.printf("  -version                   Version information\n");

    }

    private void resetState() {

        closeState();

        // Initialize tool id mapping

        mainNamespace = new NameSpace("main", "");

        startNamespace = new NameSpace("start", "s");

        errorNamespace = new NameSpace("error", "e");

        mapSnippet = new LinkedHashMap<>();

        currentNameSpace = startNamespace;

        state = JShell.builder()

                .in(userin)

                .out(userout)

                .err(usererr)

                .tempVariableNameGenerator(()-> "$" + currentNameSpace.tidNext())

                .idGenerator((sn, i) -> (currentNameSpace == startNamespace || state.status(sn).isActive)

                        ? currentNameSpace.tid(sn)

                        : errorNamespace.tid(sn))

                .build();

        analysis = state.sourceCodeAnalysis();

        shutdownSubscription = state.onShutdown((JShell deadState) -> {

            if (deadState == state) {

                hard("State engine terminated.  See /history");

                live = false;

            }

        });

        live = true;

        if (cmdlineClasspath != null) {

            state.addToClasspath(cmdlineClasspath);

        }

        String start;

        if (cmdlineStartup == null) {

            start = PREFS.get(STARTUP_KEY, "<nada>");

            if (start.equals("<nada>")) {

                start = DEFAULT_STARTUP;

                PREFS.put(STARTUP_KEY, DEFAULT_STARTUP);

            }

        } else {

            start = cmdlineStartup;

        }

        try (IOContext suin = new FileScannerIOContext(new StringReader(start))) {

            run(suin);

        } catch (Exception ex) {

            hard("Unexpected exception reading start-up: %s\n", ex);

        }

        currentNameSpace = mainNamespace;

    }

    private void closeState() {

        live = false;

        JShell oldState = state;

        if (oldState != null) {

            oldState.unsubscribe(shutdownSubscription); // No notification

            oldState.close();

        }

    }

    /**

     * Main loop

     * @param in the line input/editing context

     */

    private void run(IOContext in) {

        IOContext oldInput = input;

        input = in;

        try {

            String incomplete = "";

            while (live) {

                String prompt;

                if (in.interactiveOutput() && displayPrompt) {

                    prompt = testPrompt

                                    ? incomplete.isEmpty()

                                            ? "\u0005" //ENQ

                                            : "\u0006" //ACK

                                    : incomplete.isEmpty()

                                            ? feedback() == Feedback.Concise

                                                    ? "-> "

                                                    : "\n-> "

                                            : ">> "

                    ;

                } else {

                    prompt = "";

                }

                String raw;

                try {

                    raw = in.readLine(prompt, incomplete);

                } catch (InputInterruptedException ex) {

                    //input interrupted - clearing current state

                    incomplete = "";

                    continue;

                }

                if (raw == null) {

                    //EOF

                    if (in.interactiveOutput()) {

                        // End after user ctrl-D

                        regenerateOnDeath = false;

                    }

                    break;

                }

                String trimmed = trimEnd(raw);

                if (!trimmed.isEmpty()) {

                    String line = incomplete + trimmed;

                    // No commands in the middle of unprocessed source

                    if (incomplete.isEmpty() && line.startsWith("/") && !line.startsWith("//") && !line.startsWith("/*")) {

                        processCommand(line.trim());

                    } else {

                        incomplete = processSourceCatchingReset(line);

                    }

                }

            }

        } catch (IOException ex) {

            hard("Unexpected exception: %s\n", ex);

        } finally {

            input = oldInput;

        }

    }

    private String processSourceCatchingReset(String src) {

        try {

            input.beforeUserCode();

            return processSource(src);

        } catch (IllegalStateException ex) {

            hard("Resetting...");

            live = false; // Make double sure

            return "";

        } finally {

            input.afterUserCode();

        }

    }

    private void processCommand(String cmd) {

        }

        String arg = "";

        int idx = cmd.indexOf(' ');

        if (idx > 0) {

            arg = cmd.substring(idx + 1).trim();

            cmd = cmd.substring(0, idx);

        }

        Command[] candidates = findCommand(cmd, c -> c.kind != CommandKind.HELP_ONLY);

        if (candidates.length == 0) {

        } else if (candidates.length == 1) {

            candidates[0].run.accept(arg);

        } else {

            hard("Command: %s is ambiguous: %s", cmd, Arrays.stream(candidates).map(c -> c.command).collect(Collectors.joining(", ")));

            fluff("Type /help for help.");

        }

    }

    private Command[] findCommand(String cmd, Predicate<Command> filter) {

        Command exact = commands.get(cmd);