/*

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

                                  .ModuleHeaderDescription

                                  .ProvidesDescription;

import build.tools.symbolgenerator.CreateSymbols

                                  .ModuleHeaderDescription

                                  .RequiresDescription;

import java.io.BufferedInputStream;

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.StringWriter;

import java.io.Writer;

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.Calendar;

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.LinkedHashMap;

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.TimeZone;

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 javax.tools.JavaFileManager;

import javax.tools.JavaFileManager.Location;

import javax.tools.JavaFileObject;

import javax.tools.JavaFileObject.Kind;

import javax.tools.StandardLocation;

import com.sun.source.util.JavacTask;

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_Module_info;

import com.sun.tools.classfile.ConstantPool.CONSTANT_Package_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.ModuleResolution_attribute;

import com.sun.tools.classfile.ModuleTarget_attribute;

import com.sun.tools.classfile.Module_attribute;

import com.sun.tools.classfile.Module_attribute.ExportsEntry;

import com.sun.tools.classfile.Module_attribute.OpensEntry;

import com.sun.tools.classfile.Module_attribute.ProvidesEntry;

import com.sun.tools.classfile.Module_attribute.RequiresEntry;

import com.sun.tools.classfile.NestHost_attribute;

import com.sun.tools.classfile.NestMembers_attribute;

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.api.JavacTool;

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

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

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

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

/**

 * A tool for processing the .sym.txt files.

 *

 * To add historical data for JDK N, N >= 11, do the following:

 *  * cd <open-jdk-checkout>/make/data/symbols

 *  * <jdk-N>/bin/java --add-exports jdk.jdeps/com.sun.tools.classfile=ALL-UNNAMED \

 *                     --add-exports jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED \

 *                     --add-exports jdk.compiler/com.sun.tools.javac.jvm=ALL-UNNAMED \

 *                     --add-exports jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED \

 *                     --add-modules jdk.jdeps \

 *                     ../../../make/langtools/src/classes/build/tools/symbolgenerator/CreateSymbols.java \

 *                     build-description-incremental symbols include.list

 *  * sanity-check the new and updates files in make/data/symbols and commit them

 *

 * The tools 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

 *  * enhance existing .sym.txt files with a a new set .sym.txt for the current platform

 *

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

 *     java build.tool.symbolgenerator.CreateSymbols build-ctsym <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 make/data/symbols $TOPDIR 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 ctDescriptionFileExtra, String ctDescriptionFile, String ctSymLocation) throws IOException {

        LoadDescriptions data = load(ctDescriptionFileExtra != null ? Paths.get(ctDescriptionFileExtra)

                                                                    : null,

                                     Paths.get(ctDescriptionFile), null);

        splitHeaders(data.classes);

        Map<String, Map<Character, String>> package2Version2Module = new HashMap<>();

        for (ModuleDescription md : data.modules.values()) {

            for (ModuleHeaderDescription mhd : md.header) {

                List<String> versionsList =

                        Collections.singletonList(mhd.versions);

                writeModulesForVersions(ctSymLocation,

                                        md,

                                        mhd,

                                        versionsList);

                mhd.exports.stream().forEach(pkg -> {

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

                        package2Version2Module.computeIfAbsent(pkg, dummy -> new HashMap<>()).put(v, md.name);

                    }

                });

            }

        }

        for (ClassDescription classDescription : data.classes) {

            Map<Character, String> version2Module = package2Version2Module.getOrDefault(classDescription.packge().replace('.', '/'), Collections.emptyMap());

            for (ClassHeaderDescription header : classDescription.header) {

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

                jointVersions.add(header.versions);

                limitJointVersion(jointVersions, classDescription.fields);

                limitJointVersion(jointVersions, classDescription.methods);

                Map<String, StringBuilder> module2Versions = new HashMap<>();

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

                    String module = version2Module.get(v);

                    if (module == null) {

                        if (v >= '9') {

                            throw new AssertionError("No module for " + classDescription.name +

                                                     " and version " + v);

                        }

                        module = version2Module.get('9');

                        if (module == null) {

                            module = "java.base";

                        }

                    }

                    module2Versions.computeIfAbsent(module, dummy -> new StringBuilder()).append(v);

                }

                for (Entry<String, StringBuilder> e : module2Versions.entrySet()) {

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

                    limitJointVersion(currentVersions, e.getValue().toString());

                    currentVersions = currentVersions.stream().filter(vers -> !disjoint(vers, e.getValue().toString())).collect(Collectors.toSet());

                    writeClassesForVersions(ctSymLocation, classDescription, header, e.getKey(), currentVersions);

                }

            }

        }

    }

    public static String EXTENSION = ".sig";

    LoadDescriptions load(Path ctDescriptionWithExtraContent, Path ctDescriptionOpen, String deletePlatform) throws IOException {

        Map<String, PlatformInput> platforms = new LinkedHashMap<>();

        if (ctDescriptionWithExtraContent != null && Files.isRegularFile(ctDescriptionWithExtraContent)) {

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

                while (reader.hasNext()) {

                    switch (reader.lineKey) {

                        case "generate":

                            //ignore

                            reader.moveNext();

                            break;

                        case "platform":

                            PlatformInput platform = PlatformInput.load(ctDescriptionWithExtraContent,

                                                                        reader);

                            if (!platform.version.equals(deletePlatform))

                                platforms.put(platform.version, platform);

                            reader.moveNext();

                            break;

                        default:

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

                    }

                }

            }

        }

        Set<String> generatePlatforms = null;

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

            while (reader.hasNext()) {

                switch (reader.lineKey) {

                    case "generate":

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

                        generatePlatforms = new HashSet<>(List.of(platformsAttr));

                        generatePlatforms.remove(deletePlatform);

                        reader.moveNext();

                        break;

                    case "platform":

                        PlatformInput platform = PlatformInput.load(ctDescriptionOpen, reader);

                        if (!platform.version.equals(deletePlatform) &&

                            !platforms.containsKey(platform.version))

                            platforms.put(platform.version, platform);

                        reader.moveNext();

                        break;

                    default:

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

                }

            }

        }

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

        Map<String, ModuleDescription> modules = new LinkedHashMap<>();

        for (PlatformInput platform : platforms.values()) {

            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 (ModuleDescription md : modules.values()) {

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

            }

            for (String input : platform.files) {

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

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

                    while (reader.hasNext()) {

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

                        switch (reader.lineKey) {

                            case "class": case "-class":

                                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);

                                break;

                            case "module": {

                                ModuleDescription md =

                                        modules.computeIfAbsent(nameAttr,

                                                n -> new ModuleDescription());

                                md.read(reader, platform.basePlatform,

                                        platform.version);

                                break;

                            }

                            case "-module": {

                                ModuleDescription md =

                                        modules.computeIfAbsent(nameAttr,

                                                n -> new ModuleDescription());

                                removeVersion(md.header, h -> true,

                                              platform.version);

                                reader.moveNext();

                                break;

                            }

                        }

                    }

                }

            }

        }

        ClassList result = new ClassList();

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

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

            while (chdIt.hasNext()) {

                ClassHeaderDescription chd = chdIt.next();

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

                if (chd.versions.isEmpty())

                    chdIt.remove();

            }

            if (desc.header.isEmpty()) {

                continue;

            }

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

            while (methodIt.hasNext()) {

                MethodDescription method = methodIt.next();

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

                if (method.versions.isEmpty())

                    methodIt.remove();

            }

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

            while (fieldIt.hasNext()) {

                FieldDescription field = fieldIt.next();

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

                if (field.versions.isEmpty())

                    fieldIt.remove();

            }

            result.add(desc);

        }

        Map<String, ModuleDescription> moduleList = new HashMap<>();

        for (ModuleDescription desc : modules.values()) {

            Iterator<ModuleHeaderDescription> mhdIt = desc.header.iterator();

            while (mhdIt.hasNext()) {

                ModuleHeaderDescription mhd = mhdIt.next();

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

                if (mhd.versions.isEmpty())

                    mhdIt.remove();

            }

            if (desc.header.isEmpty()) {

                continue;

            }

            moduleList.put(desc.name, desc);

        }

        return new LoadDescriptions(result, moduleList, new ArrayList<>(platforms.values()));

    }

    static final class LoadDescriptions {

        public final ClassList classes;

        public final Map<String, ModuleDescription> modules;

        public final List<PlatformInput> versions;

        public LoadDescriptions(ClassList classes,

                                Map<String, ModuleDescription>  modules,

                                List<PlatformInput> versions) {

            this.classes = classes;

            this.modules = modules;

            this.versions = versions;

        }

    }

    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()) {