/*

 *

 * This software is distributable under the BSD license. See the terms of the

 * BSD license in the documentation provided with this software.

 *

 */

package jdk.internal.org.jline.reader.impl;

import java.io.Flushable;

import java.io.IOError;

import java.io.IOException;

import java.io.InputStream;

import java.io.InterruptedIOException;

import java.time.Instant;

import java.util.*;

import java.util.Map.Entry;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.function.*;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import java.util.stream.Collectors;

import java.util.stream.StreamSupport;

import jdk.internal.org.jline.keymap.BindingReader;

import jdk.internal.org.jline.keymap.KeyMap;

import jdk.internal.org.jline.reader.*;

import jdk.internal.org.jline.reader.Parser.ParseContext;

import jdk.internal.org.jline.reader.impl.history.DefaultHistory;

import jdk.internal.org.jline.terminal.*;

import jdk.internal.org.jline.terminal.Attributes.ControlChar;

import jdk.internal.org.jline.terminal.Terminal.Signal;

import jdk.internal.org.jline.terminal.Terminal.SignalHandler;

import jdk.internal.org.jline.utils.AttributedString;

import jdk.internal.org.jline.utils.AttributedStringBuilder;

import jdk.internal.org.jline.utils.AttributedStyle;

import jdk.internal.org.jline.utils.Curses;

import jdk.internal.org.jline.utils.Display;

import jdk.internal.org.jline.utils.InfoCmp.Capability;

import jdk.internal.org.jline.utils.Levenshtein;

import jdk.internal.org.jline.utils.Log;

import jdk.internal.org.jline.utils.Status;

import jdk.internal.org.jline.utils.WCWidth;

import static jdk.internal.org.jline.keymap.KeyMap.alt;

import static jdk.internal.org.jline.keymap.KeyMap.ctrl;

import static jdk.internal.org.jline.keymap.KeyMap.del;

import static jdk.internal.org.jline.keymap.KeyMap.esc;

import static jdk.internal.org.jline.keymap.KeyMap.range;

import static jdk.internal.org.jline.keymap.KeyMap.translate;

/**

 * A reader for terminal applications. It supports custom tab-completion,

 * saveable command history, and command line editing.

 *

 * @author <a href="mailto:mwp1@cornell.edu">Marc Prud'hommeaux</a>

 * @author <a href="mailto:jason@planet57.com">Jason Dillon</a>

 * @author <a href="mailto:gnodet@gmail.com">Guillaume Nodet</a>

 */

@SuppressWarnings("StatementWithEmptyBody")

public class LineReaderImpl implements LineReader, Flushable

{

    public static final char NULL_MASK = 0;

    public static final int TAB_WIDTH = 4;

    public static final String DEFAULT_WORDCHARS = "*?_-.[]~=/&;!#$%^(){}<>";

    public static final String DEFAULT_REMOVE_SUFFIX_CHARS = " \t\n;&|";

    public static final String DEFAULT_COMMENT_BEGIN = "#";

    public static final String DEFAULT_SEARCH_TERMINATORS = "\033\012";

    public static final String DEFAULT_BELL_STYLE = "";

    public static final int    DEFAULT_LIST_MAX = 100;

    public static final int    DEFAULT_ERRORS = 2;

    public static final long   DEFAULT_BLINK_MATCHING_PAREN = 500L;

    public static final long   DEFAULT_AMBIGUOUS_BINDING = 1000L;

    public static final String DEFAULT_SECONDARY_PROMPT_PATTERN = "%M> ";

    public static final String DEFAULT_OTHERS_GROUP_NAME = "others";

    public static final String DEFAULT_ORIGINAL_GROUP_NAME = "original";

    public static final String DEFAULT_COMPLETION_STYLE_STARTING = "36";    // cyan

    public static final String DEFAULT_COMPLETION_STYLE_DESCRIPTION = "90"; // dark gray

    public static final String DEFAULT_COMPLETION_STYLE_GROUP = "35;1";     // magenta

    public static final String DEFAULT_COMPLETION_STYLE_SELECTION = "7";    // inverted

    private static final int MIN_ROWS = 3;

    public static final String BRACKETED_PASTE_ON = "\033[?2004h";

    public static final String BRACKETED_PASTE_OFF = "\033[?2004l";

    public static final String BRACKETED_PASTE_BEGIN = "\033[200~";

    public static final String BRACKETED_PASTE_END = "\033[201~";

    public static final String FOCUS_IN_SEQ = "\033[I";

    public static final String FOCUS_OUT_SEQ = "\033[O";

    /**

     * Possible states in which the current readline operation may be in.

     */

    protected enum State {

        /**

         * The user is just typing away

         */

        NORMAL,

        /**

         * readLine should exit and return the buffer content

         */

        DONE,

        /**

         * readLine should exit and throw an EOFException

         */

        EOF,

        /**

         * readLine should exit and throw an UserInterruptException

         */

        INTERRUPT

    }

    protected enum ViMoveMode {

        NORMAL,

        YANK,

        DELETE,

        CHANGE

    }

    protected enum BellType {

        NONE,

        AUDIBLE,

        VISIBLE

    }

    //

    // Constructor variables

    //

    /** The terminal to use */

    protected final Terminal terminal;

    /** The application name */

    protected final String appName;

    /** The terminal keys mapping */

    protected final Map<String, KeyMap<Binding>> keyMaps;

    //

    // Configuration

    //

    protected final Map<String, Object> variables;

    protected History history = new DefaultHistory();

    protected Completer completer = null;

    protected Highlighter highlighter = new DefaultHighlighter();

    protected Parser parser = new DefaultParser();

    protected Expander expander = new DefaultExpander();

    //

    // State variables

    //

    protected final Map<Option, Boolean> options = new HashMap<>();

    protected final Buffer buf = new BufferImpl();

    protected final Size size = new Size();

    protected MaskingCallback maskingCallback;

    protected Map<Integer, String> modifiedHistory = new HashMap<>();

    protected Buffer historyBuffer = null;

    protected CharSequence searchBuffer;

    protected StringBuffer searchTerm = null;

    protected boolean searchFailing;

    protected boolean searchBackward;

    protected int searchIndex = -1;

    // Reading buffers

    protected final BindingReader bindingReader;

    /**

     * VI character find

     */

    protected int findChar;

    protected int findDir;

    protected int findTailAdd;

    /**

     * VI history string search

     */

    private int searchDir;

    private String searchString;

    /**

     * Region state

     */

    protected int regionMark;

    protected RegionType regionActive;

    private boolean forceChar;

    private boolean forceLine;

    /**

     * The vi yank buffer

     */

    protected String yankBuffer = "";

    protected ViMoveMode viMoveMode = ViMoveMode.NORMAL;

    protected KillRing killRing = new KillRing();

    protected UndoTree<Buffer> undo = new UndoTree<>(this::setBuffer);

    protected boolean isUndo;

    /*

     * Current internal state of the line reader

     */

    protected State   state = State.DONE;

    protected final AtomicBoolean startedReading = new AtomicBoolean();

    protected boolean reading;

    protected Supplier<AttributedString> post;

    protected Map<String, Widget> builtinWidgets;

    protected Map<String, Widget> widgets;

    protected int count;

    protected int mult;

    protected int universal = 4;

    protected int repeatCount;

    protected boolean isArgDigit;

    protected ParsedLine parsedLine;

    protected boolean skipRedisplay;

    protected Display display;

    protected boolean overTyping = false;

    protected String keyMap;

    protected int smallTerminalOffset = 0;

    public LineReaderImpl(Terminal terminal) throws IOException {

        this(terminal, null, null);

    }

    public LineReaderImpl(Terminal terminal, String appName) throws IOException {

        this(terminal, appName, null);

    }

    public LineReaderImpl(Terminal terminal, String appName, Map<String, Object> variables) {

        Objects.requireNonNull(terminal, "terminal can not be null");

        this.terminal = terminal;

        if (appName == null) {

            appName = "JLine";

        }

        this.appName = appName;

        if (variables != null) {

            this.variables = variables;

        } else {

            this.variables = new HashMap<>();

        }

        this.keyMaps = defaultKeyMaps();

        builtinWidgets = builtinWidgets();

        widgets = new HashMap<>(builtinWidgets);

        bindingReader = new BindingReader(terminal.reader());

    }

    public Terminal getTerminal() {

        return terminal;

    }

    public String getAppName() {

        return appName;

    }

    public Map<String, KeyMap<Binding>> getKeyMaps() {

        return keyMaps;

    }

    public KeyMap<Binding> getKeys() {

        return keyMaps.get(keyMap);

    }

    @Override

    public Map<String, Widget> getWidgets() {

        return widgets;

    }

    @Override

    public Map<String, Widget> getBuiltinWidgets() {

        return Collections.unmodifiableMap(builtinWidgets);

    }

    @Override

    public Buffer getBuffer() {

        return buf;

    }

    @Override

    public void runMacro(String macro) {

        bindingReader.runMacro(macro);

    }

    @Override

    public MouseEvent readMouseEvent() {

        return terminal.readMouseEvent(bindingReader::readCharacter);

    }

    /**

     * Set the completer.

     *

     * @param completer the completer to use

     */

    public void setCompleter(Completer completer) {

        this.completer = completer;

    }

    /**

     * Returns the completer.

     *

     * @return the completer

     */

    public Completer getCompleter() {

        return completer;

    }

    //

    // History

    //

    public void setHistory(final History history) {

        Objects.requireNonNull(history);

        this.history = history;

    }

    public History getHistory() {

        return history;

    }

    //

    // Highlighter

    //

    public void setHighlighter(Highlighter highlighter) {

        this.highlighter = highlighter;

    }

    public Highlighter getHighlighter() {

        return highlighter;

    }

    public Parser getParser() {

        return parser;

    }

    public void setParser(Parser parser) {

        this.parser = parser;

    }

    @Override

    public Expander getExpander() {

        return expander;

    }

    public void setExpander(Expander expander) {

        this.expander = expander;

    }

    //

    // Line Reading

    //

    /**

     * Read the next line and return the contents of the buffer.

     *

     * @return          A line that is read from the terminal, can never be null.

     */

    public String readLine() throws UserInterruptException, EndOfFileException {

        return readLine(null, null, (MaskingCallback) null, null);

    }

    /**

     * Read the next line with the specified character mask. If null, then

     * characters will be echoed. If 0, then no characters will be echoed.

     *

     * @param mask      The mask character, <code>null</code> or <code>0</code>.

     * @return          A line that is read from the terminal, can never be null.

     */

    public String readLine(Character mask) throws UserInterruptException, EndOfFileException {

        return readLine(null, null, mask, null);

    }

    /**

     * Read a line from the <i>in</i> {@link InputStream}, and return the line

     * (without any trailing newlines).

     *

     * @param prompt    The prompt to issue to the terminal, may be null.

     * @return          A line that is read from the terminal, can never be null.

     */

    public String readLine(String prompt) throws UserInterruptException, EndOfFileException {

        return readLine(prompt, null, (MaskingCallback) null, null);

    }

    /**

     * Read a line from the <i>in</i> {@link InputStream}, and return the line

     * (without any trailing newlines).

     *

     * @param prompt    The prompt to issue to the terminal, may be null.

     * @param mask      The mask character, <code>null</code> or <code>0</code>.

     * @return          A line that is read from the terminal, can never be null.

     */

    public String readLine(String prompt, Character mask) throws UserInterruptException, EndOfFileException {

        return readLine(prompt, null, mask, null);

    }

    /**

     * Read a line from the <i>in</i> {@link InputStream}, and return the line

     * (without any trailing newlines).

     *

     * @param prompt    The prompt to issue to the terminal, may be null.

     * @param mask      The mask character, <code>null</code> or <code>0</code>.

     * @param buffer    A string that will be set for editing.

     * @return          A line that is read from the terminal, can never be null.

     */

    public String readLine(String prompt, Character mask, String buffer) throws UserInterruptException, EndOfFileException {

        return readLine(prompt, null, mask, buffer);

    }

    /**

     * Read a line from the <i>in</i> {@link InputStream}, and return the line

     * (without any trailing newlines).

     *

     * @param prompt      The prompt to issue to the terminal, may be null.

     * @param rightPrompt The prompt to issue to the right of the terminal, may be null.

     * @param mask        The mask character, <code>null</code> or <code>0</code>.

     * @param buffer      A string that will be set for editing.

     * @return            A line that is read from the terminal, can never be null.

     */

    public String readLine(String prompt, String rightPrompt, Character mask, String buffer) throws UserInterruptException, EndOfFileException {

        return readLine(prompt, rightPrompt, mask != null ? new SimpleMaskingCallback(mask) : null, buffer);

    }

    /**

     * Read a line from the <i>in</i> {@link InputStream}, and return the line

     * (without any trailing newlines).

     *

     * @param prompt          The prompt to issue to the terminal, may be null.

     * @param rightPrompt     The prompt to issue to the right of the terminal, may be null.

     * @param maskingCallback The callback used to mask parts of the edited line.

     * @param buffer          A string that will be set for editing.

     * @return                A line that is read from the terminal, can never be null.

     */

    public String readLine(String prompt, String rightPrompt, MaskingCallback maskingCallback, String buffer) throws UserInterruptException, EndOfFileException {

        // prompt may be null

        // maskingCallback may be null

        // buffer may be null

        if (!startedReading.compareAndSet(false, true)) {

            throw new IllegalStateException();

        }

        Thread readLineThread = Thread.currentThread();

        SignalHandler previousIntrHandler = null;

        SignalHandler previousWinchHandler = null;

        SignalHandler previousContHandler = null;

        Attributes originalAttributes = null;

        try {

            this.maskingCallback = maskingCallback;

            /*

             * This is the accumulator for VI-mode repeat count. That is, while in

             * move mode, if you type 30x it will delete 30 characters. This is

             * where the "30" is accumulated until the command is struck.

             */

            repeatCount = 0;

            mult = 1;

            regionActive = RegionType.NONE;

            regionMark = -1;

            smallTerminalOffset = 0;

            state = State.NORMAL;

            modifiedHistory.clear();

            setPrompt(prompt);

            setRightPrompt(rightPrompt);

            buf.clear();

            if (buffer != null) {

                buf.write(buffer);

            }

            undo.clear();

            parsedLine = null;

            keyMap = MAIN;