/*

 * 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.EnumMap;

import java.util.EnumSet;

import java.util.HashMap;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.Set;

import java.util.function.Function;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import java.util.stream.Collectors;

import java.util.stream.Stream;

/**

 * 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("\\{(.*?)\\}");

    // Current mode

    private Mode mode = new Mode("", false); // initial value placeholder during start-up

    // Mapping of mode names to mode modes

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

    public boolean shouldDisplayCommandFluff() {

        return mode.commandFluff;

    }

    public String getPre() {

        return mode.pre;

    }

    public String getPost() {

        return mode.post;

    }

    public String getErrorPre() {

        return mode.errorPre;

    }

    public String getErrorPost() {

        return mode.errorPost;

    }

    public String getFormat(FormatCase fc, FormatWhen fw, FormatAction fa, FormatResolve fr,

            boolean hasName, boolean hasType, boolean hasResult) {

        return mode.getFormat(fc, fw, fa, fr, hasName, hasType, hasResult);

    }

    public String getPrompt(String nextId) {

        return mode.getPrompt(nextId);

    }

    public String getContinuationPrompt(String nextId) {

        return mode.getContinuationPrompt(nextId);

    }

    public boolean setFeedback(JShellTool tool, ArgTokenizer at) {

        return new FormatSetter(tool, at).setFeedback();

    }

    public boolean setField(JShellTool tool, ArgTokenizer at) {

        return new FormatSetter(tool, at).setField();

    }

    public boolean setFormat(JShellTool tool, ArgTokenizer at) {

        return new FormatSetter(tool, at).setFormat();

    }

    public boolean setNewMode(JShellTool tool, ArgTokenizer at) {

        return new FormatSetter(tool, at).setNewMode();

    }

    public boolean setPrompt(JShellTool tool, ArgTokenizer at) {

        return new FormatSetter(tool, at).setPrompt();

    }

    public void printFeedbackHelp(JShellTool tool) {

        new FormatSetter(tool, null).printFeedbackHelp();

    }

    public void printFieldHelp(JShellTool tool) {

        new FormatSetter(tool, null).printFieldHelp();

    }

    public void printFormatHelp(JShellTool tool) {

        new FormatSetter(tool, null).printFormatHelp();

    }

    public void printNewModeHelp(JShellTool tool) {

        new FormatSetter(tool, null).printNewModeHelp();

    }

    public void printPromptHelp(JShellTool tool) {

        new FormatSetter(tool, null).printPromptHelp();

    }

    /**

     * Holds all the context of a mode mode

     */

    private class Mode {

        // Use name of mode mode

        final String name;

        // Display command verification/information

        final boolean commandFluff;

        // event cases: class, method

        final EnumMap<FormatCase, EnumMap<FormatAction, EnumMap<FormatWhen, String>>> cases;

        // action names: add. modified, replaced, ...

        final EnumMap<FormatAction, EnumMap<FormatWhen, String>> actions;

        // resolution status description format with %s for unresolved

        final EnumMap<FormatResolve, EnumMap<FormatWhen, String>> resolves;

        // primary snippet vs update

        final EnumMap<FormatWhen, String> whens;

        // fixed map of how to get format string for a field, given a specific formatting contet

        final EnumMap<FormatField, Function<Context, String>> fields;

        // format wrappers for name, type, and result

        String fname = "%s";

        String ftype = "%s";

        String fresult = "%s";

        // start and end, also used by hard-coded output

        String pre = "|  ";

        String post = "\n";

        String errorPre = "|  Error: ";

        String errorPost = "\n";

        String prompt = "\n-> ";

        String continuationPrompt = ">> ";

        /**

         * The context of a specific mode to potentially display.

         */

        class Context {

            final FormatCase fc;

            final FormatAction fa;

            final FormatResolve fr;

            final FormatWhen fw;

            final boolean hasName;

            final boolean hasType;

            final boolean hasResult;

            Context(FormatCase fc, FormatWhen fw, FormatAction fa, FormatResolve fr,

                    boolean hasName, boolean hasType, boolean hasResult) {

                this.fc = fc;

                this.fa = fa;

                this.fr = fr;

                this.fw = fw;

                this.hasName = hasName;

                this.hasType = hasType;

                this.hasResult = hasResult;

            }

            String when() {

                return whens.get(fw);

            }

            String action() {

                return actions.get(fa).get(fw);

            }

            String resolve() {

                return String.format(resolves.get(fr).get(fw), FormatField.RESOLVE.form);

            }

            String name() {

                return hasName

                        ? String.format(fname, FormatField.NAME.form)

                        : "";

            }

            String type() {

                return hasType

                        ? String.format(ftype, FormatField.TYPE.form)

                        : "";

            }

            String result() {

                return hasResult

                        ? String.format(fresult, FormatField.RESULT.form)

                        : "";

            }

            /**

             * Lookup format based on case, action, and whether it update.

             * Replace fields with context specific formats.

             *

             * @return format string

             */

            String format() {

                String format = cases.get(fc).get(fa).get(fw);

                if (format == null) {

                    return "";

                }

                Matcher m = FIELD_PATTERN.matcher(format);

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

                while (m.find()) {

                    String fieldName = m.group(1).toUpperCase(Locale.US);

                    String sub = null;

                    for (FormatField f : FormatField.values()) {

                        if (f.name().startsWith(fieldName)) {

                            sub = fields.get(f).apply(this);

                            break;

                        }

                    }

                    if (sub != null) {

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

                    }

                }

                m.appendTail(sb);

                return sb.toString();

            }

        }

        {

            // set fixed mappings of fields

            fields = new EnumMap<>(FormatField.class);

            fields.put(FormatField.WHEN, c -> c.when());

            fields.put(FormatField.ACTION, c -> c.action());

            fields.put(FormatField.RESOLVE, c -> c.resolve());

            fields.put(FormatField.NAME, c -> c.name());

            fields.put(FormatField.TYPE, c -> c.type());

            fields.put(FormatField.RESULT, c -> c.result());

            fields.put(FormatField.PRE, c -> pre);

            fields.put(FormatField.POST, c -> post);

            fields.put(FormatField.ERRORPRE, c -> errorPre);

            fields.put(FormatField.ERRORPOST, c -> errorPost);

        }

        /**

         * Set up an empty mode.

         *

         * @param name

         * @param commandFluff True if should display command fluff messages

         */

        Mode(String name, boolean commandFluff) {

            this.name = name;

            this.commandFluff = commandFluff;

            cases = new EnumMap<>(FormatCase.class);

            for (FormatCase fc : FormatCase.values()) {

                EnumMap<FormatAction, EnumMap<FormatWhen, String>> ac = new EnumMap<>(FormatAction.class);

                cases.put(fc, ac);

                for (FormatAction fa : FormatAction.values()) {

                    EnumMap<FormatWhen, String> aw = new EnumMap<>(FormatWhen.class);

                    ac.put(fa, aw);

                    for (FormatWhen fw : FormatWhen.values()) {

                        aw.put(fw, "");

                    }

                }

            }

            actions = new EnumMap<>(FormatAction.class);

            for (FormatAction fa : FormatAction.values()) {

                EnumMap<FormatWhen, String> afw = new EnumMap<>(FormatWhen.class);

                actions.put(fa, afw);

                for (FormatWhen fw : FormatWhen.values()) {

                    afw.put(fw, fa.name() + "-" + fw.name());

                }

            }

            resolves = new EnumMap<>(FormatResolve.class);

            for (FormatResolve fr : FormatResolve.values()) {

                EnumMap<FormatWhen, String> arw = new EnumMap<>(FormatWhen.class);

                resolves.put(fr, arw);

                for (FormatWhen fw : FormatWhen.values()) {

                    arw.put(fw, fr.name() + "-" + fw.name() + ": %s");

                }

            }

            whens = new EnumMap<>(FormatWhen.class);

            for (FormatWhen fw : FormatWhen.values()) {

                whens.put(fw, fw.name());

            }

        }

        /**

         * Set up a copied mode.

         *

         * @param name

         * @param commandFluff True if should display command fluff messages

         * @param m Mode to copy

         */

        Mode(String name, boolean commandFluff, Mode m) {

            this.name = name;

            this.commandFluff = commandFluff;

            cases = new EnumMap<>(FormatCase.class);

            for (FormatCase fc : FormatCase.values()) {

                EnumMap<FormatAction, EnumMap<FormatWhen, String>> ac = new EnumMap<>(FormatAction.class);

                EnumMap<FormatAction, EnumMap<FormatWhen, String>> mc = m.cases.get(fc);

                cases.put(fc, ac);

                for (FormatAction fa : FormatAction.values()) {

                    EnumMap<FormatWhen, String> aw = new EnumMap<>(mc.get(fa));

                    ac.put(fa, aw);

                }

            }

            actions = new EnumMap<>(FormatAction.class);

            for (FormatAction fa : FormatAction.values()) {

                EnumMap<FormatWhen, String> afw = new EnumMap<>(m.actions.get(fa));

                actions.put(fa, afw);

            }

            resolves = new EnumMap<>(FormatResolve.class);

            for (FormatResolve fr : FormatResolve.values()) {

                EnumMap<FormatWhen, String> arw = new EnumMap<>(m.resolves.get(fr));

                resolves.put(fr, arw);

            }

            whens = new EnumMap<>(m.whens);

            this.fname = m.fname;

            this.ftype = m.ftype;

            this.fresult = m.fresult;

            this.pre = m.pre;

            this.post = m.post;

            this.errorPre = m.errorPre;

            this.errorPost = m.errorPost;

            this.prompt = m.prompt;

            this.continuationPrompt = m.continuationPrompt;

        }

        String getFormat(FormatCase fc, FormatWhen fw, FormatAction fa, FormatResolve fr,

                boolean hasName, boolean hasType, boolean hasResult) {

            Context context = new Context(fc, fw, fa, fr,

                    hasName, hasType, hasResult);

            return context.format();

        }

        void setCases(String format, Collection<FormatCase> cc, Collection<FormatAction> ca, Collection<FormatWhen> cw) {

            for (FormatCase fc : cc) {

                EnumMap<FormatAction, EnumMap<FormatWhen, String>> ma = cases.get(fc);

                for (FormatAction fa : ca) {

                    EnumMap<FormatWhen, String> mw = ma.get(fa);

                    for (FormatWhen fw : cw) {

                        mw.put(fw, format);

                    }

                }

            }

        }

        void setActions(String format, Collection<FormatAction> ca, Collection<FormatWhen> cw) {

            for (FormatAction fa : ca) {

                EnumMap<FormatWhen, String> mw = actions.get(fa);

                for (FormatWhen fw : cw) {

                    mw.put(fw, format);

                }

            }

        }

        void setResolves(String format, Collection<FormatResolve> cr, Collection<FormatWhen> cw) {

            for (FormatResolve fr : cr) {

                EnumMap<FormatWhen, String> mw = resolves.get(fr);

                for (FormatWhen fw : cw) {

                    mw.put(fw, format);

                }

            }

        }

        void setWhens(String format, Collection<FormatWhen> cw) {

            for (FormatWhen fw : cw) {

                whens.put(fw, format);

            }

        }

        void setName(String s) {

            fname = s;

        }

        void setType(String s) {

            ftype = s;

        }

        void setResult(String s) {

            fresult = s;

        }

        void setPre(String s) {

            pre = s;

        }

        void setPost(String s) {

            post = s;

        }

        void setErrorPre(String s) {

            errorPre = s;

        }

        void setErrorPost(String s) {

            errorPost = s;

        }

        String getPre() {

            return pre;

        }

        String getPost() {

            return post;

        }

        String getErrorPre() {

            return errorPre;

        }

        String getErrorPost() {

            return errorPost;

        }

        void setPrompts(String prompt, String continuationPrompt) {

            this.prompt = prompt;

            this.continuationPrompt = continuationPrompt;

        }

        String getPrompt(String nextId) {

            return String.format(prompt, nextId);

        }

        String getContinuationPrompt(String nextId) {

            return String.format(continuationPrompt, nextId);

        }

    }

    /**

     * The brace delimited substitutions

     */

    public enum FormatField {

        WHEN,

        ACTION,

        RESOLVE("%1$s"),

        NAME("%2$s"),

        TYPE("%3$s"),

        RESULT("%4$s"),

        PRE,

        POST,

        ERRORPRE,

        ERRORPOST;

        String form;

        FormatField(String s) {

            this.form = s;

        }

        FormatField() {

            this.form = null;

        }

    }

    /**

     * The event cases

     */

    public enum FormatCase {

        IMPORT("import declaration: {action} {name}"),

        CLASS("class, interface, enum, or annotation declaration: {action} {name} {resolve}"),

        INTERFACE("class, interface, enum, or annotation declaration: {action} {name} {resolve}"),

        ENUM("class, interface, enum, or annotation declaration: {action} {name} {resolve}"),

        ANNOTATION("annotation interface declaration: {action} {name} {resolve}"),

        METHOD("method declaration: {action} {name} {type}==parameter-types {resolve}"),

        VARDECL("variable declaration: {action} {name} {type} {resolve}"),

        VARDECLRECOVERABLE("recoverably failed variable declaration: {action} {name} {resolve}"),

        VARINIT("variable declaration with init: {action} {name} {type} {resolve} {result}"),

        VARRESET("variable reset on update: {action} {name}"),

        EXPRESSION("expression: {action}=='Saved to scratch variable' {name} {type} {result}"),

        VARVALUE("variable value expression: {action} {name} {type} {result}"),

        ASSIGNMENT("assign variable: {action} {name} {type} {result}"),

        STATEMENT("statement: {action}");

        String doc;

        private FormatCase(String doc) {

            this.doc = doc;

        }

    }

    /**

     * The event actions

     */

    public enum FormatAction {

        ADDED("snippet has been added"),

        MODIFIED("an existing snippet has been modified"),

        REPLACED("an existing snippet has been replaced with a new snippet"),

        OVERWROTE("an existing snippet has been overwritten"),

        DROPPED("snippet has been dropped"),

        REJECTED("snippet has failed and been rejected");

        String doc;

        private FormatAction(String doc) {