/*

 * Copyright (c) 2010, 2014, 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.nashorn.internal.lookup.Lookup.MH;

import java.io.IOException;

import java.lang.invoke.MethodHandle;

import java.lang.invoke.MethodHandles;

import java.lang.invoke.MethodType;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Map;

import java.util.Set;

import java.util.TreeMap;

import jdk.internal.dynalink.support.NameCodec;

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.ObjectClassGenerator.AllocatorDescriptor;

import jdk.nashorn.internal.codegen.OptimisticTypesPersistence;

import jdk.nashorn.internal.codegen.TypeMap;

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

import jdk.nashorn.internal.ir.FunctionNode;

import jdk.nashorn.internal.ir.LexicalContext;

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

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.logging.DebugLogger;

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

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

/**

 * 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$";

    /** 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;

    /** 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<ScriptEnvironment> 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 allocationDescriptor descriptor 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<ScriptEnvironment> installer,

        final AllocatorDescriptor allocationDescriptor,

        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.get(allocationDescriptor);

        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);

        if (depth == null) {

            return -1;

        }

        return 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<ScriptEnvironment> inst) {

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

            this.source    = src;

            this.installer = inst;

        } else if (this.source != src || this.installer != 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;

        }

        return flags;

    }

    @Override

    PropertyMap getAllocatorMap() {

        return allocationStrategy.getAllocatorMap();

    }

    @Override

    ScriptObject allocate(final PropertyMap map) {

        return allocationStrategy.allocate(map);

    }

    FunctionNode reparse() {

        // NOTE: If we aren't recompiling the top-level program, we decrease functionNodeId 'cause we'll have a synthetic program node

        final int descPosition = Token.descPosition(token);

        final Context context = Context.getContextTrusted();

        final Parser parser = new Parser(

            context.getEnv(),

            source,

            new Context.ThrowErrorManager(),

            isStrict(),

            lineNumber - 1,

            context.getLogger(Parser.class)); // source starts at line 0, so even though lineNumber is the correct declaration line, back off one to make it exclusive

        if (getFunctionFlag(FunctionNode.IS_ANONYMOUS)) {

            parser.setFunctionName(functionName);

        }

        parser.setReparsedFunction(this);

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

                Token.descLength(token), true);

        // 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 boolean getFunctionFlag(final int flag) {

        return (functionFlags & flag) != 0;

    }

    private boolean isProgram() {

        return getFunctionFlag(FunctionNode.IS_PROGRAM);

    }

    TypeMap typeMap(final MethodType fnCallSiteType) {

        if (fnCallSiteType == null) {

            return null;

        }

        if (CompiledFunction.isVarArgsType(fnCallSiteType)) {

            return null;

        }

        return new TypeMap(functionNodeId, explicitParams(fnCallSiteType), needsCallee());

    }

    private static ScriptObject newLocals(final ScriptObject runtimeScope) {

        final ScriptObject locals = Global.newEmptyInstance();

        locals.setProto(runtimeScope);

        return locals;

    }

    private Compiler getCompiler(final FunctionNode fn, final MethodType actualCallSiteType, final ScriptObject runtimeScope) {

        return getCompiler(fn, actualCallSiteType, newLocals(runtimeScope), null, null);

    }

    Compiler getCompiler(final FunctionNode functionNode, final MethodType actualCallSiteType,

            final ScriptObject runtimeScope, final Map<Integer, Type> invalidatedProgramPoints,

            final int[] continuationEntryPoints) {

        final TypeMap typeMap = typeMap(actualCallSiteType);

        final Type[] paramTypes = typeMap == null ? null : typeMap.getParameterTypes(functionNodeId);

        final Object typeInformationFile = OptimisticTypesPersistence.getLocationDescriptor(source, functionNodeId, paramTypes);

        final Context context = Context.getContextTrusted();

        return new Compiler(

                context,

                context.getEnv(),

                installer,

                functionNode.getSource(),  // source

                context.getErrorManager(),

                isStrict() | functionNode.isStrict(), // is strict

                true,       // is on demand

                this,       // compiledFunction, i.e. this RecompilableScriptFunctionData

                typeMap,    // type map

                getEffectiveInvalidatedProgramPoints(invalidatedProgramPoints, typeInformationFile), // invalidated program points

                typeInformationFile,

                continuationEntryPoints, // continuation entry points

                runtimeScope); // runtime scope

    }

    /**

     * If the function being compiled already has its own invalidated program points map, use it. Otherwise, attempt to

     * load invalidated program points map from the persistent type info cache.

     * @param invalidatedProgramPoints the function's current invalidated program points map. Null if the function

     * doesn't have it.

     * @param typeInformationFile the object describing the location of the persisted type information.

     * @return either the existing map, or a loaded map from the persistent type info cache, or a new empty map if

     * neither an existing map or a persistent cached type info is available.

     */

    private static Map<Integer, Type> getEffectiveInvalidatedProgramPoints(

            final Map<Integer, Type> invalidatedProgramPoints, final Object typeInformationFile) {

        if(invalidatedProgramPoints != null) {

            return invalidatedProgramPoints;

        }

        final Map<Integer, Type> loadedProgramPoints = OptimisticTypesPersistence.load(typeInformationFile);

        return loadedProgramPoints != null ? loadedProgramPoints : new TreeMap<Integer, Type>();

    }

    private FunctionInitializer compileTypeSpecialization(final MethodType actualCallSiteType, final ScriptObject runtimeScope, final boolean persist) {

        // We're creating an empty script object for holding local variables. AssignSymbols will populate it with

        // explicit Undefined values for undefined local variables (see AssignSymbols#defineSymbol() and

        // CompilationEnvironment#declareLocalSymbol()).

        if (log.isEnabled()) {

            log.info("Type specialization of '", functionName, "' signature: ", actualCallSiteType);

        }

        final boolean persistentCache = usePersistentCodeCache() && persist;

        String cacheKey = null;

        if (persistentCache) {

            final TypeMap typeMap = typeMap(actualCallSiteType);

            final Type[] paramTypes = typeMap == null ? null : typeMap.getParameterTypes(functionNodeId);

            cacheKey = CodeStore.getCacheKey(functionNodeId, paramTypes);

            final StoredScript script = installer.loadScript(source, cacheKey);

            if (script != null) {

                Compiler.updateCompilationId(script.getCompilationId());

                return install(script);

            }

        }

        final FunctionNode fn = reparse();

        final Compiler compiler = getCompiler(fn, actualCallSiteType, runtimeScope);

        final FunctionNode compiledFn = compiler.compile(fn, CompilationPhases.COMPILE_ALL);

        if (persist && !compiledFn.getFlag(FunctionNode.HAS_APPLY_TO_CALL_SPECIALIZATION)) {

            compiler.persistClassInfo(cacheKey, compiledFn);

        }

        return new FunctionInitializer(compiledFn, compiler.getInvalidatedProgramPoints());

    }

    /**

     * Install this script using the given {@code installer}.

     *

     * @param script the compiled script