/*

 * 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.nashorn.internal.lookup.Lookup.MH;

import java.io.IOException;

import java.io.ObjectOutputStream;

import java.io.Serializable;

import java.lang.invoke.MethodHandle;

import java.lang.invoke.MethodHandles;

import java.lang.invoke.MethodType;

import java.lang.ref.Reference;

import java.lang.ref.SoftReference;

import java.util.Collection;

import java.util.Collections;

import java.util.HashSet;

import java.util.IdentityHashMap;

import java.util.Map;

import java.util.Set;

import java.util.TreeMap;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.LinkedBlockingDeque;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

import jdk.nashorn.internal.codegen.Compiler;

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

import jdk.nashorn.internal.codegen.CompilerConstants;

import jdk.nashorn.internal.codegen.FunctionSignature;

import jdk.nashorn.internal.codegen.Namespace;

import jdk.nashorn.internal.codegen.OptimisticTypesPersistence;

import jdk.nashorn.internal.codegen.TypeMap;

import jdk.nashorn.internal.codegen.types.Type;

import jdk.nashorn.internal.ir.Block;

import jdk.nashorn.internal.ir.ForNode;

import jdk.nashorn.internal.ir.FunctionNode;

import jdk.nashorn.internal.ir.IdentNode;

import jdk.nashorn.internal.ir.LexicalContext;

import jdk.nashorn.internal.ir.Node;

import jdk.nashorn.internal.ir.SwitchNode;

import jdk.nashorn.internal.ir.Symbol;

import jdk.nashorn.internal.ir.TryNode;

import jdk.nashorn.internal.ir.visitor.SimpleNodeVisitor;

import jdk.nashorn.internal.objects.Global;

import jdk.nashorn.internal.parser.Parser;

import jdk.nashorn.internal.parser.Token;

import jdk.nashorn.internal.parser.TokenType;

import jdk.nashorn.internal.runtime.linker.NameCodec;

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.Options;

/**

 * This is a subclass that represents a script function that may be regenerated,

 * for example with specialization based on call site types, or lazily generated.

 * The common denominator is that it can get new invokers during its lifespan,

 * unlike {@code FinalScriptFunctionData}

 */

@Logger(name="recompile")

public final class RecompilableScriptFunctionData extends ScriptFunctionData implements Loggable {

    /** Prefix used for all recompiled script classes */

    public static final String RECOMPILATION_PREFIX = "Recompilation$";

    private static final ExecutorService astSerializerExecutorService = createAstSerializerExecutorService();

    /** Unique function node id for this function node */

    private final int functionNodeId;

    private final String functionName;

    /** The line number where this function begins. */

    private final int lineNumber;

    /** Source from which FunctionNode was parsed. */

    private transient Source source;

    /**

     * Cached form of the AST. Either a {@code SerializedAst} object used by split functions as they can't be

     * reparsed from source, or a soft reference to a {@code FunctionNode} for other functions (it is safe

     * to be cleared as they can be reparsed).

     */

    private volatile transient Object cachedAst;

    /** Token of this function within the source. */

    private final long token;

    /**

     * Represents the allocation strategy (property map, script object class, and method handle) for when

     * this function is used as a constructor. Note that majority of functions (those not setting any this.*

     * properties) will share a single canonical "default strategy" instance.

     */

    private final AllocationStrategy allocationStrategy;

    /**

     * Opaque object representing parser state at the end of the function. Used when reparsing outer function

     * to help with skipping parsing inner functions.

     */

    private final Object endParserState;

    /** Code installer used for all further recompilation/specialization of this ScriptFunction */

    private transient CodeInstaller installer;

    private final Map<Integer, RecompilableScriptFunctionData> nestedFunctions;

    /** Id to parent function if one exists */

    private RecompilableScriptFunctionData parent;

    /** Copy of the {@link FunctionNode} flags. */

    private final int functionFlags;

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

    private transient DebugLogger log;

    private final Map<String, Integer> externalScopeDepths;

    private final Set<String> internalSymbols;

    private static final int GET_SET_PREFIX_LENGTH = "*et ".length();

    private static final long serialVersionUID = 4914839316174633726L;

    /**

     * Constructor - public as scripts use it

     *

     * @param functionNode        functionNode that represents this function code

     * @param installer           installer for code regeneration versions of this function

     * @param allocationStrategy  strategy for the allocation behavior when this function is used as a constructor

     * @param nestedFunctions     nested function map

     * @param externalScopeDepths external scope depths

     * @param internalSymbols     internal symbols to method, defined in its scope

     */

    public RecompilableScriptFunctionData(

        final FunctionNode functionNode,

        final CodeInstaller installer,

        final AllocationStrategy allocationStrategy,

        final Map<Integer, RecompilableScriptFunctionData> nestedFunctions,

        final Map<String, Integer> externalScopeDepths,

        final Set<String> internalSymbols) {

        super(functionName(functionNode),

              Math.min(functionNode.getParameters().size(), MAX_ARITY),

              getDataFlags(functionNode));

        this.functionName        = functionNode.getName();

        this.lineNumber          = functionNode.getLineNumber();

        this.functionFlags       = functionNode.getFlags() | (functionNode.needsCallee() ? FunctionNode.NEEDS_CALLEE : 0);

        this.functionNodeId      = functionNode.getId();

        this.source              = functionNode.getSource();

        this.endParserState      = functionNode.getEndParserState();

        this.token               = tokenFor(functionNode);

        this.installer           = installer;

        this.allocationStrategy  = allocationStrategy;

        this.nestedFunctions     = smallMap(nestedFunctions);

        this.externalScopeDepths = smallMap(externalScopeDepths);

        this.internalSymbols     = smallSet(new HashSet<>(internalSymbols));

        for (final RecompilableScriptFunctionData nfn : nestedFunctions.values()) {

            assert nfn.getParent() == null;

            nfn.setParent(this);

        }

        createLogger();

    }

    private static <K, V> Map<K, V> smallMap(final Map<K, V> map) {

        if (map == null || map.isEmpty()) {

            return Collections.emptyMap();

        } else if (map.size() == 1) {

            final Map.Entry<K, V> entry = map.entrySet().iterator().next();

            return Collections.singletonMap(entry.getKey(), entry.getValue());

        } else {

            return map;

        }

    }

    private static <T> Set<T> smallSet(final Set<T> set) {

        if (set == null || set.isEmpty()) {

            return Collections.emptySet();

        } else if (set.size() == 1) {

            return Collections.singleton(set.iterator().next());

        } else {

            return set;

        }

    }

    @Override

    public DebugLogger getLogger() {

        return log;

    }

    @Override

    public DebugLogger initLogger(final Context ctxt) {

        return ctxt.getLogger(this.getClass());

    }

    /**

     * Check if a symbol is internally defined in a function. For example

     * if "undefined" is internally defined in the outermost program function,

     * it has not been reassigned or overridden and can be optimized

     *

     * @param symbolName symbol name

     * @return true if symbol is internal to this ScriptFunction

     */

    public boolean hasInternalSymbol(final String symbolName) {

        return internalSymbols.contains(symbolName);

    }

    /**

     * Return the external symbol table

     * @param symbolName symbol name

     * @return the external symbol table with proto depths

     */

    public int getExternalSymbolDepth(final String symbolName) {

        final Integer depth = externalScopeDepths.get(symbolName);

        return depth == null ? -1 : depth;

    }

    /**

     * Returns the names of all external symbols this function uses.

     * @return the names of all external symbols this function uses.

     */

    public Set<String> getExternalSymbolNames() {

        return Collections.unmodifiableSet(externalScopeDepths.keySet());

    }

    /**

     * Returns the opaque object representing the parser state at the end of this function's body, used to

     * skip parsing this function when reparsing its containing outer function.

     * @return the object representing the end parser state

     */

    public Object getEndParserState() {

        return endParserState;

    }

    /**

     * Get the parent of this RecompilableScriptFunctionData. If we are

     * a nested function, we have a parent. Note that "null" return value

     * can also mean that we have a parent but it is unknown, so this can

     * only be used for conservative assumptions.

     * @return parent data, or null if non exists and also null IF UNKNOWN.

     */

    public RecompilableScriptFunctionData getParent() {

        return parent;

    }

    void setParent(final RecompilableScriptFunctionData parent) {

        this.parent = parent;

    }

    @Override

    String toSource() {

        if (source != null && token != 0) {

            return source.getString(Token.descPosition(token), Token.descLength(token));

        }

        return "function " + (name == null ? "" : name) + "() { [native code] }";

    }

    /**

     * Initialize transient fields on deserialized instances

     *

     * @param src source

     * @param inst code installer

     */

    public void initTransients(final Source src, final CodeInstaller inst) {

        if (this.source == null && this.installer == null) {

            this.source    = src;

            this.installer = inst;

            for (final RecompilableScriptFunctionData nested : nestedFunctions.values()) {

                nested.initTransients(src, inst);

            }

        } else if (this.source != src || !this.installer.isCompatibleWith(inst)) {

            // Existing values must be same as those passed as parameters

            throw new IllegalArgumentException();

        }

    }

    @Override

    public String toString() {

        return super.toString() + '@' + functionNodeId;

    }

    @Override

    public String toStringVerbose() {

        final StringBuilder sb = new StringBuilder();

        sb.append("fnId=").append(functionNodeId).append(' ');

        if (source != null) {

            sb.append(source.getName())

                .append(':')

                .append(lineNumber)

                .append(' ');

        }

        return sb.toString() + super.toString();

    }

    @Override

    public String getFunctionName() {

        return functionName;

    }

    @Override

    public boolean inDynamicContext() {

        return getFunctionFlag(FunctionNode.IN_DYNAMIC_CONTEXT);

    }

    private static String functionName(final FunctionNode fn) {

        if (fn.isAnonymous()) {

            return "";

        }

        final FunctionNode.Kind kind = fn.getKind();

        if (kind == FunctionNode.Kind.GETTER || kind == FunctionNode.Kind.SETTER) {

            final String name = NameCodec.decode(fn.getIdent().getName());

            return name.substring(GET_SET_PREFIX_LENGTH);

        }

        return fn.getIdent().getName();

    }

    private static long tokenFor(final FunctionNode fn) {

        final int  position  = Token.descPosition(fn.getFirstToken());

        final long lastToken = Token.withDelimiter(fn.getLastToken());

        // EOL uses length field to store the line number

        final int  length    = Token.descPosition(lastToken) - position + (Token.descType(lastToken) == TokenType.EOL ? 0 : Token.descLength(lastToken));

        return Token.toDesc(TokenType.FUNCTION, position, length);

    }

    private static int getDataFlags(final FunctionNode functionNode) {

        int flags = IS_CONSTRUCTOR;

        if (functionNode.isStrict()) {

            flags |= IS_STRICT;

        }

        if (functionNode.needsCallee()) {

            flags |= NEEDS_CALLEE;

        }

        if (functionNode.usesThis() || functionNode.hasEval()) {

            flags |= USES_THIS;

        }

        if (functionNode.isVarArg()) {

            flags |= IS_VARIABLE_ARITY;

        }

        if (functionNode.getKind() == FunctionNode.Kind.GETTER || functionNode.getKind() == FunctionNode.Kind.SETTER) {

            flags |= IS_PROPERTY_ACCESSOR;

        }

        if (functionNode.isMethod() || functionNode.isClassConstructor()) {

            flags |= IS_ES6_METHOD;

        }

        return flags;

    }

    @Override

    PropertyMap getAllocatorMap(final ScriptObject prototype) {

        return allocationStrategy.getAllocatorMap(prototype);

    }

    @Override

    ScriptObject allocate(final PropertyMap map) {

        return allocationStrategy.allocate(map);

    }

    FunctionNode reparse() {

        final FunctionNode cachedFunction = getCachedAst();

        if (cachedFunction != null) {

            assert cachedFunction.isCached();

            return cachedFunction;

        }

        final int descPosition = Token.descPosition(token);

        final Context context = Context.getContextTrusted();

        final Parser parser = new Parser(

            context.getEnv(),

            source,

            new Context.ThrowErrorManager(),

            isStrict(),

            // source starts at line 0, so even though lineNumber is the correct declaration line, back off

            // one to make it exclusive

            lineNumber - 1,

            context.getLogger(Parser.class));

        if (getFunctionFlag(FunctionNode.IS_ANONYMOUS)) {

            parser.setFunctionName(functionName);

        }

        parser.setReparsedFunction(this);

        final FunctionNode program = parser.parse(CompilerConstants.PROGRAM.symbolName(), descPosition,

                Token.descLength(token), flags);

        // Parser generates a program AST even if we're recompiling a single function, so when we are only

        // recompiling a single function, extract it from the program.

        return (isProgram() ? program : extractFunctionFromScript(program)).setName(null, functionName);

    }

    private FunctionNode getCachedAst() {

        final Object lCachedAst = cachedAst;

        // Are we softly caching the AST?

        if (lCachedAst instanceof Reference<?>) {

            final FunctionNode fn = (FunctionNode)((Reference<?>)lCachedAst).get();

            if (fn != null) {

                // Yes we are - this is fast

                return cloneSymbols(fn);

            }

        // Are we strongly caching a serialized AST (for split functions only)?

        } else if (lCachedAst instanceof SerializedAst) {

            final SerializedAst serializedAst = (SerializedAst)lCachedAst;

            // Even so, are we also softly caching the AST?

            final FunctionNode cachedFn = serializedAst.cachedAst == null ? null : serializedAst.cachedAst.get();

            if (cachedFn != null) {

                // Yes we are - this is fast

                return cloneSymbols(cachedFn);

            }

            final FunctionNode deserializedFn = deserialize(serializedAst.serializedAst);

            // Softly cache after deserialization, maybe next time we won't need to deserialize

            serializedAst.cachedAst = new SoftReference<>(deserializedFn);

            return deserializedFn;

        }

        // No cached representation; return null for reparsing

        return null;

    }

    /**

     * Sets the AST to cache in this function

     * @param astToCache the new AST to cache

     */

    public void setCachedAst(final FunctionNode astToCache) {

        assert astToCache.getId() == functionNodeId; // same function

        assert !(cachedAst instanceof SerializedAst); // Can't overwrite serialized AST

        final boolean isSplit = astToCache.isSplit();

        // If we're caching a split function, we're doing it in the eager pass, hence there can be no other

        // cached representation already. In other words, isSplit implies cachedAst == null.

        assert !isSplit || cachedAst == null; //

        final FunctionNode symbolClonedAst = cloneSymbols(astToCache);

        final Reference<FunctionNode> ref = new SoftReference<>(symbolClonedAst);

        cachedAst = ref;

        // Asynchronously serialize split functions.

        if (isSplit) {

            astSerializerExecutorService.execute(() -> {

                cachedAst = new SerializedAst(symbolClonedAst, ref);

            });

        }

    }

    /**

     * Creates the AST serializer executor service used for in-memory serialization of split functions' ASTs.

     * It is created with an unbounded queue (so it can queue any number of pending tasks). Its core and max

     * threads is the same, but they are all allowed to time out so when there's no work, they can all go

     * away. The threads will be daemons, and they will time out if idle for a minute. Their priority is also

     * slightly lower than normal priority as we'd prefer the CPU to keep running the program; serializing

     * split function is a memory conservation measure (it allows us to release the AST), it can wait a bit.

     * @return an executor service with above described characteristics.

     */

    private static ExecutorService createAstSerializerExecutorService() {

        final int threads = Math.max(1, Options.getIntProperty("nashorn.serialize.threads", Runtime.getRuntime().availableProcessors() / 2));

        final ThreadPoolExecutor service = new ThreadPoolExecutor(threads, threads, 1, TimeUnit.MINUTES, new LinkedBlockingDeque<>(),

            (r) -> {

                final Thread t = new Thread(r, "Nashorn AST Serializer");