/*

 * Copyright (c) 2009, 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 com.sun.tools.javac.comp;

import java.io.IOException;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.EnumSet;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.LinkedHashSet;

import java.util.Map;

import java.util.Set;

import java.util.function.Consumer;

import java.util.function.Predicate;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import java.util.stream.Stream;

import javax.lang.model.SourceVersion;

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.tools.javac.code.ClassFinder;

import com.sun.tools.javac.code.Directive;

import com.sun.tools.javac.code.Directive.ExportsDirective;

import com.sun.tools.javac.code.Directive.RequiresDirective;

import com.sun.tools.javac.code.Directive.RequiresFlag;

import com.sun.tools.javac.code.Directive.UsesDirective;

import com.sun.tools.javac.code.Flags;

import com.sun.tools.javac.code.Kinds;

import com.sun.tools.javac.code.Lint.LintCategory;

import com.sun.tools.javac.code.ModuleFinder;

import com.sun.tools.javac.code.Source;

import com.sun.tools.javac.code.Symbol;

import com.sun.tools.javac.code.Symbol.ClassSymbol;

import com.sun.tools.javac.code.Symbol.Completer;

import com.sun.tools.javac.code.Symbol.CompletionFailure;

import com.sun.tools.javac.code.Symbol.MethodSymbol;

import com.sun.tools.javac.code.Symbol.ModuleSymbol;

import com.sun.tools.javac.code.Symbol.PackageSymbol;

import com.sun.tools.javac.code.Symtab;

import com.sun.tools.javac.code.Type;

import com.sun.tools.javac.code.Types;

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

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

import com.sun.tools.javac.main.Option;

import com.sun.tools.javac.resources.CompilerProperties.Errors;

import com.sun.tools.javac.resources.CompilerProperties.Warnings;

import com.sun.tools.javac.tree.JCTree;

import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;

import com.sun.tools.javac.tree.JCTree.JCExports;

import com.sun.tools.javac.tree.JCTree.JCExpression;

import com.sun.tools.javac.tree.JCTree.JCModuleDecl;

import com.sun.tools.javac.tree.JCTree.JCPackageDecl;

import com.sun.tools.javac.tree.JCTree.JCProvides;

import com.sun.tools.javac.tree.JCTree.JCRequires;

import com.sun.tools.javac.tree.JCTree.JCUses;

import com.sun.tools.javac.tree.TreeInfo;

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

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

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

import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;

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

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

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

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

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

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

import static com.sun.tools.javac.code.Flags.UNATTRIBUTED;

import static com.sun.tools.javac.code.Kinds.Kind.MDL;

import static com.sun.tools.javac.code.TypeTag.CLASS;

import com.sun.tools.javac.tree.JCTree.JCDirective;

import com.sun.tools.javac.tree.JCTree.Tag;

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

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

import static com.sun.tools.javac.code.Flags.ABSTRACT;

import static com.sun.tools.javac.code.Flags.ENUM;

import static com.sun.tools.javac.code.Flags.PUBLIC;

import static com.sun.tools.javac.tree.JCTree.Tag.MODULEDEF;

/**

 *  TODO: fill in

 *

 *  <p><b>This is NOT part of any supported API.

 *  If you write code that depends on this, you do so at your own risk.

 *  This code and its internal interfaces are subject to change or

 *  deletion without notice.</b>

 */

public class Modules extends JCTree.Visitor {

    private static final String ALL_SYSTEM = "ALL-SYSTEM";

    private static final String ALL_MODULE_PATH = "ALL-MODULE-PATH";

    private final Log log;

    private final Names names;

    private final Symtab syms;

    private final Attr attr;

    private final TypeEnvs typeEnvs;

    private final Types types;

    private final JavaFileManager fileManager;

    private final ModuleFinder moduleFinder;

    private final Source source;

    private final boolean allowModules;

    public final boolean multiModuleMode;

    private final String moduleOverride;

    private final Name java_se;

    private final Name java_;

    ModuleSymbol defaultModule;

    private final String addExportsOpt;

    private Map<ModuleSymbol, Set<ExportsDirective>> addExports;

    private final String addReadsOpt;

    private Map<ModuleSymbol, Set<RequiresDirective>> addReads;

    private final String addModsOpt;

    private final Set<String> extraAddMods = new HashSet<>();

    private final String limitModsOpt;

    private final Set<String> extraLimitMods = new HashSet<>();

    private final boolean lintOptions;

    private Set<ModuleSymbol> rootModules = null;

    public static Modules instance(Context context) {

        Modules instance = context.get(Modules.class);

        if (instance == null)

            instance = new Modules(context);

        return instance;

    }

    protected Modules(Context context) {

        context.put(Modules.class, this);

        log = Log.instance(context);

        names = Names.instance(context);

        syms = Symtab.instance(context);

        attr = Attr.instance(context);

        typeEnvs = TypeEnvs.instance(context);

        moduleFinder = ModuleFinder.instance(context);

        types = Types.instance(context);

        fileManager = context.get(JavaFileManager.class);

        source = Source.instance(context);

        allowModules = source.allowModules();

        Options options = Options.instance(context);

        lintOptions = options.isUnset(Option.XLINT_CUSTOM, "-" + LintCategory.OPTIONS.option);

        moduleOverride = options.get(Option.XMODULE);

        multiModuleMode = fileManager.hasLocation(StandardLocation.MODULE_SOURCE_PATH);

        ClassWriter classWriter = ClassWriter.instance(context);

        classWriter.multiModuleMode = multiModuleMode;

        JNIWriter jniWriter = JNIWriter.instance(context);

        jniWriter.multiModuleMode = multiModuleMode;

        java_se = names.fromString("java.se");

        java_ = names.fromString("java.");

        addExportsOpt = options.get(Option.ADD_EXPORTS);

        addReadsOpt = options.get(Option.ADD_READS);

        addModsOpt = options.get(Option.ADD_MODULES);

        limitModsOpt = options.get(Option.LIMIT_MODULES);

    }

    int depth = -1;

    private void dprintln(String msg) {

        for (int i = 0; i < depth; i++)

            System.err.print("  ");

        System.err.println(msg);

    }

    public void addExtraAddModules(String... extras) {

        extraAddMods.addAll(Arrays.asList(extras));

    }

    public void addExtraLimitModules(String... extras) {

        extraLimitMods.addAll(Arrays.asList(extras));

    }

    boolean inInitModules;

    public void initModules(List<JCCompilationUnit> trees) {

        Assert.check(!inInitModules);

        try {

            inInitModules = true;

            Assert.checkNull(rootModules);

            enter(trees, modules -> {

                Assert.checkNull(rootModules);

                Assert.checkNull(allModules);

                this.rootModules = modules;

                setupAllModules(); //initialize the module graph

                Assert.checkNonNull(allModules);

                inInitModules = false;

            }, null);

        } finally {

            inInitModules = false;

        }

    }

    public boolean enter(List<JCCompilationUnit> trees, ClassSymbol c) {

        Assert.check(rootModules != null || inInitModules || !allowModules);

        return enter(trees, modules -> {}, c);

    }

    private boolean enter(List<JCCompilationUnit> trees, Consumer<Set<ModuleSymbol>> init, ClassSymbol c) {

        if (!allowModules) {

            for (JCCompilationUnit tree: trees) {

                tree.modle = syms.noModule;

            }

            defaultModule = syms.noModule;

            return true;

        }

        int startErrors = log.nerrors;

        depth++;

        try {

            // scan trees for module defs

            Set<ModuleSymbol> roots = enterModules(trees, c);

            setCompilationUnitModules(trees, roots);

            init.accept(roots);

            for (ModuleSymbol msym: roots) {

                msym.complete();

            }

        } catch (CompletionFailure ex) {

            log.error(JCDiagnostic.DiagnosticFlag.NON_DEFERRABLE, Position.NOPOS, "cant.access", ex.sym, ex.getDetailValue());

            if (ex instanceof ClassFinder.BadClassFile) throw new Abort();

        } finally {

            depth--;

        }

        return (log.nerrors == startErrors);

    }

    public Completer getCompleter() {

        return mainCompleter;

    }

    public ModuleSymbol getDefaultModule() {

        return defaultModule;

    }

    private Set<ModuleSymbol> enterModules(List<JCCompilationUnit> trees, ClassSymbol c) {

        Set<ModuleSymbol> modules = new LinkedHashSet<>();

        for (JCCompilationUnit tree : trees) {

            JavaFileObject prev = log.useSource(tree.sourcefile);

            try {

                enterModule(tree, c, modules);

            } finally {

                log.useSource(prev);

            }

        }

        return modules;

    }

    private void enterModule(JCCompilationUnit toplevel, ClassSymbol c, Set<ModuleSymbol> modules) {

        boolean isModuleInfo = toplevel.sourcefile.isNameCompatible("module-info", Kind.SOURCE);

        boolean isModuleDecl = toplevel.defs.nonEmpty() && toplevel.defs.head.hasTag(MODULEDEF);

        if (isModuleInfo && isModuleDecl) {

            JCModuleDecl decl = (JCModuleDecl) toplevel.defs.head;

            Name name = TreeInfo.fullName(decl.qualId);

            ModuleSymbol sym;

            if (c != null) {

                sym = (ModuleSymbol) c.owner;

                Assert.checkNonNull(sym.name);

                Name treeName = TreeInfo.fullName(decl.qualId);

                if (sym.name != treeName) {

                    log.error(decl.pos(), Errors.ModuleNameMismatch(name, sym.name));

                }

            } else {

                sym = syms.enterModule(name);

                if (sym.module_info.sourcefile != null && sym.module_info.sourcefile != toplevel.sourcefile) {

                    log.error(decl.pos(), Errors.DuplicateModule(sym));

                    return;

                }

            }

            sym.completer = getSourceCompleter(toplevel);

            sym.module_info.sourcefile = toplevel.sourcefile;

            decl.sym = sym;

            if (multiModuleMode || modules.isEmpty()) {

                modules.add(sym);

            } else {

                log.error(toplevel.pos(), Errors.TooManyModules);

            }

            Env<AttrContext> provisionalEnv = new Env<>(decl, null);

            provisionalEnv.toplevel = toplevel;

            typeEnvs.put(sym, provisionalEnv);

        } else if (isModuleInfo) {

            if (multiModuleMode) {

                JCTree tree = toplevel.defs.isEmpty() ? toplevel : toplevel.defs.head;

                log.error(tree.pos(), Errors.ExpectedModule);

            }

        } else if (isModuleDecl) {

            JCTree tree = toplevel.defs.head;

            log.error(tree.pos(), Errors.ModuleDeclSbInModuleInfoJava);

        }

    }

    private void setCompilationUnitModules(List<JCCompilationUnit> trees, Set<ModuleSymbol> rootModules) {

        // update the module for each compilation unit

        if (multiModuleMode) {

            checkNoAllModulePath();

            for (JCCompilationUnit tree: trees) {

                if (tree.defs.isEmpty()) {

                    tree.modle = syms.unnamedModule;

                    continue;

                }

                JavaFileObject prev = log.useSource(tree.sourcefile);

                try {

                    Location locn = getModuleLocation(tree);

                    if (locn != null) {

                        Name name = names.fromString(fileManager.inferModuleName(locn));

                        ModuleSymbol msym;

                        if (tree.defs.head.hasTag(MODULEDEF)) {

                            JCModuleDecl decl = (JCModuleDecl) tree.defs.head;

                            msym = decl.sym;

                            if (msym.name != name) {

                                log.error(decl.qualId, Errors.ModuleNameMismatch(msym.name, name));

                            }

                        } else {

                            msym = syms.enterModule(name);

                        }

                        if (msym.sourceLocation == null) {

                            msym.sourceLocation = locn;

                            if (fileManager.hasLocation(StandardLocation.CLASS_OUTPUT)) {

                                msym.classLocation = fileManager.getModuleLocation(

                                        StandardLocation.CLASS_OUTPUT, msym.name.toString());

                            }

                        }

                        tree.modle = msym;

                        rootModules.add(msym);

                    } else {

                        log.error(tree.pos(), Errors.UnnamedPkgNotAllowedNamedModules);

                        tree.modle = syms.errModule;

                    }

                } catch (IOException e) {

                    throw new Error(e); // FIXME

                } finally {

                    log.useSource(prev);

                }

            }

            if (syms.unnamedModule.sourceLocation == null) {

                syms.unnamedModule.completer = getUnnamedModuleCompleter();

                syms.unnamedModule.sourceLocation = StandardLocation.SOURCE_PATH;

                syms.unnamedModule.classLocation = StandardLocation.CLASS_PATH;

            }

            defaultModule = syms.unnamedModule;

        } else {

            if (defaultModule == null) {

                switch (rootModules.size()) {

                    case 0:

                        defaultModule = moduleFinder.findSingleModule();

                        if (defaultModule == syms.unnamedModule) {

                            if (moduleOverride != null) {

                                checkNoAllModulePath();

                                defaultModule = moduleFinder.findModule(names.fromString(moduleOverride));

                                defaultModule.sourceLocation = StandardLocation.SOURCE_PATH;

                            } else {

                                // Question: why not do findAllModules and initVisiblePackages here?

                                // i.e. body of unnamedModuleCompleter

                                defaultModule.completer = getUnnamedModuleCompleter();

                                defaultModule.classLocation = StandardLocation.CLASS_PATH;

                            }

                        } else {

                            checkSpecifiedModule(trees, Errors.ModuleInfoWithXmoduleClasspath);

                            checkNoAllModulePath();

                            defaultModule.complete();

                            // Question: why not do completeModule here?

                            defaultModule.completer = new Completer() {

                                @Override

                                public void complete(Symbol sym) throws CompletionFailure {

                                    completeModule((ModuleSymbol) sym);

                                }

                            };

                        }

                        rootModules.add(defaultModule);

                        break;

                    case 1:

                        checkSpecifiedModule(trees, Errors.ModuleInfoWithXmoduleSourcepath);

                        checkNoAllModulePath();

                        defaultModule = rootModules.iterator().next();

                        defaultModule.classLocation = StandardLocation.CLASS_OUTPUT;

                        break;

                    default:

                        Assert.error("too many modules");

                }

                defaultModule.sourceLocation = StandardLocation.SOURCE_PATH;

            } else if (rootModules.size() == 1 && defaultModule == rootModules.iterator().next()) {

                defaultModule.complete();

                defaultModule.completer = sym -> completeModule((ModuleSymbol) sym);

            } else {

                Assert.check(rootModules.isEmpty());

                rootModules.add(defaultModule);

            }

            if (defaultModule != syms.unnamedModule) {

                syms.unnamedModule.completer = getUnnamedModuleCompleter();

                if (moduleOverride == null) {

                    syms.unnamedModule.sourceLocation = StandardLocation.SOURCE_PATH;

                }

                syms.unnamedModule.classLocation = StandardLocation.CLASS_PATH;

            }

            for (JCCompilationUnit tree: trees) {

                tree.modle = defaultModule;

            }

        }

    }

    private Location getModuleLocation(JCCompilationUnit tree) throws IOException {

        switch (tree.defs.head.getTag()) {

            case MODULEDEF:

                return getModuleLocation(tree.sourcefile, null);

            case PACKAGEDEF:

                JCPackageDecl pkg = (JCPackageDecl) tree.defs.head;

                return getModuleLocation(tree.sourcefile, TreeInfo.fullName(pkg.pid));

            default:

                // code in unnamed module

                return null;

        }

    }

    private Location getModuleLocation(JavaFileObject fo, Name pkgName) throws IOException {

        // For now, just check module source path.

        // We may want to check source path as well.

        return fileManager.getModuleLocation(StandardLocation.MODULE_SOURCE_PATH,

                fo, (pkgName == null) ? null : pkgName.toString());

    }

    private void checkSpecifiedModule(List<JCCompilationUnit> trees, JCDiagnostic.Error error) {

        if (moduleOverride != null) {

            JavaFileObject prev = log.useSource(trees.head.sourcefile);

            try {

                log.error(trees.head.pos(), error);

            } finally {

                log.useSource(prev);

            }

        }

    }

    private void checkNoAllModulePath() {

        if (addModsOpt != null && Arrays.asList(addModsOpt.split(",")).contains(ALL_MODULE_PATH)) {

            log.error(Errors.AddmodsAllModulePathInvalid);

        }

    }

    private final Completer mainCompleter = new Completer() {

        @Override

        public void complete(Symbol sym) throws CompletionFailure {

            ModuleSymbol msym = moduleFinder.findModule((ModuleSymbol) sym);

            if (msym.kind == Kinds.Kind.ERR) {

                log.error(Errors.ModuleNotFound(msym));

                //make sure the module is initialized:

                msym.directives = List.nil();

                msym.exports = List.nil();

                msym.provides = List.nil();

                msym.requires = List.nil();

                msym.uses = List.nil();

            } else if ((msym.flags_field & Flags.AUTOMATIC_MODULE) != 0) {

                setupAutomaticModule(msym);

            } else {

                msym.module_info.complete();

            }

            // If module-info comes from a .java file, the underlying

            // call of classFinder.fillIn will have called through the

            // source completer, to Enter, and then to Modules.enter,

            // which will call completeModule.

            // But, if module-info comes from a .class file, the underlying

            // call of classFinder.fillIn will just call ClassReader to read

            // the .class file, and so we call completeModule here.

            if (msym.module_info.classfile == null || msym.module_info.classfile.getKind() == Kind.CLASS) {

                completeModule(msym);

            }

        }