/*

 * Copyright (c) 2015, 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.module;

import java.io.BufferedWriter;

import java.io.IOException;

import java.io.PrintWriter;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashMap;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.Set;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import static java.util.stream.Collectors.*;

/**

 * A build tool to extend the module-info.java in the source tree for

 * platform-specific exports, opens, uses, and provides and write to

 * the specified output file.

 *

 * GenModuleInfoSource will be invoked for each module that has

 * module-info.java.extra in the source directory.

 *

 * The extra exports, opens, uses, provides can be specified

 * in module-info.java.extra.

 * Injecting platform-specific requires is not supported.

 *

 * @see build.tools.module.ModuleInfoExtraTest for basic testing

 */

public class GenModuleInfoSource {

    private final static String USAGE =

        "Usage: GenModuleInfoSource -o <output file> \n" +

        "  --source-file <module-info-java>\n" +

        "  --modules <module-name>[,<module-name>...]\n" +

        "  <module-info.java.extra> ...\n";

    static boolean verbose = false;

    public static void main(String... args) throws Exception {

        Path outfile = null;

        Path moduleInfoJava = null;

        Set<String> modules = Collections.emptySet();

        List<Path> extras = new ArrayList<>();

        // validate input arguments

        for (int i = 0; i < args.length; i++){

            String option = args[i];

            String arg = i+1 < args.length ? args[i+1] : null;

            switch (option) {

                case "-o":

                    outfile = Paths.get(arg);

                    i++;

                    break;

                case "--source-file":

                    moduleInfoJava = Paths.get(arg);

                    if (Files.notExists(moduleInfoJava)) {

                        throw new IllegalArgumentException(moduleInfoJava + " not exist");

                    }

                    i++;

                    break;

                case "--modules":

                    modules = Arrays.stream(arg.split(","))

                                    .collect(toSet());

                    i++;

                    break;

                case "-v":

                    verbose = true;

                    break;

                default:

                    Path file = Paths.get(option);

                    if (Files.notExists(file)) {

                        throw new IllegalArgumentException(file + " not exist");

                    }

                    extras.add(file);

            }

        }

        if (moduleInfoJava == null || outfile == null ||

                modules.isEmpty() || extras.isEmpty()) {

            System.err.println(USAGE);

            System.exit(-1);

        }

        GenModuleInfoSource genModuleInfo =

            new GenModuleInfoSource(moduleInfoJava, extras, modules);

        // generate new module-info.java

        genModuleInfo.generate(outfile);

    }

    final Path sourceFile;

    final List<Path> extraFiles;

    final ModuleInfo extras;

    final Set<String> modules;

    final ModuleInfo moduleInfo;

    GenModuleInfoSource(Path sourceFile, List<Path> extraFiles, Set<String> modules)

        throws IOException

    {

        this.sourceFile = sourceFile;

        this.extraFiles = extraFiles;

        this.modules = modules;

        this.moduleInfo = new ModuleInfo();

        this.moduleInfo.parse(sourceFile);

        // parse module-info.java.extra

        this.extras = new ModuleInfo();

        for (Path file : extraFiles) {

            extras.parseExtra(file);

        }

        // merge with module-info.java.extra

        moduleInfo.augmentModuleInfo(extras, modules);

    }

    void generate(Path output) throws IOException {

        List<String> lines = Files.readAllLines(sourceFile);

        try (BufferedWriter bw = Files.newBufferedWriter(output);

             PrintWriter writer = new PrintWriter(bw)) {

            // write the copyright header and lines up to module declaration

            for (String l : lines) {

                writer.println(l);

                if (l.trim().startsWith("module ")) {

                    // print URI rather than file path to avoid escape

                    writer.format("    // source file: %s%n", sourceFile.toUri());

                    for (Path file: extraFiles) {

                        writer.format("    //              %s%n", file.toUri());

                    }

                    break;

                }

            }

            // requires

            for (String l : lines) {

                if (l.trim().startsWith("requires"))

                    writer.println(l);

            }

            // write exports, opens, uses, and provides

            moduleInfo.print(writer);

            // close

            writer.println("}");

        }

    }

    class ModuleInfo {

        final Map<String, Statement> exports = new HashMap<>();

        final Map<String, Statement> opens = new HashMap<>();

        final Map<String, Statement> uses = new HashMap<>();

        final Map<String, Statement> provides = new HashMap<>();

        Statement getStatement(String directive, String name) {

            Objects.requireNonNull(name);

            switch (directive) {

                case "exports":

                    if (moduleInfo.exports.containsKey(name) &&

                        moduleInfo.exports.get(name).isUnqualified()) {

                        throw new IllegalArgumentException(sourceFile +

                            " already has " + directive + " " + name);

                    }

                    return exports.computeIfAbsent(name,

                        _n -> new Statement("exports", "to", name));

                case "opens":

                    if (moduleInfo.opens.containsKey(name) &&

                        moduleInfo.opens.get(name).isUnqualified()) {

                        throw new IllegalArgumentException(sourceFile +

                            " already has " + directive + " " + name);

                    }

                    if (moduleInfo.opens.containsKey(name)) {

                        throw new IllegalArgumentException(sourceFile +

                            " already has " + directive + " " + name);

                    }

                    return opens.computeIfAbsent(name,

                        _n -> new Statement("opens", "to", name));

                case "uses":

                    return uses.computeIfAbsent(name,

                        _n -> new Statement("uses", "", name));

                case "provides":

                    return provides.computeIfAbsent(name,

                        _n -> new Statement("provides", "with", name, true));

                default:

                    throw new IllegalArgumentException(directive);

            }

        }

        /*

         * Augment this ModuleInfo with module-info.java.extra

         */

        void augmentModuleInfo(ModuleInfo extraFiles, Set<String> modules) {

            // API package exported in the original module-info.java

            extraFiles.exports.entrySet()

                .stream()

                .filter(e -> exports.containsKey(e.getKey()) &&

                    e.getValue().filter(modules))

                .forEach(e -> mergeExportsOrOpens(exports.get(e.getKey()),

                    e.getValue(),

                    modules));

            // add exports that are not defined in the original module-info.java

            extraFiles.exports.entrySet()

                .stream()

                .filter(e -> !exports.containsKey(e.getKey()) &&

                    e.getValue().filter(modules))

                .forEach(e -> addTargets(getStatement("exports", e.getKey()),

                    e.getValue(),

                    modules));

            // API package opened in the original module-info.java

            extraFiles.opens.entrySet()

                .stream()

                .filter(e -> opens.containsKey(e.getKey()) &&

                    e.getValue().filter(modules))

                .forEach(e -> mergeExportsOrOpens(opens.get(e.getKey()),

                    e.getValue(),

                    modules));

            // add opens that are not defined in the original module-info.java

            extraFiles.opens.entrySet()

                .stream()

                .filter(e -> !opens.containsKey(e.getKey()) &&

                    e.getValue().filter(modules))

                .forEach(e -> addTargets(getStatement("opens", e.getKey()),

                    e.getValue(),

                    modules));

            // provides

            extraFiles.provides.keySet()

                .stream()

                .filter(service -> provides.containsKey(service))

                .forEach(service -> mergeProvides(service,

                    extraFiles.provides.get(service)));

            extraFiles.provides.keySet()

                .stream()

                .filter(service -> !provides.containsKey(service))

                .forEach(service -> provides.put(service,

                    extraFiles.provides.get(service)));

            // uses

            extraFiles.uses.keySet()

                .stream()

                .filter(service -> !uses.containsKey(service))

                .forEach(service -> uses.put(service, extraFiles.uses.get(service)));

        }

        // add qualified exports or opens to known modules only

        private void addTargets(Statement statement,

                                Statement extra,

                                Set<String> modules)

        {

            extra.targets.stream()

                .filter(mn -> modules.contains(mn))

                .forEach(mn -> statement.addTarget(mn));

        }

        private void mergeExportsOrOpens(Statement statement,

                                         Statement extra,

                                         Set<String> modules)

        {

            String pn = statement.name;

            if (statement.isUnqualified() && extra.isQualified()) {

                throw new RuntimeException("can't add qualified exports to " +

                    "unqualified exports " + pn);

            }

            Set<String> mods = extra.targets.stream()

                .filter(mn -> statement.targets.contains(mn))

                .collect(toSet());

            if (mods.size() > 0) {

                throw new RuntimeException("qualified exports " + pn + " to " +

                    mods.toString() + " already declared in " + sourceFile);

            }

            // add qualified exports or opens to known modules only

            addTargets(statement, extra, modules);

        }

        private void mergeProvides(String service, Statement extra) {

            Statement statement = provides.get(service);

            Set<String> mods = extra.targets.stream()

                .filter(mn -> statement.targets.contains(mn))

                .collect(toSet());

            if (mods.size() > 0) {

                throw new RuntimeException("qualified exports " + service + " to " +

                    mods.toString() + " already declared in " + sourceFile);

            }

            extra.targets.stream()

                .forEach(mn -> statement.addTarget(mn));

        }

        void print(PrintWriter writer) {

            // print unqualified exports

            exports.entrySet().stream()

                .filter(e -> e.getValue().targets.isEmpty())

                .sorted(Map.Entry.comparingByKey())

                .forEach(e -> writer.println(e.getValue()));

            // print qualified exports

            exports.entrySet().stream()

                .filter(e -> !e.getValue().targets.isEmpty())

                .sorted(Map.Entry.comparingByKey())

                .forEach(e -> writer.println(e.getValue()));

            // print unqualified opens

            opens.entrySet().stream()

                .filter(e -> e.getValue().targets.isEmpty())

                .sorted(Map.Entry.comparingByKey())

                .forEach(e -> writer.println(e.getValue()));

            // print qualified opens

            opens.entrySet().stream()

                .filter(e -> !e.getValue().targets.isEmpty())

                .sorted(Map.Entry.comparingByKey())

                .forEach(e -> writer.println(e.getValue()));

            // uses and provides

            writer.println();

            uses.entrySet().stream()

                .sorted(Map.Entry.comparingByKey())

                .forEach(e -> writer.println(e.getValue()));

            provides.entrySet().stream()

                .sorted(Map.Entry.comparingByKey())

                .forEach(e -> writer.println(e.getValue()));

        }

        private void parse(Path file) throws IOException {

            Parser parser = new Parser(file);

            parser.run();

            if (verbose) {

                parser.dump();

            }

            process(parser, false);

        }

        private void parseExtra(Path file) throws IOException {

            Parser parser = new Parser(file);

            parser.run();

            if (verbose) {

                parser.dump();

            }

            process(parser, true);

        }

        private void process(Parser parser, boolean extraFile) throws IOException {

            // no duplicate statement local in each file

            Map<String, Statement> exports = new HashMap<>();

            Map<String, Statement> opens = new HashMap<>();

            Map<String, Statement> uses = new HashMap<>();

            Map<String, Statement> provides = new HashMap<>();

            String token = null;

            boolean hasCurlyBracket = false;

            while ((token = parser.nextToken()) != null) {

                if (token.equals("module")) {

                    String modulename = nextIdentifier(parser);

                    if (extraFile) {

                        throw parser.newError("cannot declare module in " + parser.sourceFile);

                    }

                    skipTokenOrThrow(parser, "{", "missing {");

                    hasCurlyBracket = true;

                } else if (token.equals("requires")) {

                    token = nextIdentifier(parser);

                    if (token.equals("transitive")) {

                        token = nextIdentifier(parser);

                    }

                    if (extraFile) {

                        throw parser.newError("cannot declare requires in " + parser.sourceFile);

                    }

                    skipTokenOrThrow(parser, ";", "missing semicolon");

                } else if (isExportsOpensProvidesUses(token)) {

                    // new statement

                    String keyword = token;

                    String name = nextIdentifier(parser);

                    Statement statement = getStatement(keyword, name);

                    switch (keyword) {

                        case "exports":

                            if (exports.containsKey(name)) {

                                throw parser.newError("multiple " + keyword + " " + name);

                            }

                            exports.put(name, statement);

                            break;

                        case "opens":

                            if (opens.containsKey(name)) {

                                throw parser.newError("multiple " + keyword + " " + name);

                            }

                            opens.put(name, statement);

                            break;

                        case "uses":

                            if (uses.containsKey(name)) {

                                throw parser.newError("multiple " + keyword + " " + name);

                            }

                            uses.put(name, statement);

                            break;

                        case "provides":

                            if (provides.containsKey(name)) {

                                throw parser.newError("multiple " + keyword + " " + name);

                            }

                            provides.put(name, statement);

                            break;

                    }

                    String lookAhead = lookAhead(parser);

                    if (lookAhead.equals(statement.qualifier)) {

                        parser.nextToken(); // skip qualifier

                        while ((lookAhead = parser.peekToken()) != null) {

                            // add target name

                            name = nextIdentifier(parser);

                            statement.addTarget(name);

                            lookAhead = lookAhead(parser);

                            if (lookAhead.equals(",") || lookAhead.equals(";")) {

                                parser.nextToken();

                            } else {

                                throw parser.newError("missing semicolon");

                            }

                            if (lookAhead.equals(";")) {

                                break;

                            }

                        }

                    } else {

                        skipTokenOrThrow(parser, ";", "missing semicolon");

                    }

                } else if (token.equals(";")) {

                    continue;

                } else if (hasCurlyBracket && token.equals("}")) {

                    hasCurlyBracket = false;

                    if (parser.peekToken() != null) {  // must be EOF

                        throw parser.newError("is malformed");

                    }

                } else {

                    throw parser.newError("missing keyword");

                }

            }

            if (hasCurlyBracket) {

                parser.newError("missing }");

            }

        }

        private boolean isExportsOpensProvidesUses(String word) {

            switch (word) {

                case "exports":

                case "opens":

                case "provides":

                case "uses":

                    return true;

                default:

                    return false;

            }

        }

        private String lookAhead(Parser parser) {

            String lookAhead = parser.peekToken();

            if (lookAhead == null) { // EOF

                throw parser.newError("reach end of file");

            }