/*

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

import jdk.jshell.SourceCodeAnalysis.Documentation;

import jdk.jshell.SourceCodeAnalysis.QualifiedNames;

import jdk.jshell.SourceCodeAnalysis.Suggestion;

import java.io.IOException;

import java.io.InputStream;

import java.io.InterruptedIOException;

import java.io.PrintStream;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.Optional;

import java.util.function.BooleanSupplier;

import java.util.function.Function;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import jdk.internal.shellsupport.doc.JavadocFormatter;

import jdk.internal.jline.NoInterruptUnixTerminal;

import jdk.internal.jline.Terminal;

import jdk.internal.jline.TerminalFactory;

import jdk.internal.jline.TerminalSupport;

import jdk.internal.jline.WindowsTerminal;

import jdk.internal.jline.console.ConsoleReader;

import jdk.internal.jline.console.KeyMap;

import jdk.internal.jline.console.Operation;

import jdk.internal.jline.console.UserInterruptException;

import jdk.internal.jline.console.history.History;

import jdk.internal.jline.console.history.MemoryHistory;

import jdk.internal.jline.extra.EditingHistory;

import jdk.internal.jline.internal.NonBlockingInputStream;

import jdk.internal.jshell.tool.StopDetectingInputStream.State;

import jdk.internal.misc.Signal;

import jdk.internal.misc.Signal.Handler;

class ConsoleIOContext extends IOContext {

    private static final String HISTORY_LINE_PREFIX = "HISTORY_LINE_";

    final JShellTool repl;

    final StopDetectingInputStream input;

    final ConsoleReader in;

    final EditingHistory history;

    final MemoryHistory userInputHistory = new MemoryHistory();

    String prefix = "";

    ConsoleIOContext(JShellTool repl, InputStream cmdin, PrintStream cmdout) throws Exception {

        this.repl = repl;

        this.input = new StopDetectingInputStream(() -> repl.stop(), ex -> repl.hard("Error on input: %s", ex));

        Terminal term;

        if (System.getProperty("test.jdk") != null) {

            term = new TestTerminal(input);

        } else if (System.getProperty("os.name").toLowerCase(Locale.US).contains(TerminalFactory.WINDOWS)) {

            term = new JShellWindowsTerminal(input);

        } else {

            term = new JShellUnixTerminal(input);

        }

        term.init();

        List<CompletionTask> completionTODO = new ArrayList<>();

        in = new ConsoleReader(cmdin, cmdout, term) {

            @Override public KeyMap getKeys() {

                return new CheckCompletionKeyMap(super.getKeys(), completionTODO);

            }

            @Override

            protected boolean complete() throws IOException {

                return ConsoleIOContext.this.complete(completionTODO);

            }

        };

        in.setExpandEvents(false);

        in.setHandleUserInterrupt(true);

        List<String> persistenHistory = Stream.of(repl.prefs.keys())

                                              .filter(key -> key.startsWith(HISTORY_LINE_PREFIX))

                                              .sorted()

                                              .map(key -> repl.prefs.get(key))

                                              .collect(Collectors.toList());

        in.setHistory(history = new EditingHistory(in, persistenHistory) {

            @Override protected boolean isComplete(CharSequence input) {

                return repl.analysis.analyzeCompletion(input.toString()).completeness().isComplete();

            }

        });

        in.setBellEnabled(true);

        in.setCopyPasteDetection(true);

        bind(FIXES_SHORTCUT, (Runnable) () -> fixes());

        try {

            Signal.handle(new Signal("CONT"), new Handler() {

                @Override public void handle(Signal sig) {

                    try {

                        in.getTerminal().reset();

                        in.redrawLine();

                        in.flush();

                    } catch (Exception ex) {

                        ex.printStackTrace();

                    }

                }

            });

        } catch (IllegalArgumentException ignored) {

            //the CONT signal does not exist on this platform

        }

    }

    @Override

    public String readLine(String prompt, String prefix) throws IOException, InputInterruptedException {

        this.prefix = prefix;

        try {

            return in.readLine(prompt);

        } catch (UserInterruptException ex) {

            throw (InputInterruptedException) new InputInterruptedException().initCause(ex);

        }

    }

    @Override

    public boolean interactiveOutput() {

        return true;

    }

    @Override

    public Iterable<String> currentSessionHistory() {

        return history.currentSessionEntries();

    }

    @Override

    public void close() throws IOException {

        //save history:

        for (String key : repl.prefs.keys()) {

            if (key.startsWith(HISTORY_LINE_PREFIX)) {

                repl.prefs.remove(key);

            }

        }

        Collection<? extends String> savedHistory = history.save();

        if (!savedHistory.isEmpty()) {

            int len = (int) Math.ceil(Math.log10(savedHistory.size()+1));

            String format = HISTORY_LINE_PREFIX + "%0" + len + "d";

            int index = 0;

            for (String historyLine : savedHistory) {

                repl.prefs.put(String.format(format, index++), historyLine);

            }

        }

        repl.prefs.flush();

        in.shutdown();

        try {

            in.getTerminal().restore();

        } catch (Exception ex) {

            throw new IOException(ex);

        }

        input.shutdown();

    }

    private void bind(String shortcut, Object action) {

        KeyMap km = in.getKeys();

        for (int i = 0; i < shortcut.length(); i++) {

            Object value = km.getBound(Character.toString(shortcut.charAt(i)));

            if (value instanceof KeyMap) {

                km = (KeyMap) value;

            } else {

                km.bind(shortcut.substring(i), action);

            }

        }

    }

    private static final String FIXES_SHORTCUT = "\033\133\132"; //Shift-TAB

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

    private static final String LINE_SEPARATORS2 = LINE_SEPARATOR + LINE_SEPARATOR;

    @SuppressWarnings("fallthrough")

    private boolean complete(List<CompletionTask> todo) {

        //The completion has multiple states (invoked by subsequent presses of <tab>).

        //On the first invocation in a given sequence, all steps are precomputed

        //and placed into the todo list. The todo list is then followed on both the first

        //and subsequent <tab> presses:

        try {

            String text = in.getCursorBuffer().toString();

            int cursor = in.getCursorBuffer().cursor;

            if (todo.isEmpty()) {

                int[] anchor = new int[] {-1};

                List<Suggestion> suggestions;

                List<String> doc;

                boolean command = prefix.isEmpty() && text.trim().startsWith("/");

                if (command) {

                    suggestions = repl.commandCompletionSuggestions(text, cursor, anchor);

                    doc = repl.commandDocumentation(text, cursor, true);

                } else {

                    int prefixLength = prefix.length();

                    suggestions = repl.analysis.completionSuggestions(prefix + text, cursor + prefixLength, anchor);

                    anchor[0] -= prefixLength;

                    doc = repl.analysis.documentation(prefix + text, cursor + prefix.length(), false)

                                       .stream()

                                       .map(Documentation::signature)

                                       .collect(Collectors.toList());

                }

                long smartCount = suggestions.stream().filter(Suggestion::matchesType).count();

                boolean hasSmart = smartCount > 0 && smartCount <= in.getAutoprintThreshold();

                boolean hasBoth = hasSmart &&

                                  suggestions.stream()

                                             .map(s -> s.matchesType())

                                             .distinct()

                                             .count() == 2;

                boolean tooManyItems = suggestions.size() > in.getAutoprintThreshold();

                CompletionTask ordinaryCompletion = new OrdinaryCompletionTask(suggestions, anchor[0], !command && !doc.isEmpty(), hasSmart);

                CompletionTask allCompletion = new AllSuggestionsCompletionTask(suggestions, anchor[0]);

                //the main decission tree:

                if (command) {

                    CompletionTask shortDocumentation = new CommandSynopsisTask(doc);

                    CompletionTask fullDocumentation = new CommandFullDocumentationTask(todo);

                    if (!doc.isEmpty()) {

                        if (tooManyItems) {

                            todo.add(new NoopCompletionTask());

                            todo.add(allCompletion);

                        } else {

                            todo.add(ordinaryCompletion);

                        }

                        todo.add(shortDocumentation);

                        todo.add(fullDocumentation);

                    } else {

                        todo.add(new NoSuchCommandCompletionTask());

                    }

                } else {

                    if (doc.isEmpty()) {

                        if (hasSmart) {

                            todo.add(ordinaryCompletion);

                        } else if (tooManyItems) {

                            todo.add(new NoopCompletionTask());

                        }

                        if (!hasSmart || hasBoth) {

                            todo.add(allCompletion);

                        }

                    } else {

                        CompletionTask shortDocumentation = new ExpressionSignaturesTask(doc);

                        CompletionTask fullDocumentation = new ExpressionJavadocTask(todo);

                        if (hasSmart) {

                            todo.add(ordinaryCompletion);

                        }

                        todo.add(shortDocumentation);

                        if (!hasSmart || hasBoth) {

                            todo.add(allCompletion);

                        }

                        if (tooManyItems) {

                            todo.add(todo.size() - 1, fullDocumentation);

                        } else {

                            todo.add(fullDocumentation);

                        }

                    }

                }

            }

            boolean success = false;

            boolean repaint = true;

            OUTER: while (!todo.isEmpty()) {

                CompletionTask.Result result = todo.remove(0).perform(text, cursor);

                switch (result) {

                    case CONTINUE:

                        break;

                    case SKIP_NOREPAINT:

                        repaint = false;

                    case SKIP:

                        todo.clear();

                        //intentional fall-through

                    case FINISH:

                        success = true;

                        //intentional fall-through

                    case NO_DATA:

                        if (!todo.isEmpty()) {

                            in.println();

                            in.println(todo.get(0).description());

                        }

                        break OUTER;

                }

            }

            if (repaint) {

                in.redrawLine();

                in.flush();

            }

            return success;

        } catch (IOException ex) {

            throw new IllegalStateException(ex);

        }

    }

    private CompletionTask.Result doPrintFullDocumentation(List<CompletionTask> todo, List<String> doc, boolean command) {

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

            Terminal term = in.getTerminal();

            int pageHeight = term.getHeight() - NEEDED_LINES;

            List<CompletionTask> thisTODO = new ArrayList<>();

            for (Iterator<String> docIt = doc.iterator(); docIt.hasNext(); ) {

                String currentDoc = docIt.next();

                String[] lines = currentDoc.split("\n");

                int firstLine = 0;

                while (firstLine < lines.length) {

                    boolean first = firstLine == 0;

                    String[] thisPageLines =

                            Arrays.copyOfRange(lines,

                                               firstLine,

                                               Math.min(firstLine + pageHeight, lines.length));

                    thisTODO.add(new CompletionTask() {

                        @Override

                        public String description() {

                            String key =  !first ? "jshell.console.see.next.page"

                                                 : command ? "jshell.console.see.next.command.doc"

                                                           : "jshell.console.see.next.javadoc";

                            return repl.getResourceString(key);

                        }

                        @Override

                        public Result perform(String text, int cursor) throws IOException {

                            in.println();

                            for (String line : thisPageLines) {

                                in.println(line);

                            }

                            return Result.FINISH;

                        }

                    });

                    firstLine += pageHeight;

                }

            }

            todo.addAll(0, thisTODO);

            return CompletionTask.Result.CONTINUE;

        }

        return CompletionTask.Result.FINISH;

    }

    //where:

        private static final int NEEDED_LINES = 4;

    private static String commonPrefix(String str1, String str2) {

        for (int i = 0; i < str2.length(); i++) {

            if (!str1.startsWith(str2.substring(0, i + 1))) {

                return str2.substring(0, i);

            }

        }

        return str2;

    }

    private interface CompletionTask {

        public String description();

        public Result perform(String text, int cursor) throws IOException;

        enum Result {

            NO_DATA,

            CONTINUE,

            FINISH,

            SKIP,

            SKIP_NOREPAINT;

        }

    }

    private final class NoopCompletionTask implements CompletionTask {

        @Override

        public String description() {

            throw new UnsupportedOperationException("Should not get here.");

        }

        @Override

        public Result perform(String text, int cursor) throws IOException {

            return Result.FINISH;

        }

    }

    private final class NoSuchCommandCompletionTask implements CompletionTask {

        @Override

        public String description() {

            throw new UnsupportedOperationException("Should not get here.");

        }

        @Override

        public Result perform(String text, int cursor) throws IOException {

            in.println();

            in.println(repl.getResourceString("jshell.console.no.such.command"));

            in.println();

            return Result.SKIP;

        }

    }

    private final class OrdinaryCompletionTask implements CompletionTask {

        private final List<Suggestion> suggestions;

        private final int anchor;

        private final boolean cont;

        private final boolean smart;

        public OrdinaryCompletionTask(List<Suggestion> suggestions,

                                      int anchor,

                                      boolean cont,

                                      boolean smart) {

            this.suggestions = suggestions;

            this.anchor = anchor;

            this.cont = cont;

            this.smart = smart;

        }

        @Override

        public String description() {

            throw new UnsupportedOperationException("Should not get here.");

        }

        @Override

        public Result perform(String text, int cursor) throws IOException {

            List<CharSequence> toShow;

            if (smart) {

                toShow =

                    suggestions.stream()

                               .filter(Suggestion::matchesType)

                               .map(Suggestion::continuation)

                               .distinct()

                               .collect(Collectors.toList());

            } else {

                toShow =

                    suggestions.stream()

                               .map(Suggestion::continuation)

                               .distinct()

                               .collect(Collectors.toList());

            }

            if (toShow.isEmpty()) {

                return Result.CONTINUE;

            }

            Optional<String> prefix =

                    suggestions.stream()

                               .map(Suggestion::continuation)

                               .reduce(ConsoleIOContext::commonPrefix);

            String prefixStr = prefix.orElse("").substring(cursor - anchor);

            in.putString(prefixStr);

            boolean showItems = toShow.size() > 1 || smart;

            if (showItems) {

                in.println();

                in.printColumns(toShow);

            }

            if (!prefixStr.isEmpty())

                return showItems ? Result.SKIP : Result.SKIP_NOREPAINT;

            return cont ? Result.CONTINUE : Result.FINISH;

        }

    }

    private final class AllSuggestionsCompletionTask implements CompletionTask {

        private final List<Suggestion> suggestions;

        private final int anchor;

        public AllSuggestionsCompletionTask(List<Suggestion> suggestions,

                                            int anchor) {