/*

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

import java.io.UncheckedIOException;

import java.lang.ref.SoftReference;

import java.net.URI;

import java.nio.file.DirectoryStream;

import java.nio.file.FileSystem;

import java.nio.file.FileSystems;

import java.nio.file.FileSystemNotFoundException;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.ProviderNotFoundException;

import java.util.Collections;

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.LinkedHashSet;

import java.util.Map;

import java.util.MissingResourceException;

import java.util.ResourceBundle;

import java.util.Set;

import javax.tools.FileObject;

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

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

/**

 * A package-oriented index into the jrt: filesystem.

 */

public class JRTIndex {

    /** Get a shared instance of the cache. */

    private static JRTIndex sharedInstance;

    public synchronized static JRTIndex getSharedInstance() {

        if (sharedInstance == null) {

            try {

                sharedInstance = new JRTIndex();

            } catch (IOException e) {

                throw new UncheckedIOException(e);

            }

        }

        return sharedInstance;

    }

    /** Get a context-specific instance of a cache. */

    public static JRTIndex instance(Context context) {

        try {

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

            if (instance == null)

                context.put(JRTIndex.class, instance = new JRTIndex());

            return instance;

        } catch (IOException e) {

            throw new UncheckedIOException(e);

        }

    }

    public static boolean isAvailable() {

        try {

            FileSystems.getFileSystem(URI.create("jrt:/"));

            return true;

        } catch (ProviderNotFoundException | FileSystemNotFoundException e) {

            return false;

        }

    }

    /**

     * The jrt: file system.

     */

    private final FileSystem jrtfs;

    /**

     * A lazily evaluated set of entries about the contents of the jrt: file system.

     */

    private final Map<RelativeDirectory, SoftReference<Entry>> entries;

    /**

     * An entry provides cached info about a specific package directory within jrt:.

     */

    class Entry {

        /**

         * The regular files for this package.

         * For now, assume just one instance of each file across all modules.

         */

        final Map<String, Path> files;

        /**

         * The set of subdirectories in jrt: for this package.

         */

        final Set<RelativeDirectory> subdirs;

        /**

         * The info that used to be in ct.sym for classes in this package.

         */

        final CtSym ctSym;

        private Entry(Map<String, Path> files, Set<RelativeDirectory> subdirs, CtSym ctSym) {

            this.files = files;

            this.subdirs = subdirs;

            this.ctSym = ctSym;

        }

    }

    /**

     * The info that used to be in ct.sym for classes in a package.

     */

    public static class CtSym {

        /**

         * The classes in this package are internal and not visible.

         */

        public final boolean hidden;

        /**

         * The classes in this package are proprietary and will generate a warning.

         */

        public final boolean proprietary;

        /**

         * The minimum profile in which classes in this package are available.

         */

        public final String minProfile;

        CtSym(boolean hidden, boolean proprietary, String minProfile) {

            this.hidden = hidden;

            this.proprietary = proprietary;

            this.minProfile = minProfile;

        }

        @Override

        public String toString() {

            StringBuilder sb = new StringBuilder("CtSym[");

            boolean needSep = false;

            if (hidden) {

                sb.append("hidden");

                needSep = true;

            }

            if (proprietary) {

                if (needSep) sb.append(",");

                sb.append("proprietary");

                needSep = true;

            }

            if (minProfile != null) {

                if (needSep) sb.append(",");

                sb.append(minProfile);

            }

            sb.append("]");

            return sb.toString();

        }

        static final CtSym EMPTY = new CtSym(false, false, null);

    }

    /**

     * Create and initialize the index.

     */

    private JRTIndex() throws IOException {

        jrtfs = FileSystems.getFileSystem(URI.create("jrt:/"));

        entries = new HashMap<>();

    }

    public CtSym getCtSym(CharSequence packageName) throws IOException {

        return getEntry(RelativeDirectory.forPackage(packageName)).ctSym;

    }

    synchronized Entry getEntry(RelativeDirectory rd) throws IOException {

        SoftReference<Entry> ref = entries.get(rd);

        Entry e = (ref == null) ? null : ref.get();

        if (e == null) {

            Map<String, Path> files = new LinkedHashMap<>();

            Set<RelativeDirectory> subdirs = new LinkedHashSet<>();

            Path dir;

            if (rd.path.isEmpty()) {

                dir = jrtfs.getPath("/modules");

            } else {

                Path pkgs = jrtfs.getPath("/packages");

                dir = pkgs.resolve(rd.getPath().replaceAll("/$", "").replace("/", "."));

            }

            if (Files.exists(dir)) {

                try (DirectoryStream<Path> modules = Files.newDirectoryStream(dir)) {

                    for (Path module: modules) {

                        Path p = rd.resolveAgainst(module);

                        if (!Files.exists(p))

                            continue;

                        try (DirectoryStream<Path> stream = Files.newDirectoryStream(p)) {

                            for (Path entry: stream) {

                                String name = entry.getFileName().toString();

                                if (Files.isRegularFile(entry)) {

                                    // TODO: consider issue of files with same name in different modules

                                    files.put(name, entry);

                                } else if (Files.isDirectory(entry)) {

                                    subdirs.add(new RelativeDirectory(rd, name));

                                }

                            }

                        }

                    }

                }

            }

            e = new Entry(Collections.unmodifiableMap(files),

                    Collections.unmodifiableSet(subdirs),

                    getCtInfo(rd));

            entries.put(rd, new SoftReference<>(e));

        }

        return e;

    }

    public boolean isInJRT(FileObject fo) {

        if (fo instanceof PathFileObject) {

            Path path = ((PathFileObject) fo).getPath();

            return (path.getFileSystem() == jrtfs);

        } else {

            return false;

        }

    }

    private CtSym getCtInfo(RelativeDirectory dir) {

        if (dir.path.isEmpty())

            return CtSym.EMPTY;

        // It's a side-effect of the default build rules that ct.properties

        // ends up as a resource bundle.

        if (ctBundle == null) {

            final String bundleName = "com.sun.tools.javac.resources.ct";

            ctBundle = ResourceBundle.getBundle(bundleName);

        }

        try {

            String attrs = ctBundle.getString(dir.path.replace('/', '.') + '*');

            boolean hidden = false;

            boolean proprietary = false;

            String minProfile = null;

            for (String attr: attrs.split(" +", 0)) {

                switch (attr) {

                    case "hidden":

                        hidden = true;

                        break;

                    case "proprietary":

                        proprietary = true;

                        break;

                    default:

                        minProfile = attr;

                }

            }

            return new CtSym(hidden, proprietary, minProfile);

        } catch (MissingResourceException e) {

            return CtSym.EMPTY;

        }

    }

    private ResourceBundle ctBundle;

}