/*
 * Copyright (c) 2014, 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 build.tools.jigsaw;

import java.io.IOException;
import java.io.PrintStream;
import java.lang.module.Configuration;
import java.lang.module.ModuleDescriptor;
import java.lang.module.ModuleFinder;
import java.lang.module.ModuleReference;
import java.lang.module.ResolvedModule;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.function.Function;
import java.util.stream.Collectors;
import static java.lang.module.ModuleDescriptor.Requires.Modifier.TRANSITIVE;

/**
 * Generate the DOT file for a module graph for each module in the JDK
 * after transitive reduction.
 */
public class GenGraphs {

    public static void main(String[] args) throws Exception {

        if (args.length != 1) {
            System.err.println("ERROR: specify the output directory");
            System.exit(1);
        }
        Path dir = Paths.get(args[0]);
        Files.createDirectories(dir);

        ModuleFinder finder = ModuleFinder.ofSystem();

        Set<ModuleDescriptor> javaSEModules
            = new TreeSet<>(finder.findAll().stream()
                                  .map(ModuleReference::descriptor)
                                  .filter(m -> (m.name().startsWith("java.") &&
                                               !m.name().equals("java.smartcardio")))
                                  .collect(Collectors.toSet()));
        Set<ModuleDescriptor> jdkModules
            = new TreeSet<>(finder.findAll().stream()
                                  .map(ModuleReference::descriptor)
                                  .filter(m -> !javaSEModules.contains(m))
                                  .collect(Collectors.toSet()));

        GenGraphs genGraphs = new GenGraphs(javaSEModules, jdkModules);
        Set<String> mods = new HashSet<>();
        for (ModuleReference mref: finder.findAll()) {
            ModuleDescriptor descriptor = mref.descriptor();
            String name = descriptor.name();
            mods.add(name);
            Configuration cf = Configuration.empty()
                    .resolveRequires(finder,
                                     ModuleFinder.of(),
                                     Set.of(name));
            genGraphs.genDotFile(dir, name, cf);
        }

        Configuration cf = Configuration.empty()
                .resolveRequires(finder,
                                 ModuleFinder.of(),
                                 mods);
        genGraphs.genDotFile(dir, "jdk", cf);

    }

    private final Set<ModuleDescriptor> javaGroup;
    private final Set<ModuleDescriptor> jdkGroup;

    GenGraphs(Set<ModuleDescriptor> javaGroup, Set<ModuleDescriptor> jdkGroup) {
        this.javaGroup = Collections.unmodifiableSet(javaGroup);
        this.jdkGroup = Collections.unmodifiableSet(jdkGroup);
    }

    private static final String ORANGE = "#e76f00";
    private static final String BLUE = "#437291";
    private static final String GRAY = "#dddddd";

    private static final String REEXPORTS = "";
    private static final String REQUIRES = "style=\"dashed\"";
    private static final String REQUIRES_BASE = "color=\"" + GRAY + "\"";

    private static final Map<String,Integer> weights = new HashMap<>();

    private static void weight(String s, String t, int w) {
        weights.put(s + ":" + t, w);
    }

    private static int weightOf(String s, String t) {
        int w = weights.getOrDefault(s + ":" + t, 1);
        if (w != 1)
            return w;
        if (s.startsWith("java.") && t.startsWith("java."))
            return 10;
        return 1;
    }

    static {
        int h = 1000;
        weight("java.se", "java.compact3", h * 10);
        weight("jdk.compact3", "java.compact3", h * 10);
        weight("java.compact3", "java.compact2", h * 10);
        weight("java.compact2", "java.compact1", h * 10);
        weight("java.compact1", "java.logging", h * 10);
        weight("java.logging", "java.base", h * 10);
    }

    private void genDotFile(Path dir, String name, Configuration cf) throws IOException {
        try (PrintStream out
                 = new PrintStream(Files.newOutputStream(dir.resolve(name + ".dot")))) {

            Map<String, ModuleDescriptor> nameToModule = cf.modules().stream()
                    .map(ResolvedModule::reference)
                    .map(ModuleReference::descriptor)
                    .collect(Collectors.toMap(ModuleDescriptor::name, Function.identity()));

            Set<ModuleDescriptor> descriptors = new TreeSet<>(nameToModule.values());

            out.format("digraph \"%s\" {%n", name);
            out.format("size=\"25,25\";");
            out.format("nodesep=.5;%n");
            out.format("ranksep=1.5;%n");
            out.format("pencolor=transparent;%n");
            out.format("node [shape=plaintext, fontname=\"DejaVuSans\", fontsize=36, margin=\".2,.2\"];%n");
            out.format("edge [penwidth=4, color=\"#999999\", arrowhead=open, arrowsize=2];%n");

            out.format("subgraph %sse {%n", name.equals("jdk") ? "cluster_" : "");
            descriptors.stream()
                .filter(javaGroup::contains)
                .map(ModuleDescriptor::name)
                .forEach(mn -> out.format("  \"%s\" [fontcolor=\"%s\", group=%s];%n",
                                          mn, ORANGE, "java"));
            out.format("}%n");
            descriptors.stream()
                .filter(jdkGroup::contains)
                .map(ModuleDescriptor::name)
                .forEach(mn -> out.format("  \"%s\" [fontcolor=\"%s\", group=%s];%n",
                                          mn, BLUE, "jdk"));

            // transitive reduction
            Graph<String> graph = gengraph(cf);
            descriptors.forEach(md -> {
                String mn = md.name();
                Set<String> requiresTransitive = md.requires().stream()
                        .filter(d -> d.modifiers().contains(TRANSITIVE))
                        .map(d -> d.name())
                        .collect(Collectors.toSet());

                graph.adjacentNodes(mn).forEach(dn -> {
                    String attr = dn.equals("java.base") ? REQUIRES_BASE
                            : (requiresTransitive.contains(dn) ? REEXPORTS : REQUIRES);
                    int w = weightOf(mn, dn);
                    if (w > 1)
                        attr += "weight=" + w;
                    out.format("  \"%s\" -> \"%s\" [%s];%n", mn, dn, attr);
                });
            });

            out.println("}");
        }
    }

    /**
     * Returns a Graph of the given Configuration after transitive reduction.
     *
     * Transitive reduction of requires transitive edge and requires edge have
     * to be applied separately to prevent the requires transitive edges
     * (e.g. U -> V) from being reduced by a path (U -> X -> Y -> V)
     * in which  V would not be re-exported from U.
     */
    private Graph<String> gengraph(Configuration cf) {
        Graph.Builder<String> builder = new Graph.Builder<>();
        for (ResolvedModule resolvedModule : cf.modules()) {
            String mn = resolvedModule.reference().descriptor().name();
            builder.addNode(mn);
            resolvedModule.reads().stream()
                    .map(ResolvedModule::name)
                    .forEach(target -> builder.addEdge(mn, target));
        }
        Graph<String> rpg = requiresTransitiveGraph(cf);
        return builder.build().reduce(rpg);
    }

    /**
     * Returns a Graph containing only requires transitive edges
     * with transitive reduction.
     */
    private Graph<String> requiresTransitiveGraph(Configuration cf) {
        Graph.Builder<String> builder = new Graph.Builder<>();
        for (ResolvedModule resolvedModule : cf.modules()) {
            ModuleDescriptor descriptor = resolvedModule.reference().descriptor();
            String mn = descriptor.name();
            descriptor.requires().stream()
                    .filter(d -> d.modifiers().contains(TRANSITIVE))
                    .map(d -> d.name())
                    .forEach(d -> builder.addEdge(mn, d));
        }
        return builder.build().reduce();
    }
}