/*

 * 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.

 *

 * 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 org.graalvm.compiler.hotspot;

import static jdk.vm.ci.common.InitTimer.timer;

import static jdk.vm.ci.services.Services.IS_BUILDING_NATIVE_IMAGE;

import static org.graalvm.compiler.hotspot.HotSpotGraalOptionValues.GRAAL_OPTION_PROPERTY_PREFIX;

import java.io.PrintStream;

import org.graalvm.compiler.api.runtime.GraalRuntime;

import org.graalvm.compiler.debug.MethodFilter;

import org.graalvm.compiler.options.Option;

import org.graalvm.compiler.options.OptionKey;

import org.graalvm.compiler.options.OptionType;

import org.graalvm.compiler.options.OptionValues;

import org.graalvm.compiler.options.OptionsParser;

import org.graalvm.compiler.phases.tiers.CompilerConfiguration;

import jdk.vm.ci.common.InitTimer;

import jdk.vm.ci.hotspot.HotSpotJVMCICompilerFactory;

import jdk.vm.ci.hotspot.HotSpotJVMCIRuntime;

import jdk.vm.ci.runtime.JVMCIRuntime;

public final class HotSpotGraalCompilerFactory extends HotSpotJVMCICompilerFactory {

    private static MethodFilter[] graalCompileOnlyFilter;

    private static boolean compileGraalWithC1Only;

    private IsGraalPredicate isGraalPredicate;

    private final HotSpotGraalJVMCIServiceLocator locator;

    HotSpotGraalCompilerFactory(HotSpotGraalJVMCIServiceLocator locator) {

        this.locator = locator;

    }

    @Override

    public String getCompilerName() {

        return "graal";

    }

    /**

     * Initialized when this factory is {@linkplain #onSelection() selected}.

     */

    private OptionValues options;

    @Override

    public void onSelection() {

        assert options == null : "cannot select " + getClass() + " service more than once";

        options = HotSpotGraalOptionValues.defaultOptions();

        initializeGraalCompilePolicyFields(options);

        isGraalPredicate = compileGraalWithC1Only ? new IsGraalPredicate() : null;

        /*

         * Exercise this code path early to encourage loading now. This doesn't solve problem of

         * deadlock during class loading but seems to eliminate it in practice.

         */

        if (IS_BUILDING_NATIVE_IMAGE) {

            // Triggers initialization of all option descriptors

            Options.CompileGraalWithC1Only.getName();

        }

    }

    private static void initializeGraalCompilePolicyFields(OptionValues options) {

        String optionValue = Options.GraalCompileOnly.getValue(options);

        if (optionValue != null) {

            MethodFilter[] filter = MethodFilter.parse(optionValue);

            if (filter.length == 0) {

                filter = null;

            }

            graalCompileOnlyFilter = filter;

        }

    }

    @Override

    public void printProperties(PrintStream out) {

        out.println("[Graal properties]");

        options.printHelp(OptionsParser.getOptionsLoader(), out, GRAAL_OPTION_PROPERTY_PREFIX);

    }

    static class Options {

        // @formatter:off

        @Option(help = "In tiered mode compile Graal and JVMCI using optimized first tier code.", type = OptionType.Expert)

        public static final OptionKey<Boolean> CompileGraalWithC1Only = new OptionKey<>(true);

        @Option(help = "A filter applied to a method the VM has selected for compilation by Graal. " +

                       "A method not matching the filter is redirected to a lower tier compiler. " +

                       "The filter format is the same as for the MethodFilter option.", type = OptionType.Expert)

        public static final OptionKey<String> GraalCompileOnly = new OptionKey<>(null);

        // @formatter:on

    }

    @Override

    public HotSpotGraalCompiler createCompiler(JVMCIRuntime runtime) {

        CompilerConfigurationFactory factory = CompilerConfigurationFactory.selectFactory(null, options);

        if (isGraalPredicate != null) {

        }

        HotSpotGraalCompiler compiler = createCompiler("VM", runtime, options, factory);

        // Only the HotSpotGraalRuntime associated with the compiler created via

        // jdk.vm.ci.runtime.JVMCIRuntime.getCompiler() is registered for receiving

        // VM events.

        locator.onCompilerCreation(compiler);

        return compiler;

    }

    /**

     * Creates a new {@link HotSpotGraalRuntime} object and a new {@link HotSpotGraalCompiler} and

     * returns the latter.

     *

     * @param runtimeNameQualifier a qualifier to be added to the {@linkplain GraalRuntime#getName()

     *            name} of the {@linkplain HotSpotGraalCompiler#getGraalRuntime() runtime} created

     *            by this method

     * @param runtime the JVMCI runtime on which the {@link HotSpotGraalRuntime} is built

     * @param compilerConfigurationFactory factory for the {@link CompilerConfiguration}

     */

    @SuppressWarnings("try")

    public static HotSpotGraalCompiler createCompiler(String runtimeNameQualifier, JVMCIRuntime runtime, OptionValues options, CompilerConfigurationFactory compilerConfigurationFactory) {

        HotSpotJVMCIRuntime jvmciRuntime = (HotSpotJVMCIRuntime) runtime;

        try (InitTimer t = timer("HotSpotGraalRuntime.<init>")) {

            HotSpotGraalRuntime graalRuntime = new HotSpotGraalRuntime(runtimeNameQualifier, jvmciRuntime, compilerConfigurationFactory, options);

            return new HotSpotGraalCompiler(jvmciRuntime, graalRuntime, graalRuntime.getOptions());

        }

    }

    @Override

    public CompilationLevelAdjustment getCompilationLevelAdjustment() {

    }

    @Override

    public CompilationLevel adjustCompilationLevel(Object declaringClassObject, String name, String signature, boolean isOsr, CompilationLevel level) {

        Class<?> declaringClass = (Class<?>) declaringClassObject;

    }

    static {

        // Fail-fast detection for package renaming to guard use of package

        // prefixes in adjustCompilationLevelInternal.

        assert jdk.vm.ci.services.Services.class.getName().equals("jdk.vm.ci.services.Services");

        assert HotSpotGraalCompilerFactory.class.getName().equals("org.graalvm.compiler.hotspot.HotSpotGraalCompilerFactory");

    }

                return CompilationLevel.Simple;

            }

        }

        return level;

    }

}