/*

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

 *

 * 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 org.graalvm.compiler.core.match.processor;

import java.io.FileWriter;

import java.io.IOException;

import java.io.PrintWriter;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import javax.annotation.processing.AbstractProcessor;

import javax.annotation.processing.Filer;

import javax.annotation.processing.RoundEnvironment;

import javax.annotation.processing.SupportedAnnotationTypes;

import javax.lang.model.SourceVersion;

import javax.lang.model.element.AnnotationMirror;

import javax.lang.model.element.AnnotationValue;

import javax.lang.model.element.Element;

import javax.lang.model.element.ElementKind;

import javax.lang.model.element.ExecutableElement;

import javax.lang.model.element.Modifier;

import javax.lang.model.element.Name;

import javax.lang.model.element.PackageElement;

import javax.lang.model.element.TypeElement;

import javax.lang.model.element.VariableElement;

import javax.lang.model.type.MirroredTypeException;

import javax.lang.model.type.TypeMirror;

import javax.lang.model.util.AbstractAnnotationValueVisitor7;

import javax.lang.model.util.ElementFilter;

import javax.lang.model.util.Types;

import javax.tools.Diagnostic.Kind;

import javax.tools.FileObject;

import javax.tools.JavaFileObject;

import javax.tools.StandardLocation;

import org.graalvm.compiler.core.gen.NodeMatchRules;

import org.graalvm.compiler.core.match.ComplexMatchResult;

import org.graalvm.compiler.core.match.MatchRule;

import org.graalvm.compiler.core.match.MatchRules;

import org.graalvm.compiler.core.match.MatchStatement;

import org.graalvm.compiler.core.match.MatchStatementSet;

import org.graalvm.compiler.core.match.MatchableNode;

import org.graalvm.compiler.core.match.MatchableNodes;

import org.graalvm.compiler.debug.GraalError;

import org.graalvm.compiler.graph.Position;

import org.graalvm.compiler.nodes.ValueNode;

import org.graalvm.compiler.serviceprovider.ServiceProvider;

/**

 * Processes classes annotated with {@link MatchRule}. A {@link MatchStatementSet} service is

 * generated for each top level class containing at least one such field. These service objects can

 * be retrieved as follows:

 *

 * <pre>

 *     Iterable<MatchStatementSet> sl = GraalServices.load(MatchStatementSet.class);

 *     for (MatchStatementSet rules : sl) {

 *         ...

 *     }

 * </pre>

 */

@SupportedAnnotationTypes({"org.graalvm.compiler.core.match.MatchRule", "org.graalvm.compiler.core.match.MatchRules", "org.graalvm.compiler.core.match.MatchableNode",

                "org.graalvm.compiler.core.match.MatchableNodes"})

public class MatchProcessor extends AbstractProcessor {

    public MatchProcessor() {

    }

    @Override

    public SourceVersion getSupportedSourceVersion() {

        return SourceVersion.latest();

    }

    private final Set<Element> processedMatchRule = new HashSet<>();

    private final Set<Element> processedMatchableNode = new HashSet<>();

    private static class RuleParseError extends RuntimeException {

        private static final long serialVersionUID = 6456128283609257490L;

        RuleParseError(String format, Object... args) {

            super(String.format(format, args));

        }

    }

    private static final Pattern tokenizer = Pattern.compile("\\s*([()=]|[A-Za-z][A-Za-z0-9]*)\\s*");

    private class RuleParser {

        private ArrayList<TypeDescriptor> capturedTypes = new ArrayList<>();

        private ArrayList<String> capturedNames = new ArrayList<>();

        private final String[] tokens;

        private int current;

        private MatchDescriptor matchDescriptor;

        private final Set<Element> originatingElements = new HashSet<>();

        private Set<String> requiredPackages = new HashSet<>();

        RuleParser(String rule) {

            Matcher m = tokenizer.matcher(rule);

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

            int end = 0;

            while (m.lookingAt()) {

                list.add(m.group(1));

                end = m.end();

                m.region(m.end(), m.regionEnd());

            }

            if (end != m.regionEnd()) {

                throw new RuleParseError("Unexpected tokens :" + rule.substring(m.end(), m.regionEnd()));

            }

            tokens = list.toArray(new String[0]);

            matchDescriptor = parseExpression();

            if (!done()) {

                throw new RuleParseError("didn't consume all tokens");

            }

            capturedNames.add(0, "root");

            capturedTypes.add(0, matchDescriptor.nodeType);

        }

        String next() {

            return tokens[current++];

        }

        String peek(String name) {

            if (current >= tokens.length) {

                if (name == null) {

                    throw new RuleParseError("Out of tokens");

                }

                throw new RuleParseError("Out of tokens looking for %s", name);

            }

            return tokens[current];

        }

        boolean done() {

            return current == tokens.length;

        }

        private MatchDescriptor parseExpression() {

            if (peek("(").equals("(")) {

                next();

                MatchDescriptor descriptor = parseType(true);

                for (int n = 0; n < descriptor.nodeType.inputs.length; n++) {

                    if (peek("(").equals("(")) {

                        descriptor.inputs[n] = parseExpression();

                    } else {

                        descriptor.inputs[n] = parseType(false);

                    }

                }

                for (int n = 0; n < descriptor.nodeType.inputs.length; n++) {

                    if (descriptor.inputs[n] == null) {

                        throw new RuleParseError("not enough inputs for " + descriptor.name);

                    }

                }

                if (peek(")").equals(")")) {

                    next();

                    return descriptor;

                }

                throw new RuleParseError("Too many arguments to " + descriptor.nodeType.nodeClass);

            }

            throw new RuleParseError("Extra tokens following match pattern: " + peek(null));

        }

        private MatchDescriptor parseType(boolean forExpression) {

            TypeDescriptor type = null;

            String name = null;

            if (Character.isUpperCase(peek("node type or name").charAt(0))) {

                String token = next();

                type = knownTypes.get(token);

                if (type == null) {

                    throw new RuleParseError("Unknown node type: " + token);

                }

                if (peek("=").equals("=")) {

                    next();

                    name = next();

                }

                originatingElements.addAll(type.originatingElements);

            } else if (Character.isLowerCase(peek("name").charAt(0))) {

                name = next();

                type = valueType;

            } else {

                throw new RuleParseError("Unexpected token \"%s\" when looking for name or node type", peek(null));

            }

            requiredPackages.add(type.nodePackage);

            if (name != null) {

                if (!capturedNames.contains(name)) {

                    capturedNames.add(name);

                    capturedTypes.add(type);

                } else {

                    int index = capturedNames.indexOf(name);

                    if (capturedTypes.get(index) != type) {

                        throw new RuleParseError("Captured node \"%s\" has differing types", name);

                    }

                }

            }

            return new MatchDescriptor(type, name, forExpression);

        }

        List<String> generateVariants() {

            return matchDescriptor.generateVariants();

        }

        /**

         * Recursively accumulate any required Position declarations.

         */

        void generatePositionDeclarations(EconomicSet<String> declarations) {

            matchDescriptor.generatePositionDeclarations(declarations);

        }

        /**

         *

         * @return the list of node types which are captured by name

         */

        public ArrayList<TypeDescriptor> capturedTypes() {

            return capturedTypes;

        }

        public ArrayList<String> capturedNames() {

            return capturedNames;

        }

    }

    /**

     * Set to true to enable logging to a local file during annotation processing. There's no normal

     * channel for any debug messages and debugging annotation processors requires some special

     * setup.

     */

    private static final boolean DEBUG = false;

    private PrintWriter log;

    /**

     * Logging facility for debugging the annotation processor.

     */

    private PrintWriter getLog() {

        if (log == null) {

            try {

                // Create the log file within the generated source directory so it's easy to find.

                // /tmp isn't platform independent and java.io.tmpdir can map anywhere, particularly

                // on the mac.

                FileObject file = processingEnv.getFiler().createResource(StandardLocation.SOURCE_OUTPUT, "", getClass().getSimpleName() + "log");

                log = new PrintWriter(new FileWriter(file.toUri().getPath(), true));

            } catch (IOException e) {

                // Do nothing

            }

        }

        return log;

    }

    private void logMessage(String format, Object... args) {

        if (!DEBUG) {

            return;

        }

        PrintWriter bw = getLog();

        if (bw != null) {

            bw.printf(format, args);

            bw.flush();

        }

    }

    private void logException(Throwable t) {

        if (!DEBUG) {

            return;

        }

        PrintWriter bw = getLog();

        if (bw != null) {

            t.printStackTrace(bw);

            bw.flush();

        }

    }

    /**

     * Bugs in an annotation processor can cause silent failure so try to report any exception

     * throws as errors.

     */

    private void reportExceptionThrow(Element element, Throwable t) {

        if (element != null) {

            logMessage("throw for %s:\n", element);

        }

        logException(t);

        errorMessage(element, "Exception throw during processing: %s %s", t, Arrays.toString(Arrays.copyOf(t.getStackTrace(), 4)));

    }

    static class TypeDescriptor {

        final TypeMirror mirror;

        /**

         * The name uses in match expressions to refer to this type.

         */

        final String shortName;

        /**

         * The simple name of the {@link ValueNode} class represented by this type.

         */

        final String nodeClass;

        /**

         * The package of {@link ValueNode} class represented by this type.

         */

        final String nodePackage;

        /**

         * The matchable inputs of the node.

         */

        final String[] inputs;

        /**

         * Should swapped variants of this match be generated. The user of the match is expected to

         * compensate for any ordering differences in compare which are commutative but require

         * reinterpreting the condition in that case.

         */

        final boolean commutative;

        /**

         * Can multiple users of this node subsume it. Constants can be swallowed into a match even

         * if there are multiple users.

         */

        final boolean shareable;

        final Set<Element> originatingElements = new HashSet<>();

        TypeDescriptor(TypeMirror mirror, String shortName, String nodeClass, String nodePackage, String[] inputs, boolean commutative, boolean shareable) {

            this.mirror = mirror;

            this.shortName = shortName;

            this.nodeClass = nodeClass;

            this.nodePackage = nodePackage;

            this.inputs = inputs;

            this.commutative = commutative;

            this.shareable = shareable;

            assert !commutative || inputs.length == 2;

        }

    }

    /**

     * The types which are know for purpose of parsing MatchRule expressions.

     */

    EconomicMap<String, TypeDescriptor> knownTypes = EconomicMap.create(Equivalence.DEFAULT);

    private TypeDescriptor valueType;

    private TypeMirror matchRulesTypeMirror;

    private TypeMirror matchRuleTypeMirror;

    private TypeMirror matchableNodeTypeMirror;

    private TypeMirror matchableNodesTypeMirror;

    private void declareType(TypeMirror mirror, String shortName, String nodeClass, String nodePackage, String[] inputs, boolean commutative, boolean shareable, Element element) {

        TypeDescriptor descriptor = new TypeDescriptor(mirror, shortName, nodeClass, nodePackage, inputs, commutative, shareable);

        descriptor.originatingElements.add(element);

        knownTypes.put(shortName, descriptor);

    }

    private String findPackage(Element type) {

        PackageElement p = processingEnv.getElementUtils().getPackageOf(type);

        if (p != null) {

            return p.getQualifiedName().toString();

        }

        throw new GraalError("can't find package for %s", type);

    }

    class MatchDescriptor {

        TypeDescriptor nodeType;

        String name;

        MatchDescriptor[] inputs;

        MatchDescriptor(TypeDescriptor nodeType, String name, boolean forExpression) {

            this.nodeType = nodeType;

            this.name = name;

            if (forExpression) {

                this.inputs = new MatchDescriptor[nodeType.inputs.length];

            } else {

                this.inputs = new MatchDescriptor[0];

            }

        }

        public void generatePositionDeclarations(EconomicSet<String> declarations) {

            if (inputs.length == 0) {

                return;

            }

            declarations.add(generatePositionDeclaration());

            for (MatchDescriptor desc : inputs) {

                desc.generatePositionDeclarations(declarations);

            }

        }

        List<String> recurseVariants(int index) {

            if (inputs.length == 0) {

                return new ArrayList<>();

            }

            List<String> currentVariants = inputs[index].generateVariants();

            if (index == inputs.length - 1) {

                return currentVariants;

            }

            List<String> subVariants = recurseVariants(index + 1);

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

            for (String current : currentVariants) {

                for (String sub : subVariants) {

                    result.add(current + ", " + sub);

                    if (nodeType.commutative) {

                        result.add(sub + ", " + current);

                    }

                }

            }

            return result;

        }

        /**

         * Recursively generate all the variants of this rule pattern. Currently that just means to

         * swap the inputs for commutative rules, producing all possible permutations.

         *

         * @return a list of Strings which will construct pattern matchers for this rule.

         */

        List<String> generateVariants() {

            String prefix = formatPrefix();

            String suffix = formatSuffix();

            ArrayList<String> variants = new ArrayList<>();

            if (inputs.length > 0) {

                for (String var : recurseVariants(0)) {

                    variants.add(prefix + ", " + var + suffix);

                }

            } else {

                assert inputs.length == 0;

                variants.add(prefix + suffix);

            }

            return variants;

        }

        private String formatPrefix() {

            if (nodeType == valueType) {

                return String.format("new MatchPattern(%s, false", name != null ? ("\"" + name + "\"") : "null");

            } else {

                return String.format("new MatchPattern(%s.class, %s", nodeType.nodeClass, name != null ? ("\"" + name + "\"") : "null");

            }

        }

        private String formatSuffix() {

            if (nodeType != null) {

                if (inputs.length != nodeType.inputs.length) {

                    return ", true)";

                } else {

                    if (nodeType.inputs.length > 0) {

                        return ", " + nodeType.nodeClass + "_positions, " + !nodeType.shareable + ")";

                    }

                    if (nodeType.shareable) {

                        return ", false)";

                    }

                }

            }

            return ")";

        }

        String generatePositionDeclaration() {

            return String.format("Position[] %s_positions = MatchRuleRegistry.findPositions(%s.TYPE, new String[]{\"%s\"});", nodeType.nodeClass, nodeType.nodeClass,

                            String.join("\", \"", nodeType.inputs));

        }

    }

    /**

     * Strip the package off a class name leaving the full class name including any outer classes.

     */

    private String fullClassName(Element element) {

        assert element.getKind() == ElementKind.CLASS || element.getKind() == ElementKind.INTERFACE : element;

        String pkg = findPackage(element);

        return ((TypeElement) element).getQualifiedName().toString().substring(pkg.length() + 1);

    }

    private void createFiles(MatchRuleDescriptor info) {

        String pkg = ((PackageElement) info.topDeclaringType.getEnclosingElement()).getQualifiedName().toString();

        Name topDeclaringClass = info.topDeclaringType.getSimpleName();

        String matchStatementClassName = topDeclaringClass + "_" + MatchStatementSet.class.getSimpleName();

        Element[] originatingElements = info.originatingElements.toArray(new Element[info.originatingElements.size()]);

        Types typeUtils = typeUtils();

        Filer filer = processingEnv.getFiler();

        try (PrintWriter out = createSourceFile(pkg, matchStatementClassName, filer, originatingElements)) {

            out.println("// CheckStyle: stop header check");

            out.println("// CheckStyle: stop line length check");

            out.println("// GENERATED CONTENT - DO NOT EDIT");

            out.println("// Source: " + topDeclaringClass + ".java");

            out.println("package " + pkg + ";");

            out.println("");

            out.println("import java.util.*;");

            out.println("import " + MatchStatementSet.class.getPackage().getName() + ".*;");

            out.println("import " + NodeMatchRules.class.getName() + ";");

            out.println("import " + Position.class.getName() + ";");

            out.println("import " + ServiceProvider.class.getName() + ";");

            for (String p : info.requiredPackages) {

                out.println("import " + p + ".*;");

            }

            out.println("");