/*

 * Copyright (c) 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.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.EnumSet;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Objects;

import java.util.Set;

import java.util.StringJoiner;

import java.util.function.BiConsumer;

import java.util.function.BinaryOperator;

import java.util.function.Consumer;

import java.util.function.Function;

import java.util.function.Supplier;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import java.util.stream.Collector;

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

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

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

import jdk.internal.jshell.tool.JShellTool.CompletionProvider;

import static jdk.internal.jshell.tool.JShellTool.EMPTY_COMPLETION_PROVIDER;

/**

 * Feedback customization support

 *

 * @author Robert Field

 */

class Feedback {

    // Patern for substituted fields within a customized format string

    private static final Pattern FIELD_PATTERN = Pattern.compile("\\{(.*?)\\}");

    // Internal field name for truncation length

    private static final String TRUNCATION_FIELD = "<truncation>";

    // For encoding to Properties String

    private static final String RECORD_SEPARATOR = "\u241E";

    // Current mode -- initial value is placeholder during start-up

    private Mode mode = new Mode("");

    // Retained current mode -- for checks

    private Mode retainedCurrentMode = null;

    // Mapping of mode name to mode

    private final Map<String, Mode> modeMap = new HashMap<>();

    // Mapping of mode names to encoded retained mode

    private final Map<String, String> retainedMap = new HashMap<>();

    // Mapping selector enum names to enums

    private final Map<String, Selector<?>> selectorMap = new HashMap<>();

    private static final long ALWAYS = bits(FormatCase.all, FormatAction.all, FormatWhen.all,

            FormatResolve.all, FormatUnresolved.all, FormatErrors.all);

    private static final long ANY = 0L;

    public boolean shouldDisplayCommandFluff() {

        return mode.commandFluff;

    }

    public String getPre() {

        return mode.format("pre", ANY);

    }

    public String getPost() {

        return mode.format("post", ANY);

    }

    public String getErrorPre() {

        return mode.format("errorpre", ANY);

    }

    public String getErrorPost() {

        return mode.format("errorpost", ANY);

    }

    public String format(FormatCase fc, FormatAction fa, FormatWhen fw,

                    FormatResolve fr, FormatUnresolved fu, FormatErrors fe,

                    String name, String type, String value, String unresolved, List<String> errorLines) {

        return mode.format(fc, fa, fw, fr, fu, fe,

                name, type, value, unresolved, errorLines);

    }

    public String format(String field, FormatCase fc, FormatAction fa, FormatWhen fw,

                    FormatResolve fr, FormatUnresolved fu, FormatErrors fe,

                    String name, String type, String value, String unresolved, List<String> errorLines) {

        return mode.format(field, fc, fa, fw, fr, fu, fe,

                name, type, value, unresolved, errorLines);

    }

    public String truncateVarValue(String value) {

        return mode.truncateVarValue(value);

    }

    public String getPrompt(String nextId) {

        return mode.getPrompt(nextId);

    }

    public String getContinuationPrompt(String nextId) {

        return mode.getContinuationPrompt(nextId);

    }

    public boolean setFeedback(MessageHandler messageHandler, ArgTokenizer at, Consumer<String> retainer) {

        return new Setter(messageHandler, at).setFeedback(retainer);

    }

    public boolean setFormat(MessageHandler messageHandler, ArgTokenizer at) {

        return new Setter(messageHandler, at).setFormat();

    }

    public boolean setTruncation(MessageHandler messageHandler, ArgTokenizer at) {

        return new Setter(messageHandler, at).setTruncation();

    }

    public boolean setMode(MessageHandler messageHandler, ArgTokenizer at, Consumer<String> retainer) {

        return new Setter(messageHandler, at).setMode(retainer);

    }

    public boolean setPrompt(MessageHandler messageHandler, ArgTokenizer at) {

        return new Setter(messageHandler, at).setPrompt();

    }

    public boolean restoreEncodedModes(MessageHandler messageHandler, String encoded) {

        return new Setter(messageHandler, new ArgTokenizer("<init>", "")).restoreEncodedModes(encoded);

    }

    public void markModesReadOnly() {

        modeMap.values().stream()

                .forEach(m -> m.readOnly = true);

    }

    JShellTool.CompletionProvider modeCompletions() {

        return modeCompletions(EMPTY_COMPLETION_PROVIDER);

    }

    JShellTool.CompletionProvider modeCompletions(CompletionProvider successor) {

        return new ContinuousCompletionProvider(

                () -> modeMap.keySet().stream()

                        .collect(toMap(Function.identity(), m -> successor)),

                PERFECT_MATCHER);

    }

    {

        for (FormatCase e : FormatCase.all)

            selectorMap.put(e.name().toLowerCase(Locale.US), e);

        for (FormatAction e : FormatAction.all)

            selectorMap.put(e.name().toLowerCase(Locale.US), e);

        for (FormatResolve e : FormatResolve.all)

            selectorMap.put(e.name().toLowerCase(Locale.US), e);

        for (FormatUnresolved e : FormatUnresolved.all)

            selectorMap.put(e.name().toLowerCase(Locale.US), e);

        for (FormatErrors e : FormatErrors.all)

            selectorMap.put(e.name().toLowerCase(Locale.US), e);

        for (FormatWhen e : FormatWhen.all)

            selectorMap.put(e.name().toLowerCase(Locale.US), e);

    }

    private static class SelectorSets {

        Set<FormatCase> cc;

        Set<FormatAction> ca;

        Set<FormatWhen> cw;

        Set<FormatResolve> cr;

        Set<FormatUnresolved> cu;

        Set<FormatErrors> ce;

    }

    /**

     * Holds all the context of a mode mode

     */

    private static class Mode {

        // Name of mode

        final String name;

        // Display command verification/information

        boolean commandFluff;

        // Event cases: class, method, expression, ...

        final Map<String, List<Setting>> cases;

        boolean readOnly = false;

        String prompt = "\n-> ";

        String continuationPrompt = ">> ";

        static class Setting {

            final long enumBits;

            final String format;

            Setting(long enumBits, String format) {

                this.enumBits = enumBits;

                this.format = format;

            }

            @Override

            public boolean equals(Object o) {

                if (o instanceof Setting) {

                    Setting ing = (Setting) o;

                    return enumBits == ing.enumBits && format.equals(ing.format);

                } else {

                    return false;

                }

            }

            @Override

            public int hashCode() {

                int hash = 7;

                hash = 67 * hash + (int) (this.enumBits ^ (this.enumBits >>> 32));

                hash = 67 * hash + Objects.hashCode(this.format);

                return hash;

            }

        }

        /**

         * Set up an empty mode.

         *

         * @param name

         * @param commandFluff True if should display command fluff messages

         */

        Mode(String name) {

            this.name = name;

            this.cases = new HashMap<>();

            add("name",       new Setting(ALWAYS, "%1$s"));

            add("type",       new Setting(ALWAYS, "%2$s"));

            add("value",      new Setting(ALWAYS, "%3$s"));

            add("unresolved", new Setting(ALWAYS, "%4$s"));

            add("errors",     new Setting(ALWAYS, "%5$s"));

            add("err",        new Setting(ALWAYS, "%6$s"));

            add("errorline",  new Setting(ALWAYS, "    {err}%n"));

            add("pre",        new Setting(ALWAYS, "|  "));

            add("post",       new Setting(ALWAYS, "%n"));

            add("errorpre",   new Setting(ALWAYS, "|  "));

            add("errorpost",  new Setting(ALWAYS, "%n"));

        }

        /**

         * Set up a copied mode.

         *

         * @param name

         * @param m Mode to copy, or null for no fresh

         */

        Mode(String name, Mode m) {

            this.name = name;

            this.commandFluff = m.commandFluff;

            this.prompt = m.prompt;

            this.continuationPrompt = m.continuationPrompt;

            this.cases = new HashMap<>();

            m.cases.entrySet().stream()

                    .forEach(fes -> fes.getValue()

                    .forEach(ing -> add(fes.getKey(), ing)));

        }

        /**

         * Set up a mode reconstituted from a preferences string.

         *

         * @param it the encoded Mode broken into String chunks, may contain

         * subsequent encoded modes

         */

        Mode(Iterator<String> it) {

            this.name = it.next();

            this.commandFluff = Boolean.parseBoolean(it.next());

            this.prompt = it.next();

            this.continuationPrompt = it.next();

            cases = new HashMap<>();

            String field;

            while (!(field = it.next()).equals("***")) {

                String open = it.next();

                assert open.equals("(");

                List<Setting> settings = new ArrayList<>();

                String bits;

                while (!(bits = it.next()).equals(")")) {

                    String format = it.next();

                    Setting ing = new Setting(Long.parseLong(bits), format);

                    settings.add(ing);

                }

                cases.put(field, settings);

            }

        }

        @Override

        public boolean equals(Object o) {

            if (o instanceof Mode) {

                Mode m = (Mode) o;

                return name.equals((m.name))

                        && commandFluff == m.commandFluff

                        && prompt.equals((m.prompt))

                        && continuationPrompt.equals((m.continuationPrompt))

                        && cases.equals((m.cases));

            } else {

                return false;

            }

        }

        @Override

        public int hashCode() {

            return Objects.hashCode(name);

        }

        /**

         * Set if this mode displays informative/confirmational messages on

         * commands.

         *

         * @param fluff the value to set

         */

        void setCommandFluff(boolean fluff) {

            commandFluff = fluff;

        }

        /**

         * Encodes the mode into a String so it can be saved in Preferences.

         *

         * @return the string representation

         */

        String encode() {

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

            el.add(name);

            el.add(String.valueOf(commandFluff));

            el.add(prompt);

            el.add(continuationPrompt);

            for (Entry<String, List<Setting>> es : cases.entrySet()) {

                el.add(es.getKey());

                el.add("(");

                for (Setting ing : es.getValue()) {

                    el.add(String.valueOf(ing.enumBits));

                    el.add(ing.format);

                }

                el.add(")");

            }

            el.add("***");

            return String.join(RECORD_SEPARATOR, el);

        }

        private void add(String field, Setting ing) {

            List<Setting> settings = cases.get(field);

            if (settings == null) {

                settings = new ArrayList<>();

                cases.put(field, settings);

            } else {

                // remove obscured settings

                long mask = ~ing.enumBits;

                settings.removeIf(t -> (t.enumBits & mask) == 0);

            }

            settings.add(ing);

        }

        void set(String field,

                Collection<FormatCase> cc, Collection<FormatAction> ca, Collection<FormatWhen> cw,

                Collection<FormatResolve> cr, Collection<FormatUnresolved> cu, Collection<FormatErrors> ce,

                String format) {

            long bits = bits(cc, ca, cw, cr, cu, ce);

            set(field, bits, format);

        }

        void set(String field, long bits, String format) {

            add(field, new Setting(bits, format));

        }

        /**

         * Lookup format Replace fields with context specific formats.

         *

         * @return format string

         */

        String format(String field, long bits) {

            List<Setting> settings = cases.get(field);

            if (settings == null) {

                return ""; //TODO error?

            }

            String format = null;

            for (int i = settings.size() - 1; i >= 0; --i) {

                Setting ing = settings.get(i);

                long mask = ing.enumBits;

                if ((bits & mask) == bits) {

                    format = ing.format;

                    break;

                }

            }

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

                return "";

            }

            Matcher m = FIELD_PATTERN.matcher(format);

            StringBuffer sb = new StringBuffer(format.length());

            while (m.find()) {

                String fieldName = m.group(1);

                String sub = format(fieldName, bits);

                m.appendReplacement(sb, Matcher.quoteReplacement(sub));

            }

            m.appendTail(sb);

            return sb.toString();

        }

        String truncateVarValue(String value) {

            return truncateValue(value,

                    bits(FormatCase.VARVALUE, FormatAction.ADDED,

                            FormatWhen.PRIMARY, FormatResolve.OK,

                            FormatUnresolved.UNRESOLVED0, FormatErrors.ERROR0));

        }

        String truncateValue(String value, long bits) {

            if (value==null) {

                return "";

            } else {

                // Retrieve the truncation length

                String truncField = format(TRUNCATION_FIELD, bits);

                if (truncField.isEmpty()) {

                    // No truncation set, use whole value

                    return value;

                } else {

                    // Convert truncation length to int

                    // this is safe since it has been tested before it is set

                    int trunc = Integer.parseUnsignedInt(truncField);

                    int len = value.length();

                    if (len > trunc) {

                        if (trunc <= 13) {

                            // Very short truncations have no room for "..."

                            return value.substring(0, trunc);

                        } else {

                            // Normal truncation, make total length equal truncation length

                            int endLen = trunc / 3;

                            int startLen = trunc - 5 - endLen;

                            return value.substring(0, startLen) + " ... " + value.substring(len -endLen);

                        }

                    } else {

                        // Within truncation length, use whole value

                        return value;

                    }

                }

            }

        }

        // Compute the display output given full context and values

        String format(FormatCase fc, FormatAction fa, FormatWhen fw,

                    FormatResolve fr, FormatUnresolved fu, FormatErrors fe,

                    String name, String type, String value, String unresolved, List<String> errorLines) {

            return format("display", fc, fa, fw, fr, fu, fe,

                name, type, value, unresolved, errorLines);

        }

        // Compute the display output given full context and values

        String format(String field, FormatCase fc, FormatAction fa, FormatWhen fw,

                    FormatResolve fr, FormatUnresolved fu, FormatErrors fe,

                    String name, String type, String value, String unresolved, List<String> errorLines) {

            // Convert the context into a bit representation used as selectors for store field formats

            long bits = bits(fc, fa, fw, fr, fu, fe);

            String fname = name==null? "" : name;

            String ftype = type==null? "" : type;

            // Compute the representation of value

            String fvalue = truncateValue(value, bits);

            String funresolved = unresolved==null? "" : unresolved;

            String errors = errorLines.stream()

                    .map(el -> String.format(

                            format("errorline", bits),

                            fname, ftype, fvalue, funresolved, "*cannot-use-errors-here*", el))

                    .collect(joining());

            return String.format(

                    format(field, bits),

                    fname, ftype, fvalue, funresolved, errors, "*cannot-use-err-here*");

        }