/*

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

import java.io.File;

import java.io.IOException;

import java.net.MalformedURLException;

import java.net.URI;

import java.net.URISyntaxException;

import java.net.URL;

import java.nio.CharBuffer;

import java.nio.charset.Charset;

import java.nio.file.FileSystem;

import java.nio.file.FileSystems;

import java.nio.file.FileVisitOption;

import java.nio.file.FileVisitResult;

import java.nio.file.Files;

import java.nio.file.InvalidPathException;

import java.nio.file.LinkOption;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.nio.file.ProviderNotFoundException;

import java.nio.file.SimpleFileVisitor;

import java.nio.file.attribute.BasicFileAttributes;

import java.nio.file.spi.FileSystemProvider;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.Comparator;

import java.util.EnumSet;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Objects;

import java.util.ServiceLoader;

import java.util.Set;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import javax.lang.model.SourceVersion;

import javax.tools.FileObject;

import javax.tools.JavaFileManager;

import javax.tools.JavaFileObject;

import javax.tools.StandardJavaFileManager;

import com.sun.tools.javac.file.RelativePath.RelativeDirectory;

import com.sun.tools.javac.file.RelativePath.RelativeFile;

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

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

import com.sun.tools.javac.util.DefinedBy.Api;

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

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

import com.sun.tools.javac.util.JDK9Wrappers.Configuration;

import com.sun.tools.javac.util.JDK9Wrappers.Layer;

import com.sun.tools.javac.util.JDK9Wrappers.ModuleFinder;

import com.sun.tools.javac.util.JDK9Wrappers.ServiceLoaderHelper;

import static java.nio.file.FileVisitOption.FOLLOW_LINKS;

import static javax.tools.StandardLocation.*;

/**

 * This class provides access to the source, class and other files

 * used by the compiler and related tools.

 *

 * <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 JavacFileManager extends BaseFileManager implements StandardJavaFileManager {

    @SuppressWarnings("cast")

    public static char[] toArray(CharBuffer buffer) {

        if (buffer.hasArray())

            return ((CharBuffer)buffer.compact().flip()).array();

        else

            return buffer.toString().toCharArray();

    }

    private FSInfo fsInfo;

    private final Set<JavaFileObject.Kind> sourceOrClass =

        EnumSet.of(JavaFileObject.Kind.SOURCE, JavaFileObject.Kind.CLASS);

    protected boolean symbolFileEnabled;

    private PathFactory pathFactory = Paths::get;

    protected enum SortFiles implements Comparator<Path> {

        FORWARD {

            @Override

            public int compare(Path f1, Path f2) {

                return f1.getFileName().compareTo(f2.getFileName());

            }

        },

        REVERSE {

            @Override

            public int compare(Path f1, Path f2) {

                return -f1.getFileName().compareTo(f2.getFileName());

            }

        }

    }

    protected SortFiles sortFiles;

    /**

     * Register a Context.Factory to create a JavacFileManager.

     */

    public static void preRegister(Context context) {

        context.put(JavaFileManager.class, new Context.Factory<JavaFileManager>() {

            @Override

            public JavaFileManager make(Context c) {

                return new JavacFileManager(c, true, null);

            }

        });

    }

    /**

     * Create a JavacFileManager using a given context, optionally registering

     * it as the JavaFileManager for that context.

     */

    public JavacFileManager(Context context, boolean register, Charset charset) {

        super(charset);

        if (register)

            context.put(JavaFileManager.class, this);

        setContext(context);

    }

    /**

     * Set the context for JavacFileManager.

     */

    @Override

    public void setContext(Context context) {

        super.setContext(context);

        fsInfo = FSInfo.instance(context);

        symbolFileEnabled = !options.isSet("ignore.symbol.file");

        String sf = options.get("sortFiles");

        if (sf != null) {

            sortFiles = (sf.equals("reverse") ? SortFiles.REVERSE : SortFiles.FORWARD);

        }

    }

    @Override @DefinedBy(DefinedBy.Api.COMPILER)

    public void setPathFactory(PathFactory f) {

        pathFactory = Objects.requireNonNull(f);

        locations.setPathFactory(f);

    }

    private Path getPath(String first, String... more) {

        return pathFactory.getPath(first, more);

    }

    /**

     * Set whether or not to use ct.sym as an alternate to rt.jar.

     */

    public void setSymbolFileEnabled(boolean b) {

        symbolFileEnabled = b;

    }

    public boolean isSymbolFileEnabled() {

        return symbolFileEnabled;

    }

    // used by tests

    public JavaFileObject getJavaFileObject(String name) {

        return getJavaFileObjects(name).iterator().next();

    }

    // used by tests

    public JavaFileObject getJavaFileObject(Path file) {

        return getJavaFileObjects(file).iterator().next();

    }

    public JavaFileObject getFileForOutput(String classname,

                                           JavaFileObject.Kind kind,

                                           JavaFileObject sibling)

        throws IOException

    {

        return getJavaFileForOutput(CLASS_OUTPUT, classname, kind, sibling);

    }

    @Override @DefinedBy(Api.COMPILER)

    public Iterable<? extends JavaFileObject> getJavaFileObjectsFromStrings(Iterable<String> names) {

        ListBuffer<Path> paths = new ListBuffer<>();

        for (String name : names)

            paths.append(getPath(nullCheck(name)));

        return getJavaFileObjectsFromPaths(paths.toList());

    }

    @Override @DefinedBy(Api.COMPILER)

    public Iterable<? extends JavaFileObject> getJavaFileObjects(String... names) {

        return getJavaFileObjectsFromStrings(Arrays.asList(nullCheck(names)));

    }

    private static boolean isValidName(String name) {

        // Arguably, isValidName should reject keywords (such as in SourceVersion.isName() ),

        // but the set of keywords depends on the source level, and we don't want

        // impls of JavaFileManager to have to be dependent on the source level.

        // Therefore we simply check that the argument is a sequence of identifiers

        // separated by ".".

        for (String s : name.split("\\.", -1)) {

            if (!SourceVersion.isIdentifier(s))

                return false;

        }

        return true;

    }

    private static void validateClassName(String className) {

        if (!isValidName(className))

            throw new IllegalArgumentException("Invalid class name: " + className);

    }

    private static void validatePackageName(String packageName) {

        if (packageName.length() > 0 && !isValidName(packageName))

            throw new IllegalArgumentException("Invalid packageName name: " + packageName);

    }

    public static void testName(String name,

                                boolean isValidPackageName,

                                boolean isValidClassName)

    {

        try {

            validatePackageName(name);

            if (!isValidPackageName)

                throw new AssertionError("Invalid package name accepted: " + name);

            printAscii("Valid package name: \"%s\"", name);

        } catch (IllegalArgumentException e) {

            if (isValidPackageName)

                throw new AssertionError("Valid package name rejected: " + name);

            printAscii("Invalid package name: \"%s\"", name);

        }

        try {

            validateClassName(name);

            if (!isValidClassName)

                throw new AssertionError("Invalid class name accepted: " + name);

            printAscii("Valid class name: \"%s\"", name);

        } catch (IllegalArgumentException e) {

            if (isValidClassName)

                throw new AssertionError("Valid class name rejected: " + name);

            printAscii("Invalid class name: \"%s\"", name);

        }

    }

    private static void printAscii(String format, Object... args) {

        String message;

        try {

            final String ascii = "US-ASCII";

            message = new String(String.format(null, format, args).getBytes(ascii), ascii);

        } catch (java.io.UnsupportedEncodingException ex) {

            throw new AssertionError(ex);

        }

        System.out.println(message);

    }

    private final Map<Path, Container> containers = new HashMap<>();

    synchronized Container getContainer(Path path) throws IOException {

        Container fs = containers.get(path);

        if (fs != null) {

            return fs;

        }

        if (fsInfo.isFile(path) && path.equals(Locations.thisSystemModules)) {

            containers.put(path, fs = new JRTImageContainer());

            return fs;

        }

        Path realPath = fsInfo.getCanonicalFile(path);

        fs = containers.get(realPath);

        if (fs != null) {

            containers.put(path, fs);

            return fs;

        }

        BasicFileAttributes attr = null;

        try {

            attr = Files.readAttributes(realPath, BasicFileAttributes.class);

        } catch (IOException ex) {

            //non-existing

            fs = MISSING_CONTAINER;

        }

        if (attr != null) {

            if (attr.isDirectory()) {

                fs = new DirectoryContainer(realPath);

            } else {

                try {

                    fs = new ArchiveContainer(realPath);

                } catch (ProviderNotFoundException | SecurityException ex) {

                    throw new IOException(ex);

                }

            }

        }

        containers.put(realPath, fs);

        containers.put(path, fs);

        return fs;

    }

    private interface Container {

        /**

         * Insert all files in subdirectory subdirectory of container which

         * match fileKinds into resultList

         */

        public abstract void list(Path userPath,

                                  RelativeDirectory subdirectory,

                                  Set<JavaFileObject.Kind> fileKinds,

                                  boolean recurse,

                                  ListBuffer<JavaFileObject> resultList) throws IOException;

        public abstract JavaFileObject getFileObject(Path userPath, RelativeFile name) throws IOException;

        public abstract void close() throws IOException;

    }

    private static final Container MISSING_CONTAINER =  new Container() {

        @Override

        public void list(Path userPath,

                         RelativeDirectory subdirectory,

                         Set<JavaFileObject.Kind> fileKinds,

                         boolean recurse,

                         ListBuffer<JavaFileObject> resultList) throws IOException {

        }

        @Override

        public JavaFileObject getFileObject(Path userPath, RelativeFile name) throws IOException {

            return null;

        }

        @Override

        public void close() throws IOException {}

    };

    private final class JRTImageContainer implements Container {

        /**

         * Insert all files in a subdirectory of the platform image

         * which match fileKinds into resultList.

         */

        @Override

        public void list(Path userPath,

                         RelativeDirectory subdirectory,

                         Set<JavaFileObject.Kind> fileKinds,

                         boolean recurse,

                         ListBuffer<JavaFileObject> resultList) throws IOException {

            try {

                JRTIndex.Entry e = getJRTIndex().getEntry(subdirectory);

                if (symbolFileEnabled && e.ctSym.hidden)

                    return;

                for (Path file: e.files.values()) {

                    if (fileKinds.contains(getKind(file))) {

                        JavaFileObject fe

                                = PathFileObject.forJRTPath(JavacFileManager.this, file);

                        resultList.append(fe);

                    }

                }

                if (recurse) {

                    for (RelativeDirectory rd: e.subdirs) {

                        list(userPath, rd, fileKinds, recurse, resultList);

                    }

                }

            } catch (IOException ex) {

                ex.printStackTrace(System.err);

                log.error("error.reading.file", userPath, getMessage(ex));

            }

        }

        @Override

        public JavaFileObject getFileObject(Path userPath, RelativeFile name) throws IOException {

            JRTIndex.Entry e = getJRTIndex().getEntry(name.dirname());

            if (symbolFileEnabled && e.ctSym.hidden)

                return null;

            Path p = e.files.get(name.basename());

            if (p != null) {

                return PathFileObject.forJRTPath(JavacFileManager.this, p);

            } else {

                return null;

            }

        }

        @Override

        public void close() throws IOException {

        }

    }

    private synchronized JRTIndex getJRTIndex() {

        if (jrtIndex == null)

            jrtIndex = JRTIndex.getSharedInstance();

        return jrtIndex;

    }

    private JRTIndex jrtIndex;

    private final class DirectoryContainer implements Container {

        private final Path directory;

        public DirectoryContainer(Path directory) {

            this.directory = directory;

        }

        /**

         * Insert all files in subdirectory subdirectory of directory userPath

         * which match fileKinds into resultList

         */

        @Override

        public void list(Path userPath,

                         RelativeDirectory subdirectory,

                         Set<JavaFileObject.Kind> fileKinds,

                         boolean recurse,

                         ListBuffer<JavaFileObject> resultList) throws IOException {

            Path d;

            try {

                d = subdirectory.resolveAgainst(userPath);

            } catch (InvalidPathException ignore) {

                return ;

            }

            if (!Files.exists(d)) {

               return;

            }

            if (!caseMapCheck(d, subdirectory)) {

                return;

            }

            java.util.List<Path> files;

            try (Stream<Path> s = Files.list(d)) {

                files = (sortFiles == null ? s : s.sorted(sortFiles)).collect(Collectors.toList());

            } catch (IOException ignore) {

                return;

            }

            for (Path f: files) {

                String fname = f.getFileName().toString();

                if (fname.endsWith("/"))

                    fname = fname.substring(0, fname.length() - 1);

                if (Files.isDirectory(f)) {

                    if (recurse && SourceVersion.isIdentifier(fname)) {

                        list(userPath,

                             new RelativeDirectory(subdirectory, fname),

                             fileKinds,

                             recurse,

                             resultList);

                    }

                } else {

                    if (isValidFile(fname, fileKinds)) {

                        RelativeFile file = new RelativeFile(subdirectory, fname);

                        JavaFileObject fe = PathFileObject.forDirectoryPath(JavacFileManager.this,

                                file.resolveAgainst(directory), userPath, file);

                        resultList.append(fe);

                    }

                }

            }

        }

        @Override

        public JavaFileObject getFileObject(Path userPath, RelativeFile name) throws IOException {

            try {

                Path f = name.resolveAgainst(userPath);

                if (Files.exists(f))

                    return PathFileObject.forSimplePath(JavacFileManager.this,

                            fsInfo.getCanonicalFile(f), f);

            } catch (InvalidPathException ignore) {

            }

            return null;

        }

        @Override