/*

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

import java.io.File;

import java.io.IOException;

import java.nio.file.Path;

import java.util.Collection;

import java.util.Iterator;

import java.util.ServiceLoader;

import java.util.Set;

import javax.tools.FileObject;

import javax.tools.JavaFileManager;

import javax.tools.JavaFileManager.Location;

import javax.tools.JavaFileObject;

import javax.tools.JavaFileObject.Kind;

import javax.tools.StandardJavaFileManager;

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

/**

 * A JavaFileManager that delegates to one of two delegate ClassLoaders.

 */

public class DelegatingJavaFileManager implements JavaFileManager {

    public static void installReleaseFileManager(Context context,

                                                 JavaFileManager releaseFM,

                                                 JavaFileManager originalFM) {

        context.put(JavaFileManager.class, (JavaFileManager) null);

        JavaFileManager nue = originalFM instanceof StandardJavaFileManager

                ? new DelegatingSJFM(releaseFM,

                                                        (StandardJavaFileManager) originalFM)

                : new DelegatingJavaFileManager(releaseFM, originalFM);

        context.put(JavaFileManager.class, nue);

    }

    private final JavaFileManager releaseFM;

    private final JavaFileManager baseFM;

    private DelegatingJavaFileManager(JavaFileManager releaseFM, JavaFileManager baseFM) {

        this.releaseFM = releaseFM;

        this.baseFM = baseFM;

    }

    private JavaFileManager delegate(Location location) {

        if (releaseFM.hasLocation(location)) {

            return releaseFM;

        }

        return baseFM;

    }

    @Override

    public ClassLoader getClassLoader(Location location) {

        return delegate(location).getClassLoader(location);

    }

    @Override

    public Iterable<JavaFileObject> list(Location location, String packageName,

                                         Set<Kind> kinds, boolean recurse) throws IOException {

        return delegate(location).list(location, packageName, kinds, recurse);

    }

    @Override

    public String inferBinaryName(Location location, JavaFileObject file) {

        return delegate(location).inferBinaryName(location, file);

    }

    @Override

    public boolean isSameFile(FileObject a, FileObject b) {

        return baseFM.isSameFile(a, b);

    }

    @Override

    public boolean handleOption(String current, Iterator<String> remaining) {

        return baseFM.handleOption(current, remaining);

    }

    @Override

    public boolean hasLocation(Location location) {

        return releaseFM.hasLocation(location) || baseFM.hasLocation(location);

    }

    @Override

    public JavaFileObject getJavaFileForInput(Location location, String className,

                                              Kind kind) throws IOException {

        return delegate(location).getJavaFileForInput(location, className, kind);

    }

    @Override

    public JavaFileObject getJavaFileForOutput(Location location, String className, Kind kind,

                                               FileObject sibling) throws IOException {

        return delegate(location).getJavaFileForOutput(location, className, kind, sibling);

    }

    @Override

    public FileObject getFileForInput(Location location, String packageName,

                                      String relativeName) throws IOException {

        return delegate(location).getFileForInput(location, packageName, relativeName);

    }

    @Override

    public FileObject getFileForOutput(Location location, String packageName, String relativeName,

                                       FileObject sibling) throws IOException {

        return delegate(location).getFileForOutput(location, packageName, relativeName, sibling);

    }

    @Override

    public void flush() throws IOException {

        releaseFM.flush();

        baseFM.flush();

    }

    @Override

    public void close() throws IOException {

        releaseFM.close();

        baseFM.close();

    }

    @Override

    public Location getLocationForModule(Location location,

                                         String moduleName) throws IOException {

        return delegate(location).getLocationForModule(location, moduleName);

    }

    @Override

    public Location getLocationForModule(Location location,

                                         JavaFileObject fo) throws IOException {

        return delegate(location).getLocationForModule(location, fo);

    }

    @Override

    public <S> ServiceLoader<S> getServiceLoader(Location location,

                                                 Class<S> service) throws IOException {

        return delegate(location).getServiceLoader(location, service);

    }

    @Override

    public String inferModuleName(Location location) throws IOException {

        return delegate(location).inferModuleName(location);

    }

    @Override

    public Iterable<Set<Location>> listLocationsForModules(Location location) throws IOException {

        return delegate(location).listLocationsForModules(location);

    }

    @Override

    public boolean contains(Location location, FileObject fo) throws IOException {

        return delegate(location).contains(location, fo);

    }

    @Override

    public int isSupportedOption(String option) {

        return baseFM.isSupportedOption(option);

    }

    public JavaFileManager getBaseFileManager() {

        return baseFM;

    }

    private static final class DelegatingSJFM extends DelegatingJavaFileManager

                                              implements StandardJavaFileManager {

        private final StandardJavaFileManager baseSJFM;

        private DelegatingSJFM(JavaFileManager releaseFM,

                                                  StandardJavaFileManager baseSJFM) {

            super(releaseFM, baseSJFM);

            this.baseSJFM = baseSJFM;

        }

        @Override

        public boolean isSameFile(FileObject a, FileObject b) {

            return baseSJFM.isSameFile(a, b);

        }

        @Override

        public Iterable<? extends JavaFileObject> getJavaFileObjectsFromFiles

                                                  (Iterable<? extends File> files) {

            return baseSJFM.getJavaFileObjectsFromFiles(files);

        }

        @Override

        public Iterable<? extends JavaFileObject> getJavaFileObjectsFromPaths

                                                  (Iterable<? extends Path> paths) {

            return baseSJFM.getJavaFileObjectsFromPaths(paths);

        }

        @Override

        public Iterable<? extends JavaFileObject> getJavaFileObjects(File... files) {

            return baseSJFM.getJavaFileObjects(files);

        }

        @Override

        public Iterable<? extends JavaFileObject> getJavaFileObjects(Path... paths) {

            return baseSJFM.getJavaFileObjects(paths);

        }

        @Override

        public Iterable<? extends JavaFileObject> getJavaFileObjectsFromStrings

                                                  (Iterable<String> names) {

            return baseSJFM.getJavaFileObjectsFromStrings(names);

        }

        @Override

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

            return baseSJFM.getJavaFileObjects(names);

        }

        @Override

        public void setLocation(Location location,

                                Iterable<? extends File> files) throws IOException {

            baseSJFM.setLocation(location, files);

        }

        @Override

        public void setLocationFromPaths(Location location,

                                         Collection<? extends Path> paths) throws IOException {

            baseSJFM.setLocationFromPaths(location, paths);

        }

        @Override

        public void setLocationForModule(Location location, String moduleName,

                                         Collection<? extends Path> paths) throws IOException {

            baseSJFM.setLocationForModule(location, moduleName, paths);

        }

        @Override

        public Iterable<? extends File> getLocation(Location location) {

            return baseSJFM.getLocation(location);

        }

        @Override

        public Iterable<? extends Path> getLocationAsPaths(Location location) {

            return baseSJFM.getLocationAsPaths(location);

        }

        @Override

        public Path asPath(FileObject file) {

            return baseSJFM.asPath(file);

        }

        @Override

        public void setPathFactory(PathFactory f) {

            baseSJFM.setPathFactory(f);

        }

    }

}