/*

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

import java.io.File;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.OutputStreamWriter;

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

import java.util.zip.ZipFile;

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

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

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

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

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

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

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 {

    public static char[] toArray(CharBuffer buffer) {

        if (buffer.hasArray())

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

        else

            return buffer.toString().toCharArray();

    }

    private FSInfo fsInfo;

    private boolean contextUseOptimizedZip;

    private ZipFileIndexCache zipFileIndexCache;

    private final Set<JavaFileObject.Kind> sourceOrClass =

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

    protected boolean mmappedIO;

    protected boolean symbolFileEnabled;

    protected enum SortFiles implements Comparator<File> {

        FORWARD {

            public int compare(File f1, File f2) {

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

            }

        },

        REVERSE {

            public int compare(File f1, File f2) {

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

            }

        }

    }

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

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

        contextUseOptimizedZip = options.getBoolean("useOptimizedZip", true);

        if (contextUseOptimizedZip)

            zipFileIndexCache = ZipFileIndexCache.getSharedInstance();

        mmappedIO = options.isSet("mmappedIO");

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

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

        if (sf != null) {

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

        }

    }

    /**

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

     */

    public void setSymbolFileEnabled(boolean b) {

        symbolFileEnabled = b;

    }

    public JavaFileObject getFileForInput(String name) {

        return getRegularFile(new File(name));

    }

    public JavaFileObject getRegularFile(File file) {

        return new RegularFileObject(this, file);

    }

    public JavaFileObject getFileForOutput(String classname,

                                           JavaFileObject.Kind kind,

                                           JavaFileObject sibling)

        throws IOException

    {

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

    }

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

        ListBuffer<File> files = new ListBuffer<>();

        for (String name : names)

            files.append(new File(nullCheck(name)));

        return getJavaFileObjectsFromFiles(files.toList());

    }

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

    }

    /**

     * Insert all files in subdirectory subdirectory of directory directory

     * which match fileKinds into resultList

     */

    private void listDirectory(File directory,

                               RelativeDirectory subdirectory,

                               Set<JavaFileObject.Kind> fileKinds,

                               boolean recurse,

                               ListBuffer<JavaFileObject> resultList) {

        File d = subdirectory.getFile(directory);

        if (!caseMapCheck(d, subdirectory))

            return;

        File[] files = d.listFiles();

        if (files == null)

            return;

        if (sortFiles != null)

            Arrays.sort(files, sortFiles);

        for (File f: files) {

            String fname = f.getName();

            if (f.isDirectory()) {

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

                    listDirectory(directory,

                                  new RelativeDirectory(subdirectory, fname),

                                  fileKinds,

                                  recurse,

                                  resultList);

                }

            } else {

                if (isValidFile(fname, fileKinds)) {

                    JavaFileObject fe =

                        new RegularFileObject(this, fname, new File(d, fname));

                    resultList.append(fe);

                }

            }

        }

    }

    /**

     * Insert all files in subdirectory subdirectory of archive archive

     * which match fileKinds into resultList

     */

    private void listArchive(Archive archive,

                               RelativeDirectory subdirectory,

                               Set<JavaFileObject.Kind> fileKinds,

                               boolean recurse,

                               ListBuffer<JavaFileObject> resultList) {

        // Get the files directly in the subdir

        List<String> files = archive.getFiles(subdirectory);

        if (files != null) {

            for (; !files.isEmpty(); files = files.tail) {

                String file = files.head;

                if (isValidFile(file, fileKinds)) {

                    resultList.append(archive.getFileObject(subdirectory, file));

                }

            }

        }

        if (recurse) {

            for (RelativeDirectory s: archive.getSubdirectories()) {

                if (subdirectory.contains(s)) {

                    // Because the archive map is a flat list of directories,

                    // the enclosing loop will pick up all child subdirectories.

                    // Therefore, there is no need to recurse deeper.

                    listArchive(archive, s, fileKinds, false, resultList);

                }

            }

        }

    }

    /**

     * container is a directory, a zip file, or a non-existant path.

     * Insert all files in subdirectory subdirectory of container which

     * match fileKinds into resultList

     */

    private void listContainer(File container,

                               RelativeDirectory subdirectory,

                               Set<JavaFileObject.Kind> fileKinds,

                               boolean recurse,

                               ListBuffer<JavaFileObject> resultList) {

        Archive archive = archives.get(container);

        if (archive == null) {

            // archives are not created for directories.

            if  (fsInfo.isDirectory(container)) {

                listDirectory(container,

                              subdirectory,

                              fileKinds,

                              recurse,

                              resultList);

                return;

            }

            // Not a directory; either a file or non-existant, create the archive

            try {

                archive = openArchive(container);

            } catch (IOException ex) {

                log.error("error.reading.file",

                          container, getMessage(ex));

                return;

            }

        }

        listArchive(archive,

                    subdirectory,

                    fileKinds,

                    recurse,

                    resultList);

    }

    private boolean isValidFile(String s, Set<JavaFileObject.Kind> fileKinds) {

        JavaFileObject.Kind kind = getKind(s);

        return fileKinds.contains(kind);

    }

    private static final boolean fileSystemIsCaseSensitive =

        File.separatorChar == '/';

    /** Hack to make Windows case sensitive. Test whether given path

     *  ends in a string of characters with the same case as given name.

     *  Ignore file separators in both path and name.

     */

    private boolean caseMapCheck(File f, RelativePath name) {

        if (fileSystemIsCaseSensitive) return true;

        // Note that getCanonicalPath() returns the case-sensitive

        // spelled file name.

        String path;

        try {

            path = f.getCanonicalPath();

        } catch (IOException ex) {

            return false;

        }

        char[] pcs = path.toCharArray();

        char[] ncs = name.path.toCharArray();

        int i = pcs.length - 1;

        int j = ncs.length - 1;

        while (i >= 0 && j >= 0) {

            while (i >= 0 && pcs[i] == File.separatorChar) i--;

            while (j >= 0 && ncs[j] == '/') j--;

            if (i >= 0 && j >= 0) {

                if (pcs[i] != ncs[j]) return false;

                i--;

                j--;

            }

        }

        return j < 0;

    }

    /**

     * An archive provides a flat directory structure of a ZipFile by

     * mapping directory names to lists of files (basenames).

     */

    public interface Archive {

        void close() throws IOException;

        boolean contains(RelativePath name);

        JavaFileObject getFileObject(RelativeDirectory subdirectory, String file);

        List<String> getFiles(RelativeDirectory subdirectory);

        Set<RelativeDirectory> getSubdirectories();

    }

    public class MissingArchive implements Archive {

        final File zipFileName;

        public MissingArchive(File name) {

            zipFileName = name;

        }

        public boolean contains(RelativePath name) {

            return false;

        }

        public void close() {

        }

        public JavaFileObject getFileObject(RelativeDirectory subdirectory, String file) {

            return null;

        }

        public List<String> getFiles(RelativeDirectory subdirectory) {

            return List.nil();

        }

        public Set<RelativeDirectory> getSubdirectories() {

            return Collections.emptySet();

        }

        @Override

        public String toString() {

            return "MissingArchive[" + zipFileName + "]";

        }

    }

    /** A directory of zip files already opened.

     */

    Map<File, Archive> archives = new HashMap<>();

    private static final String[] symbolFileLocation = { "lib", "ct.sym" };

    private static final RelativeDirectory symbolFilePrefix

            = new RelativeDirectory("META-INF/sym/rt.jar/");

    /*

     * This method looks for a ZipFormatException and takes appropriate

     * evasive action. If there is a failure in the fast mode then we

     * fail over to the platform zip, and allow it to deal with a potentially

     * non compliant zip file.

     */

    protected Archive openArchive(File zipFilename) throws IOException {

        try {

            return openArchive(zipFilename, contextUseOptimizedZip);

        } catch (IOException ioe) {

            if (ioe instanceof ZipFileIndex.ZipFormatException) {

                return openArchive(zipFilename, false);

            } else {

                throw ioe;

            }

        }

    }

    /** Open a new zip file directory, and cache it.

     */

    private Archive openArchive(File zipFileName, boolean useOptimizedZip) throws IOException {

        File origZipFileName = zipFileName;

        if (symbolFileEnabled && locations.isDefaultBootClassPathRtJar(zipFileName)) {

            File file = zipFileName.getParentFile().getParentFile(); // ${java.home}

            if (new File(file.getName()).equals(new File("jre")))

                file = file.getParentFile();

            // file == ${jdk.home}

            for (String name : symbolFileLocation)

                file = new File(file, name);

            // file == ${jdk.home}/lib/ct.sym

            if (file.exists())

                zipFileName = file;

        }

        Archive archive;

        try {

            ZipFile zdir = null;

            boolean usePreindexedCache = false;

            String preindexCacheLocation = null;

            if (!useOptimizedZip) {

                zdir = new ZipFile(zipFileName);

            } else {

                usePreindexedCache = options.isSet("usezipindex");

                preindexCacheLocation = options.get("java.io.tmpdir");

                String optCacheLoc = options.get("cachezipindexdir");

                if (optCacheLoc != null && optCacheLoc.length() != 0) {