/*
 * Copyright (c) 2014, 2024, 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.
 *
 * 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 jdk.vm.ci.services;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.Consumer;
import java.util.function.Supplier;

import jdk.internal.misc.TerminatingThreadLocal;
import jdk.internal.misc.VM;
import jdk.internal.misc.Unsafe;
import jdk.internal.util.Architecture;
import jdk.internal.util.OperatingSystem;

/**
 * Provides utilities needed by JVMCI clients.
 */
public final class Services {

    /**
     * Guards code that should only be run in a JVMCI shared library. Such code must be directly
     * guarded by an {@code if} statement on this field - the guard cannot be behind a method call.
     *
     * The value of this field in a JVMCI shared library runtime must be {@code true}.
     */
    public static final boolean IS_IN_NATIVE_IMAGE;
    static {
        /*
         * Prevents javac from constant folding use of this field. It is set to true by the process
         * that builds the shared library.
         */
        IS_IN_NATIVE_IMAGE = false;
    }

    private Services() {
    }

    /**
     * Lazily initialized in {@link #getSavedProperties}.
     */
    private static volatile Map<String, String> savedProperties;

    /**
     * Gets an unmodifiable copy of the system properties as of VM startup.
     *
     * If running on Hotspot, this will be the system properties parsed by {@code arguments.cpp}
     * plus {@code java.specification.version}, {@code os.name} and {@code os.arch}. The latter two
     * are forced to be the real OS and architecture. That is, values for these two properties set
     * on the command line are ignored.
     */
    public static Map<String, String> getSavedProperties() {
        if (savedProperties == null) {
            synchronized (Services.class) {
                if (savedProperties == null) {
                    savedProperties = initProperties();
                }
            }
        }
        return savedProperties;
    }

    /**
     * Helper method equivalent to {@link #getSavedProperties()}{@code .getOrDefault(name, def)}.
     */
    public static String getSavedProperty(String name, String def) {
        return Services.getSavedProperties().getOrDefault(name, def);
    }

    /**
     * Helper method equivalent to {@link #getSavedProperties()}{@code .get(name)}.
     */
    public static String getSavedProperty(String name) {
        return Services.getSavedProperties().get(name);
    }

    /**
     * Causes the JVMCI subsystem to be initialized if it isn't already initialized.
     */
    public static void initializeJVMCI() {
        try {
            Class.forName("jdk.vm.ci.runtime.JVMCI");
        } catch (ClassNotFoundException e) {
            throw new InternalError(e);
        }
    }

    /**
     * Opens all JVMCI packages to {@code otherModule}.
     */
    static void openJVMCITo(Module otherModule) {
        Module jvmci = Services.class.getModule();
        if (jvmci != otherModule) {
            Set<String> packages = jvmci.getPackages();
            for (String pkg : packages) {
                boolean opened = jvmci.isOpen(pkg, otherModule);
                if (!opened) {
                    jvmci.addOpens(pkg, otherModule);
                }
            }
        }
    }

    /**
     * Creates a thread-local variable that notifies {@code onThreadTermination} when a thread
     * terminates and it has been initialized in the terminating thread (even if it was initialized
     * with a null value). A typical use is to release resources associated with a thread.
     *
     * @param initialValue a supplier to be used to determine the initial value
     * @param onThreadTermination a consumer invoked by a thread when terminating and the
     *            thread-local has an associated value for the terminating thread. The current
     *            thread's value of the thread-local variable is passed as a parameter to the
     *            consumer.
     */
    public static <T> ThreadLocal<T> createTerminatingThreadLocal(Supplier<T> initialValue, Consumer<T> onThreadTermination) {
        Objects.requireNonNull(initialValue, "initialValue must be non null.");
        Objects.requireNonNull(onThreadTermination, "onThreadTermination must be non null.");
        return new TerminatingThreadLocal<>() {

            @Override
            protected T initialValue() {
                return initialValue.get();
            }

            @Override
            protected void threadTerminated(T value) {
                onThreadTermination.accept(value);
            }
        };
    }

    static String toJavaString(Unsafe unsafe, long cstring) {
        if (cstring == 0) {
            return null;
        }
        int len = 0;
        for (long p = cstring; unsafe.getByte(p) != 0; p++) {
            len++;
        }
        byte[] buf = new byte[len];
        for (int i = 0; i < len; i++) {
            buf[i] = unsafe.getByte(cstring + i);
        }
        return new String(buf, java.nio.charset.StandardCharsets.UTF_8);
    }

    /**
     * Gets the value of {@code Arguments::systemProperties()} and puts the offsets
     * of {@code SystemProperty} fields into {@code offsets}. The values returned in
     * {@code offsets} are:
     *
     * <pre>
     *     [ next,  // SystemProperty::next_offset_in_bytes()
     *       key,   // SystemProperty::key_offset_in_bytes()
     *       value  // PathString::value_offset_in_bytes()
     *     ]
     * </pre>
     *
     * Ideally this would be done with vmstructs but that code is in {@code jdk.vm.ci.hotspot}.
     */
    private static native long readSystemPropertiesInfo(int[] offsets);

    /**
     * Parses the native {@code Arguments::systemProperties()} data structure using Unsafe to
     * create a properties map. This parsing is safe as argument parsing in completed in
     * early VM start before this code can be executed, making {@code Arguments::systemProperties()}
     * effectively read-only by now.
     */
    private static Map<String, String> initProperties() {
        int[] offsets = new int[3];
        long systemProperties = readSystemPropertiesInfo(offsets);
        int nextOffset = offsets[0];
        int keyOffset = offsets[1];
        int valueOffset = offsets[2];

        int count = 0;
        Unsafe unsafe = Unsafe.getUnsafe();
        for (long prop = systemProperties; prop != 0; prop = unsafe.getLong(prop + nextOffset)) {
            if (unsafe.getLong(prop + valueOffset) != 0) {
                count++;
            } else {
                // Some internal properties (e.g. jdk.boot.class.path.append) can have a null
                // value and should just be ignored. Note that null is different than the empty string.
            }
        }
        Map<String, SystemProperties.Value> props = new HashMap<>(count + 1);
        int i = 0;
        for (long prop = systemProperties; prop != 0; prop = unsafe.getLong(prop + nextOffset)) {
            String key = toJavaString(unsafe, unsafe.getLong(prop + keyOffset));
            long valueAddress = unsafe.getLong(prop + valueOffset);
            if (valueAddress != 0) {
                props.put(key, new SystemProperties.Value(unsafe, valueAddress));
                i++;
            }
        }
        if (i != count) {
            throw new InternalError(i + " != " + count);
        }
        if (!props.containsKey("java.specification.version")) {
            SystemProperties.Value v = Objects.requireNonNull(props.get("java.vm.specification.version"));
            props.put("java.specification.version", v);
        }

        SystemProperties res = new SystemProperties(unsafe, sanitizeOSArch(props));
        if ("true".equals(res.get("debug.jvmci.PrintSavedProperties"))) {
            System.out.println("[Saved system properties]");
            for (Map.Entry<String, String> e : res.entrySet()) {
                System.out.printf("%s=%s%n", e.getKey(), e.getValue());
            }
        }
        return res;
    }

    // Force os.name and os.arch to reflect the actual OS and architecture.
    // JVMCI configures itself based on these values and needs to be isolated
    // from apps that set them on the command line.
    private static Map<String, SystemProperties.Value> sanitizeOSArch(Map<String, SystemProperties.Value> props) {
        props.put("os.arch", new SystemProperties.Value(realArch()));
        props.put("os.name", new SystemProperties.Value(realOS()));
        return props;
    }

    private static String realOS() {
        OperatingSystem os = OperatingSystem.current();
        switch (os) {
            case LINUX: return "Linux";
            case MACOS: return "Mac OS X";
            case AIX: return "AIX";
            case WINDOWS: {
                String osName = System.getProperty("os.name");
                if (osName.startsWith("Windows")) {
                    // Use original value which is often more "complete"
                    // E.g. "Windows Server 2012"
                    return osName;
                }
                return "Windows";
            }
            default: throw new InternalError("missing case for " + os);
        }
    }

    private static String realArch() {
        Architecture arch = Architecture.current();
        switch (arch) {
            case X64: return "x86_64";
            case X86: return "x86";
            case AARCH64: return "aarch64";
            case RISCV64: return "riscv64";
            case ARM: return "arm";
            case S390: return "s390";
            case PPC64: return "ppc64";
            case OTHER: return "other";
            default: throw new InternalError("missing case for " + arch);
        }
    }
}