/*

 * Copyright (c) 2010, 2013, 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 jdk.nashorn.internal.runtime;

import static jdk.internal.org.objectweb.asm.Opcodes.V1_7;

import static jdk.nashorn.internal.codegen.CompilerConstants.CONSTANTS;

import static jdk.nashorn.internal.codegen.CompilerConstants.CREATE_PROGRAM_FUNCTION;

import static jdk.nashorn.internal.codegen.CompilerConstants.SOURCE;

import static jdk.nashorn.internal.codegen.CompilerConstants.STRICT_MODE;

import static jdk.nashorn.internal.runtime.CodeStore.newCodeStore;

import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;

import static jdk.nashorn.internal.runtime.ScriptRuntime.UNDEFINED;

import static jdk.nashorn.internal.runtime.Source.sourceFor;

import java.io.File;

import java.io.IOException;

import java.io.PrintWriter;

import java.lang.invoke.MethodHandle;

import java.lang.invoke.MethodHandles;

import java.lang.invoke.MethodType;

import java.lang.invoke.SwitchPoint;

import java.lang.ref.Reference;

import java.lang.ref.ReferenceQueue;

import java.lang.ref.SoftReference;

import java.lang.ref.WeakReference;

import java.lang.reflect.Field;

import java.lang.reflect.Modifier;

import java.net.MalformedURLException;

import java.net.URL;

import java.security.AccessControlContext;

import java.security.AccessController;

import java.security.CodeSigner;

import java.security.CodeSource;

import java.security.Permissions;

import java.security.PrivilegedAction;

import java.security.PrivilegedActionException;

import java.security.PrivilegedExceptionAction;

import java.security.ProtectionDomain;

import java.util.Collection;

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.Objects;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.atomic.AtomicLong;

import java.util.concurrent.atomic.AtomicReference;

import java.util.concurrent.atomic.LongAdder;

import java.util.function.Consumer;

import java.util.function.Supplier;

import java.util.logging.Level;

import javax.script.ScriptContext;

import javax.script.ScriptEngine;

import jdk.internal.org.objectweb.asm.ClassReader;

import jdk.internal.org.objectweb.asm.ClassWriter;

import jdk.internal.org.objectweb.asm.Opcodes;

import jdk.internal.org.objectweb.asm.util.CheckClassAdapter;

import jdk.nashorn.api.scripting.ClassFilter;

import jdk.nashorn.api.scripting.ScriptObjectMirror;

import jdk.nashorn.internal.codegen.Compiler;

import jdk.nashorn.internal.codegen.Compiler.CompilationPhases;

import jdk.nashorn.internal.codegen.ObjectClassGenerator;

import jdk.nashorn.internal.ir.FunctionNode;

import jdk.nashorn.internal.ir.debug.ASTWriter;

import jdk.nashorn.internal.ir.debug.PrintVisitor;

import jdk.nashorn.internal.lookup.MethodHandleFactory;

import jdk.nashorn.internal.objects.Global;

import jdk.nashorn.internal.parser.Parser;

import jdk.nashorn.internal.runtime.events.RuntimeEvent;

import jdk.nashorn.internal.runtime.logging.DebugLogger;

import jdk.nashorn.internal.runtime.logging.Loggable;

import jdk.nashorn.internal.runtime.logging.Logger;

import jdk.nashorn.internal.runtime.options.LoggingOption.LoggerInfo;

import jdk.nashorn.internal.runtime.options.Options;

import sun.misc.Unsafe;

/**

 * This class manages the global state of execution. Context is immutable.

 */

public final class Context {

    // nashorn specific security runtime access permission names

    /**

     * Permission needed to pass arbitrary nashorn command line options when creating Context.

     */

    public static final String NASHORN_SET_CONFIG      = "nashorn.setConfig";

    /**

     * Permission needed to create Nashorn Context instance.

     */

    public static final String NASHORN_CREATE_CONTEXT  = "nashorn.createContext";

    /**

     * Permission needed to create Nashorn Global instance.

     */

    public static final String NASHORN_CREATE_GLOBAL   = "nashorn.createGlobal";

    /**

     * Permission to get current Nashorn Context from thread local storage.

     */

    public static final String NASHORN_GET_CONTEXT     = "nashorn.getContext";

    /**

     * Permission to use Java reflection/jsr292 from script code.

     */

    public static final String NASHORN_JAVA_REFLECTION = "nashorn.JavaReflection";

    /**

     * Permission to enable nashorn debug mode.

     */

    public static final String NASHORN_DEBUG_MODE = "nashorn.debugMode";

    // nashorn load psuedo URL prefixes

    private static final String LOAD_CLASSPATH = "classpath:";

    private static final String LOAD_FX = "fx:";

    private static final String LOAD_NASHORN = "nashorn:";

    private static final MethodHandles.Lookup LOOKUP = MethodHandles.lookup();

    private static final MethodType CREATE_PROGRAM_FUNCTION_TYPE = MethodType.methodType(ScriptFunction.class, ScriptObject.class);

    private static final LongAdder NAMED_INSTALLED_SCRIPT_COUNT = new LongAdder();

    private static final LongAdder ANONYMOUS_INSTALLED_SCRIPT_COUNT = new LongAdder();

    private static final boolean DISABLE_VM_ANONYMOUS_CLASSES = Options.getBooleanProperty("nashorn.disableVmAnonymousClasses");

    /**

     * Should scripts use only object slots for fields, or dual long/object slots? The default

     * behaviour is to couple this to optimistic types, using dual representation if optimistic types are enabled

     * and single field representation otherwise. This can be overridden by setting either the "nashorn.fields.objects"

     * or "nashorn.fields.dual" system property.

     */

    private final FieldMode fieldMode;

    private static enum FieldMode {

        /** Value for automatic field representation depending on optimistic types setting */

        AUTO,

        /** Value for object field representation regardless of optimistic types setting */

        OBJECTS,

        /** Value for dual primitive/object field representation regardless of optimistic types setting */

        DUAL

    }

    /**

     * Keeps track of which builtin prototypes and properties have been relinked

     * Currently we are conservative and associate the name of a builtin class with all

     * its properties, so it's enough to invalidate a property to break all assumptions

     * about a prototype. This can be changed to a more fine grained approach, but no one

     * ever needs this, given the very rare occurrence of swapping out only parts of

     * a builtin v.s. the entire builtin object

     */

    private final Map<String, SwitchPoint> builtinSwitchPoints = new HashMap<>();

    /* Force DebuggerSupport to be loaded. */

    static {

        DebuggerSupport.FORCELOAD = true;

    }

    static long getNamedInstalledScriptCount() {

        return NAMED_INSTALLED_SCRIPT_COUNT.sum();

    }

    static long getAnonymousInstalledScriptCount() {

        return ANONYMOUS_INSTALLED_SCRIPT_COUNT.sum();

    }

    /**

     * ContextCodeInstaller that has the privilege of installing classes in the Context.

     * Can only be instantiated from inside the context and is opaque to other classes

     */

    private abstract static class ContextCodeInstaller implements CodeInstaller {

        final Context context;

        final CodeSource codeSource;

        ContextCodeInstaller(final Context context, final CodeSource codeSource) {

            this.context = context;

            this.codeSource = codeSource;

        }

        @Override

        public Context getContext() {

            return context;

        }

        @Override

        public void initialize(final Collection<Class<?>> classes, final Source source, final Object[] constants) {

            try {

                AccessController.doPrivileged(new PrivilegedExceptionAction<Void>() {

                    @Override

                    public Void run() throws Exception {

                        for (final Class<?> clazz : classes) {

                            //use reflection to write source and constants table to installed classes

                            final Field sourceField = clazz.getDeclaredField(SOURCE.symbolName());

                            sourceField.setAccessible(true);

                            sourceField.set(null, source);

                            final Field constantsField = clazz.getDeclaredField(CONSTANTS.symbolName());

                            constantsField.setAccessible(true);

                            constantsField.set(null, constants);

                        }

                        return null;

                    }

                });

            } catch (final PrivilegedActionException e) {

                throw new RuntimeException(e);

            }

        }

        @Override

        public void verify(final byte[] code) {

            context.verify(code);

        }

        @Override

        public long getUniqueScriptId() {

            return context.getUniqueScriptId();

        }

        @Override

        public void storeScript(final String cacheKey, final Source source, final String mainClassName,

                                final Map<String,byte[]> classBytes, final Map<Integer, FunctionInitializer> initializers,

                                final Object[] constants, final int compilationId) {

            if (context.codeStore != null) {

                context.codeStore.store(cacheKey, source, mainClassName, classBytes, initializers, constants, compilationId);

            }

        }

        @Override

        public StoredScript loadScript(final Source source, final String functionKey) {

            if (context.codeStore != null) {

                return context.codeStore.load(source, functionKey);

            }

            return null;

        }

        @Override

        public boolean isCompatibleWith(final CodeInstaller other) {

            if (other instanceof ContextCodeInstaller) {

                final ContextCodeInstaller cci = (ContextCodeInstaller)other;

                return cci.context == context && cci.codeSource == codeSource;

            }

            return false;

        }

    }

    private static class NamedContextCodeInstaller extends ContextCodeInstaller {

        private final ScriptLoader loader;

        private int usageCount = 0;

        private int bytesDefined = 0;

        // We reuse this installer for 10 compilations or 200000 defined bytes. Usually the first condition

        // will occur much earlier, the second is a safety measure for very large scripts/functions.

        private final static int MAX_USAGES = 10;

        private final static int MAX_BYTES_DEFINED = 200_000;

        private NamedContextCodeInstaller(final Context context, final CodeSource codeSource, final ScriptLoader loader) {

            super(context, codeSource);

            this.loader = loader;

        }

        @Override

        public Class<?> install(final String className, final byte[] bytecode) {

            usageCount++;

            bytesDefined += bytecode.length;

            NAMED_INSTALLED_SCRIPT_COUNT.increment();

            return loader.installClass(Compiler.binaryName(className), bytecode, codeSource);

        }

        @Override

        public CodeInstaller getOnDemandCompilationInstaller() {

            // Reuse this installer if we're within our limits.

            if (usageCount < MAX_USAGES && bytesDefined < MAX_BYTES_DEFINED) {

                return this;

            }

            return new NamedContextCodeInstaller(context, codeSource, context.createNewLoader());

        }

        @Override

        public CodeInstaller getMultiClassCodeInstaller() {

            // This installer is perfectly suitable for installing multiple classes that reference each other

            // as it produces classes with resolvable names, all defined in a single class loader.

            return this;

        }

    }

    private final Map<CodeSource, Reference<Class<?>>> anonymousHostClasses = new ConcurrentHashMap<>();

    private static final class AnonymousContextCodeInstaller extends ContextCodeInstaller {

        private static final Unsafe UNSAFE = getUnsafe();

        private static final String ANONYMOUS_HOST_CLASS_NAME = Compiler.SCRIPTS_PACKAGE.replace('/', '.') + ".AnonymousHost";

        private static final byte[] ANONYMOUS_HOST_CLASS_BYTES = getAnonymousHostClassBytes();

        private final Class<?> hostClass;

        private AnonymousContextCodeInstaller(final Context context, final CodeSource codeSource) {

            super(context, codeSource);

            hostClass = getAnonymousHostClass();

        }

        @Override

        public Class<?> install(final String className, final byte[] bytecode) {

            ANONYMOUS_INSTALLED_SCRIPT_COUNT.increment();

            return UNSAFE.defineAnonymousClass(hostClass, bytecode, null);

        }

        @Override

        public CodeInstaller getOnDemandCompilationInstaller() {

            // This code loader can be indefinitely reused for on-demand recompilations for the same code source.

            return this;

        }

        @Override

        public CodeInstaller getMultiClassCodeInstaller() {

            // This code loader can not be used to install multiple classes that reference each other, as they

            // would have no resolvable names. Therefore, in such situation we must revert to an installer that

            // produces named classes.

            return new NamedContextCodeInstaller(context, codeSource, context.createNewLoader());

        }

        private Class<?> getAnonymousHostClass() {

            final Reference<Class<?>> ref = context.anonymousHostClasses.get(codeSource);

            if (ref != null) {

                final Class<?> existingHostClass = ref.get();

                if (existingHostClass != null) {

                    return existingHostClass;

                }

            }

            final Class<?> newHostClass = context.createNewLoader().installClass(ANONYMOUS_HOST_CLASS_NAME, ANONYMOUS_HOST_CLASS_BYTES, codeSource);

            context.anonymousHostClasses.put(codeSource, new WeakReference<>(newHostClass));

            return newHostClass;

        }

        private static final byte[] getAnonymousHostClassBytes() {

            final ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);

            cw.visit(V1_7, Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT, ANONYMOUS_HOST_CLASS_NAME.replace('.', '/'), null, "java/lang/Object", null);

            cw.visitEnd();

            return cw.toByteArray();

        }

        private static Unsafe getUnsafe() {

            return AccessController.doPrivileged(new PrivilegedAction<Unsafe>() {

                @Override

                public Unsafe run() {

                    try {

                        final Field theUnsafeField = Unsafe.class.getDeclaredField("theUnsafe");

                        theUnsafeField.setAccessible(true);

                        return (Unsafe)theUnsafeField.get(null);

                    } catch (final ReflectiveOperationException e) {

                        throw new RuntimeException(e);

                    }

                }

            });

        }

    }

    /** Is Context global debug mode enabled ? */

    public static final boolean DEBUG = Options.getBooleanProperty("nashorn.debug");

    private static final ThreadLocal<Global> currentGlobal = new ThreadLocal<>();

    // in-memory cache for loaded classes

    private ClassCache classCache;

    // persistent code store

    private CodeStore codeStore;

    // A factory for linking global properties as constant method handles. It is created when the first Global

    // is created, and invalidated forever once the second global is created.

    private final AtomicReference<GlobalConstants> globalConstantsRef = new AtomicReference<>();

    /**

     * Get the current global scope

     * @return the current global scope

     */

    public static Global getGlobal() {

        // This class in a package.access protected package.

        // Trusted code only can call this method.

        return currentGlobal.get();

    }

    /**

     * Set the current global scope

     * @param global the global scope

     */

    public static void setGlobal(final ScriptObject global) {

        if (global != null && !(global instanceof Global)) {

            throw new IllegalArgumentException("not a global!");

        }

        setGlobal((Global)global);

    }

    /**

     * Set the current global scope

     * @param global the global scope

     */

    public static void setGlobal(final Global global) {

        // This class in a package.access protected package.

        // Trusted code only can call this method.

        assert getGlobal() != global;

        //same code can be cached between globals, then we need to invalidate method handle constants

        if (global != null) {

            final GlobalConstants globalConstants = getContext(global).getGlobalConstants();

            if (globalConstants != null) {

                globalConstants.invalidateAll();

            }

        }

        currentGlobal.set(global);

    }

    /**

     * Get context of the current global

     * @return current global scope's context.

     */

    public static Context getContext() {

        final SecurityManager sm = System.getSecurityManager();

        if (sm != null) {

            sm.checkPermission(new RuntimePermission(NASHORN_GET_CONTEXT));

        }

        return getContextTrusted();

    }

    /**

     * Get current context's error writer

     *

     * @return error writer of the current context

     */

    public static PrintWriter getCurrentErr() {

        final ScriptObject global = getGlobal();

        return (global != null)? global.getContext().getErr() : new PrintWriter(System.err);

    }

    /**

     * Output text to this Context's error stream

     * @param str text to write

     */

    public static void err(final String str) {

        err(str, true);

    }

    /**

     * Output text to this Context's error stream, optionally with

     * a newline afterwards

     *

     * @param str  text to write

     * @param crlf write a carriage return/new line after text

     */

    public static void err(final String str, final boolean crlf) {

        final PrintWriter err = Context.getCurrentErr();

        if (err != null) {

            if (crlf) {

                err.println(str);

            } else {

                err.print(str);

            }

        }

    }

    /** Current environment. */

    private final ScriptEnvironment env;

    /** is this context in strict mode? Cached from env. as this is used heavily. */

    final boolean _strict;

    /** class loader to resolve classes from script. */

    private final ClassLoader  appLoader;

    /** Class loader to load classes from -classpath option, if set. */

    private final ClassLoader  classPathLoader;

    /** Class loader to load classes compiled from scripts. */

    private final ScriptLoader scriptLoader;

    /** Current error manager. */

    private final ErrorManager errors;