/*

 * Copyright (c) 2006, 2015, 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 build.tools.symbolgenerator;

import java.io.BufferedReader;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.Writer;

import java.nio.file.DirectoryStream;

import java.nio.file.Files;

import java.nio.file.FileVisitResult;

import java.nio.file.FileVisitor;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.nio.file.attribute.BasicFileAttributes;

import java.util.stream.Stream;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Objects;

import java.util.Set;

import java.util.function.Function;

import java.util.function.Predicate;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import java.util.stream.Collectors;

import com.sun.tools.classfile.AccessFlags;

import com.sun.tools.classfile.Annotation;

import com.sun.tools.classfile.Annotation.Annotation_element_value;

import com.sun.tools.classfile.Annotation.Array_element_value;

import com.sun.tools.classfile.Annotation.Class_element_value;

import com.sun.tools.classfile.Annotation.Enum_element_value;

import com.sun.tools.classfile.Annotation.Primitive_element_value;

import com.sun.tools.classfile.Annotation.element_value;

import com.sun.tools.classfile.Annotation.element_value_pair;

import com.sun.tools.classfile.AnnotationDefault_attribute;

import com.sun.tools.classfile.Attribute;

import com.sun.tools.classfile.Attributes;

import com.sun.tools.classfile.ClassFile;

import com.sun.tools.classfile.ClassWriter;

import com.sun.tools.classfile.ConstantPool;

import com.sun.tools.classfile.ConstantPool.CONSTANT_Class_info;

import com.sun.tools.classfile.ConstantPool.CONSTANT_Double_info;

import com.sun.tools.classfile.ConstantPool.CONSTANT_Float_info;

import com.sun.tools.classfile.ConstantPool.CONSTANT_Integer_info;

import com.sun.tools.classfile.ConstantPool.CONSTANT_Long_info;

import com.sun.tools.classfile.ConstantPool.CONSTANT_String_info;

import com.sun.tools.classfile.ConstantPool.CONSTANT_Utf8_info;

import com.sun.tools.classfile.ConstantPool.CPInfo;

import com.sun.tools.classfile.ConstantPool.InvalidIndex;

import com.sun.tools.classfile.ConstantPoolException;

import com.sun.tools.classfile.ConstantValue_attribute;

import com.sun.tools.classfile.Deprecated_attribute;

import com.sun.tools.classfile.Descriptor;

import com.sun.tools.classfile.Exceptions_attribute;

import com.sun.tools.classfile.Field;

import com.sun.tools.classfile.InnerClasses_attribute;

import com.sun.tools.classfile.InnerClasses_attribute.Info;

import com.sun.tools.classfile.Method;

import com.sun.tools.classfile.RuntimeAnnotations_attribute;

import com.sun.tools.classfile.RuntimeInvisibleAnnotations_attribute;

import com.sun.tools.classfile.RuntimeInvisibleParameterAnnotations_attribute;

import com.sun.tools.classfile.RuntimeParameterAnnotations_attribute;

import com.sun.tools.classfile.RuntimeVisibleAnnotations_attribute;

import com.sun.tools.classfile.RuntimeVisibleParameterAnnotations_attribute;

import com.sun.tools.classfile.Signature_attribute;

import com.sun.tools.javac.jvm.Target;

import com.sun.tools.javac.util.Assert;

import com.sun.tools.javac.util.Pair;

/**

 * A tool for processing the .sym.txt files. It allows to:

 *  * convert the .sym.txt into class/sig files for ct.sym

 *  * in cooperation with the adjacent history Probe, construct .sym.txt files for previous platforms

 *

 * To convert the .sym.txt files to class/sig files from ct.sym, run:

 *     java build.tool.symbolgenerator.CreateSymbols build-ctsym [JOINED_VERSIONS|SEPARATE] <platform-description-file> <target-directory>

 *

 * The <platform-description-file> is a file of this format:

 *     generate platforms <platform-ids-to-generate separate with ':'>

 *     platform version <platform-id1> files <.sym.txt files containing history data for given platform, separate with ':'>

 *     platform version <platform-id2> base <base-platform-id> files <.sym.txt files containing history data for given platform, separate with ':'>

 *

 * The content of platform "<base-platform-id>" is also automatically added to the content of

 * platform "<platform-id2>", unless explicitly excluded in "<platform-id2>"'s .sym.txt files.

 *

 * To create the .sym.txt files, first run the history Probe for all the previous platforms:

 *     <jdk-N>/bin/java build.tools.symbolgenerator.Probe <classes-for-N>

 *

 * Where <classes-for-N> is a name of a file into which the classes from the bootclasspath of <jdk-N>

 * will be written.

 *

 * Then create the <platform-description-file> file and the .sym.txt files like this:

 *     java build.tools.symbolgenerator.CreateSymbols build-description <target-directory> <path-to-a-JDK-root> <include-list-file>

 *                                                    <platform-id1> <target-file-for-platform1> "<none>"

 *                                                    <platform-id2> <target-file-for-platform2> <diff-against-platform2>

 *                                                    <platform-id3> <target-file-for-platform3> <diff-against-platform3>

 *                                                    ...

 *

 * The <include-list-file> is a file that specifies classes that should be included/excluded.

 * Lines that start with '+' represent class or package that should be included, '-' class or package

 * that should be excluded. '/' should be used as package name delimiter, packages should end with '/'.

 * Several include list files may be specified, separated by File.pathSeparator.

 *

 * When <diff-against-platformN> is specified, the .sym.txt files for platform N will only contain

 * differences between platform N and the specified platform. The first platform (denoted F further)

 * that is specified should use literal value "<none>", to have all the APIs of the platform written to

 * the .sym.txt files. If there is an existing platform with full .sym.txt files in the repository,

 * that platform should be used as the first platform to avoid unnecessary changes to the .sym.txt

 * files. The <diff-against-platformN> for platform N should be determined as follows: if N < F, then

 * <diff-against-platformN> should be N + 1. If F < N, then <diff-against-platformN> should be N - 1.

 * If N is a custom/specialized sub-version of another platform N', then <diff-against-platformN> should be N'.

 *

 * To generate the .sym.txt files for OpenJDK 7 and 8:

 *     <jdk-7>/bin/java build.tools.symbolgenerator.Probe OpenJDK7.classes

 *     <jdk-8>/bin/java build.tools.symbolgenerator.Probe OpenJDK8.classes

 *     java build.tools.symbolgenerator.CreateSymbols build-description langtools/make/data/symbols $TOPDIR langtools/make/data/symbols/include.list

 *                                                    8 OpenJDK8.classes '<none>'

 *                                                    7 OpenJDK7.classes 8

 *

 * Note: the versions are expected to be a single character.

 */

public class CreateSymbols {

    //<editor-fold defaultstate="collapsed" desc="ct.sym construction">

    /**Create sig files for ct.sym reading the classes description from the directory that contains

     * {@code ctDescriptionFile}, using the file as a recipe to create the sigfiles.

     */

    @SuppressWarnings("unchecked")

    public void createSymbols(String ctDescriptionFile, String ctSymLocation, CtSymKind ctSymKind) throws IOException {

        ClassList classes = load(Paths.get(ctDescriptionFile));

        splitHeaders(classes);

        for (ClassDescription classDescription : classes) {

            for (ClassHeaderDescription header : classDescription.header) {

                switch (ctSymKind) {

                    case JOINED_VERSIONS:

                        Set<String> jointVersions = new HashSet<>();

                        jointVersions.add(header.versions);

                        limitJointVersion(jointVersions, classDescription.fields);

                        limitJointVersion(jointVersions, classDescription.methods);

                        writeClassesForVersions(ctSymLocation, classDescription, header, jointVersions);

                        break;

                    case SEPARATE:

                        Set<String> versions = new HashSet<>();

                        for (char v : header.versions.toCharArray()) {

                            versions.add("" + v);

                        }

                        writeClassesForVersions(ctSymLocation, classDescription, header, versions);

                        break;

                }

            }

        }

    }

    public static String EXTENSION = ".sig";

    ClassList load(Path ctDescription) throws IOException {

        List<PlatformInput> platforms = new ArrayList<>();

        Set<String> generatePlatforms = null;

        try (LineBasedReader reader = new LineBasedReader(ctDescription)) {

            while (reader.hasNext()) {

                switch (reader.lineKey) {

                    case "generate":

                        String[] platformsAttr = reader.attributes.get("platforms").split(":");

                        generatePlatforms = new HashSet<>(Arrays.asList(platformsAttr));

                        reader.moveNext();

                        break;

                    case "platform":

                        platforms.add(PlatformInput.load(reader));

                        reader.moveNext();

                        break;

                    default:

                        throw new IllegalStateException("Unknown key: " + reader.lineKey);

                }

            }

        }

        Map<String, ClassDescription> classes = new LinkedHashMap<>();

        for (PlatformInput platform: platforms) {

            for (ClassDescription cd : classes.values()) {

                addNewVersion(cd.header, platform.basePlatform, platform.version);

                addNewVersion(cd.fields, platform.basePlatform, platform.version);

                addNewVersion(cd.methods, platform.basePlatform, platform.version);

            }

            for (String input : platform.files) {

                Path inputFile = ctDescription.getParent().resolve(input);

                try (LineBasedReader reader = new LineBasedReader(inputFile)) {

                    while (reader.hasNext()) {

                        String nameAttr = reader.attributes.get("name");

                        ClassDescription cd =

                                classes.computeIfAbsent(nameAttr, n -> new ClassDescription());

                        if ("-class".equals(reader.lineKey)) {

                            removeVersion(cd.header, h -> true, platform.version);

                            reader.moveNext();

                            continue;

                        }

                        cd.read(reader, platform.basePlatform, platform.version);

                    }

                }

            }

        }

        ClassList result = new ClassList();

        for (ClassDescription desc : classes.values()) {

            for (Iterator<ClassHeaderDescription> chdIt = desc.header.iterator(); chdIt.hasNext();) {

                ClassHeaderDescription chd = chdIt.next();

                chd.versions = reduce(chd.versions, generatePlatforms);

                if (chd.versions.isEmpty())

                    chdIt.remove();

            }

            if (desc.header.isEmpty()) {

                continue;

            }

            for (Iterator<MethodDescription> methodIt = desc.methods.iterator(); methodIt.hasNext();) {

                MethodDescription method = methodIt.next();

                method.versions = reduce(method.versions, generatePlatforms);

                if (method.versions.isEmpty())

                    methodIt.remove();

            }

            for (Iterator<FieldDescription> fieldIt = desc.fields.iterator(); fieldIt.hasNext();) {

                FieldDescription field = fieldIt.next();

                field.versions = reduce(field.versions, generatePlatforms);

                if (field.versions.isEmpty())

                    fieldIt.remove();

            }

            result.add(desc);

        }

        return result;

    }

    static final class LineBasedReader implements AutoCloseable {

        private final BufferedReader input;

        public String lineKey;

        public Map<String, String> attributes = new HashMap<>();

        public LineBasedReader(Path input) throws IOException {

            this.input = Files.newBufferedReader(input);

            moveNext();

        }

        public void moveNext() throws IOException {

            String line = input.readLine();

            if (line == null) {

                lineKey = null;

                return ;

            }

            if (line.trim().isEmpty() || line.startsWith("#")) {

                moveNext();

                return ;

            }

            String[] parts = line.split(" ");

            lineKey = parts[0];

            attributes.clear();

            for (int i = 1; i < parts.length; i += 2) {

                attributes.put(parts[i], unquote(parts[i + 1]));

            }

        }

        public boolean hasNext() {

            return lineKey != null;

        }

        @Override

        public void close() throws IOException {

            input.close();

        }

    }

    private static String reduce(String original, String other) {

        Set<String> otherSet = new HashSet<>();

        for (char v : other.toCharArray()) {

            otherSet.add("" + v);

        }

        return reduce(original, otherSet);

    }

    private static String reduce(String original, Set<String> generate) {

        StringBuilder sb = new StringBuilder();

        for (char v : original.toCharArray()) {

            if (generate.contains("" + v)) {

                sb.append(v);

            }

        }

        return sb.toString();

    }

    private static class PlatformInput {

        public final String version;

        public final String basePlatform;

        public final List<String> files;

        public PlatformInput(String version, String basePlatform, List<String> files) {

            this.version = version;

            this.basePlatform = basePlatform;

            this.files = files;

        }

        public static PlatformInput load(LineBasedReader in) throws IOException {

            return new PlatformInput(in.attributes.get("version"),

                                     in.attributes.get("base"),

                                     Arrays.asList(in.attributes.get("files").split(":")));

        }

    }

    static void addNewVersion(Collection<? extends FeatureDescription> features,

                       String baselineVersion,

                       String version) {

        features.stream()

                .filter(f -> f.versions.contains(baselineVersion))

                .forEach(f -> f.versions += version);

    }

    static <T extends FeatureDescription> void removeVersion(Collection<T> features,

                                                             Predicate<T> shouldRemove,

                                                             String version) {

        for (T existing : features) {

            if (shouldRemove.test(existing) && existing.versions.endsWith(version)) {

                existing.versions = existing.versions.replace(version, "");

                return;

            }

        }

    }

    /**Changes to class header of an outer class (like adding a new type parameter) may affect

     * its innerclasses. So if the outer class's header is different for versions A and B, need to

     * split its innerclasses headers to also be different for versions A and B.

     */

    static void splitHeaders(ClassList classes) {

        Set<String> ctVersions = new HashSet<>();

        for (ClassDescription cd : classes) {

            for (ClassHeaderDescription header : cd.header) {

                for (char c : header.versions.toCharArray()) {

                    ctVersions.add("" + c);

                }

            }

        }

        classes.sort();

        for (ClassDescription cd : classes) {

            Map<String, String> outerSignatures2Version = new HashMap<>();

            for (String version : ctVersions) { //XXX

                ClassDescription outer = cd;

                String outerSignatures = "";

                while ((outer = classes.enclosingClass(outer)) != null) {

                    for (ClassHeaderDescription outerHeader : outer.header) {

                        if (outerHeader.versions.contains(version)) {

                            outerSignatures += outerHeader.signature;

                        }

                    }

                }

                outerSignatures2Version.compute(outerSignatures,

                                                 (key, value) -> value != null ? value + version : version);

            }

            List<ClassHeaderDescription> newHeaders = new ArrayList<>();

            HEADER_LOOP: for (ClassHeaderDescription header : cd.header) {

                for (String versions : outerSignatures2Version.values()) {

                    if (containsAll(versions, header.versions)) {

                        newHeaders.add(header);

                        continue HEADER_LOOP;

                    }

                    if (disjoint(versions, header.versions)) {

                        continue;

                    }

                    ClassHeaderDescription newHeader = new ClassHeaderDescription();

                    newHeader.classAnnotations = header.classAnnotations;

                    newHeader.deprecated = header.deprecated;

                    newHeader.extendsAttr = header.extendsAttr;

                    newHeader.flags = header.flags;

                    newHeader.implementsAttr = header.implementsAttr;

                    newHeader.innerClasses = header.innerClasses;

                    newHeader.runtimeAnnotations = header.runtimeAnnotations;

                    newHeader.signature = header.signature;

                    newHeader.versions = reduce(versions, header.versions);

                    newHeaders.add(newHeader);

                }

            }

            cd.header = newHeaders;

        }

    }

    void limitJointVersion(Set<String> jointVersions, List<? extends FeatureDescription> features) {

        for (FeatureDescription feature : features) {

            for (String version : jointVersions) {

                if (!containsAll(feature.versions, version) &&

                    !disjoint(feature.versions, version)) {

                    StringBuilder featurePart = new StringBuilder();

                    StringBuilder otherPart = new StringBuilder();

                    for (char v : version.toCharArray()) {

                        if (feature.versions.indexOf(v) != (-1)) {

                            featurePart.append(v);

                        } else {

                            otherPart.append(v);

                        }

                    }

                    jointVersions.remove(version);

                    if (featurePart.length() == 0 || otherPart.length() == 0) {

                        throw new AssertionError();

                    }

                    jointVersions.add(featurePart.toString());

                    jointVersions.add(otherPart.toString());

                    break;

                }

            }

        }

    }

    private static boolean containsAll(String versions, String subVersions) {

        for (char c : subVersions.toCharArray()) {

            if (versions.indexOf(c) == (-1))

                return false;

        }

        return true;

    }

    private static boolean disjoint(String version1, String version2) {

        for (char c : version2.toCharArray()) {

            if (version1.indexOf(c) != (-1))

                return false;

        }

        return true;

    }

    void writeClassesForVersions(String ctSymLocation,

                                 ClassDescription classDescription,

                                 ClassHeaderDescription header,

                                 Iterable<String> versions) throws IOException {

        for (String ver : versions) {

            writeClass(ctSymLocation, classDescription, header, ver);

        }

    }

    public enum CtSymKind {

        JOINED_VERSIONS,

        SEPARATE;

    }

    //<editor-fold defaultstate="collapsed" desc="Class Writing">

    void writeClass(String ctSymLocation,

                    ClassDescription classDescription,

                    ClassHeaderDescription header,

                    String version) throws IOException {

        List<CPInfo> constantPool = new ArrayList<>();

        constantPool.add(null);

        List<Method> methods = new ArrayList<>();

        for (MethodDescription methDesc : classDescription.methods) {

            if (disjoint(methDesc.versions, version))

                continue;

            Descriptor descriptor = new Descriptor(addString(constantPool, methDesc.descriptor));

            //TODO: LinkedHashMap to avoid param annotations vs. Signature problem in javac's ClassReader:

            Map<String, Attribute> attributesMap = new LinkedHashMap<>();

            addAttributes(methDesc, constantPool, attributesMap);

            Attributes attributes = new Attributes(attributesMap);

            AccessFlags flags = new AccessFlags(methDesc.flags);

            int nameString = addString(constantPool, methDesc.name);

            methods.add(new Method(flags, nameString, descriptor, attributes));

        }

        List<Field> fields = new ArrayList<>();

        for (FieldDescription fieldDesc : classDescription.fields) {

            if (disjoint(fieldDesc.versions, version))

                continue;

            Descriptor descriptor = new Descriptor(addString(constantPool, fieldDesc.descriptor));

            Map<String, Attribute> attributesMap = new HashMap<>();

            addAttributes(fieldDesc, constantPool, attributesMap);

            Attributes attributes = new Attributes(attributesMap);